Contract

/**
 *Submitted for verification at Etherscan.io on 2021-06-15
*/

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

// File contracts/dependencies/openzeppelin/contracts/SafeMath.sol

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;

/**
 * @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 subtraction of two unsigned integers, reverting on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, 'SafeMath: subtraction overflow');
  }

  /**
   * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
   * overflow (when the result is negative).
   *
   * Counterpart to Solidity's `-` operator.
   *
   * Requirements:
   * - Subtraction cannot overflow.
   */
  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 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/dependencies/openzeppelin/contracts/IERC20.sol

pragma solidity 0.6.12;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the amount of tokens owned by `account`.
   */
  function balanceOf(address account) external view returns (uint256);

  /**
   * @dev Moves `amount` tokens from the caller's account to `recipient`.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transfer(address recipient, uint256 amount) external returns (bool);

  /**
   * @dev Returns the remaining number of tokens that `spender` will be
   * allowed to spend on behalf of `owner` through {transferFrom}. This is
   * zero by default.
   *
   * This value changes when {approve} or {transferFrom} are called.
   */
  function allowance(address owner, address spender) external view returns (uint256);

  /**
   * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * IMPORTANT: Beware that changing an allowance with this method brings the risk
   * that someone may use both the old and the new allowance by unfortunate
   * transaction ordering. One possible solution to mitigate this race
   * condition is to first reduce the spender's allowance to 0 and set the
   * desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   *
   * Emits an {Approval} event.
   */
  function approve(address spender, uint256 amount) external returns (bool);

  /**
   * @dev Moves `amount` tokens from `sender` to `recipient` using the
   * allowance mechanism. `amount` is then deducted from the caller's
   * allowance.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) external returns (bool);

  /**
   * @dev Emitted when `value` tokens are moved from one account (`from`) to
   * another (`to`).
   *
   * Note that `value` may be zero.
   */
  event Transfer(address indexed from, address indexed to, uint256 value);

  /**
   * @dev Emitted when the allowance of a `spender` for an `owner` is set by
   * a call to {approve}. `value` is the new allowance.
   */
  event Approval(address indexed owner, address indexed spender, uint256 value);
}


// File contracts/dependencies/openzeppelin/contracts/IERC20Detailed.sol

pragma solidity 0.6.12;

interface IERC20Detailed is IERC20 {
  function name() external view returns (string memory);

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

  function decimals() external view returns (uint8);
}


// File contracts/dependencies/openzeppelin/contracts/Address.sol

pragma solidity 0.6.12;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
  /**
   * @dev Returns true if `account` is a contract.
   *
   * [IMPORTANT]
   * ====
   * It is unsafe to assume that an address for which this function returns
   * false is an externally-owned account (EOA) and not a contract.
   *
   * Among others, `isContract` will return false for the following
   * types of addresses:
   *
   *  - an externally-owned account
   *  - a contract in construction
   *  - an address where a contract will be created
   *  - an address where a contract lived, but was destroyed
   * ====
   */
  function isContract(address account) internal view returns (bool) {
    // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
    // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
    // for accounts without code, i.e. `keccak256('')`
    bytes32 codehash;
    bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
    // solhint-disable-next-line no-inline-assembly
    assembly {
      codehash := extcodehash(account)
    }
    return (codehash != accountHash && codehash != 0x0);
  }

  /**
   * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
   * `recipient`, forwarding all available gas and reverting on errors.
   *
   * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
   * of certain opcodes, possibly making contracts go over the 2300 gas limit
   * imposed by `transfer`, making them unable to receive funds via
   * `transfer`. {sendValue} removes this limitation.
   *
   * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
   *
   * IMPORTANT: because control is transferred to `recipient`, care must be
   * taken to not create reentrancy vulnerabilities. Consider using
   * {ReentrancyGuard} or the
   * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
   */
  function sendValue(address payable recipient, uint256 amount) internal {
    require(address(this).balance >= amount, 'Address: insufficient balance');

    // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
    (bool success, ) = recipient.call{value: amount}('');
    require(success, 'Address: unable to send value, recipient may have reverted');
  }
}


// File contracts/dependencies/openzeppelin/contracts/SafeERC20.sol


pragma solidity 0.6.12;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
  using SafeMath for uint256;
  using Address for address;

  function safeTransfer(
    IERC20 token,
    address to,
    uint256 value
  ) internal {
    callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
  }

  function safeTransferFrom(
    IERC20 token,
    address from,
    address to,
    uint256 value
  ) internal {
    callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
  }

  function safeApprove(
    IERC20 token,
    address spender,
    uint256 value
  ) internal {
    require(
      (value == 0) || (token.allowance(address(this), spender) == 0),
      'SafeERC20: approve from non-zero to non-zero allowance'
    );
    callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
  }

  function callOptionalReturn(IERC20 token, bytes memory data) private {
    require(address(token).isContract(), 'SafeERC20: call to non-contract');

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = address(token).call(data);
    require(success, 'SafeERC20: low-level call failed');

    if (returndata.length > 0) {
      // Return data is optional
      // solhint-disable-next-line max-line-length
      require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
    }
  }
}


// File contracts/dependencies/openzeppelin/contracts/Context.sol

pragma solidity 0.6.12;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
  function _msgSender() internal view virtual returns (address payable) {
    return msg.sender;
  }

  function _msgData() internal view virtual returns (bytes memory) {
    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    return msg.data;
  }
}


// File contracts/dependencies/openzeppelin/contracts/Ownable.sol


pragma solidity ^0.6.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
  address private _owner;

  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  /**
   * @dev Initializes the contract setting the deployer as the initial owner.
   */
  constructor() internal {
    address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);
  }

  /**
   * @dev Returns the address of the current owner.
   */
  function owner() public view returns (address) {
    return _owner;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(_owner == _msgSender(), 'Ownable: caller is not the owner');
    _;
  }

  /**
   * @dev Leaves the contract without owner. It will not be possible to call
   * `onlyOwner` functions anymore. Can only be called by the current owner.
   *
   * NOTE: Renouncing ownership will leave the contract without an owner,
   * thereby removing any functionality that is only available to the owner.
   */
  function renounceOwnership() public virtual onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);
  }

  /**
   * @dev Transfers ownership of the contract to a new account (`newOwner`).
   * Can only be called by the current owner.
   */
  function transferOwnership(address newOwner) public virtual onlyOwner {
    require(newOwner != address(0), 'Ownable: new owner is the zero address');
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
  }
}


// File contracts/interfaces/ILendingPoolAddressesProvider.sol

pragma solidity 0.6.12;

/**
 * @title LendingPoolAddressesProvider contract
 * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles
 * - Acting also as factory of proxies and admin of those, so with right to change its implementations
 * - Owned by the Aave Governance
 * @author Aave
 **/
interface ILendingPoolAddressesProvider {
  event MarketIdSet(string newMarketId);
  event LendingPoolUpdated(address indexed newAddress);
  event ConfigurationAdminUpdated(address indexed newAddress);
  event EmergencyAdminUpdated(address indexed newAddress);
  event LendingPoolConfiguratorUpdated(address indexed newAddress);
  event LendingPoolCollateralManagerUpdated(address indexed newAddress);
  event PriceOracleUpdated(address indexed newAddress);
  event LendingRateOracleUpdated(address indexed newAddress);
  event ProxyCreated(bytes32 id, address indexed newAddress);
  event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy);

  function getMarketId() external view returns (string memory);

  function setMarketId(string calldata marketId) external;

  function setAddress(bytes32 id, address newAddress) external;

  function setAddressAsProxy(bytes32 id, address impl) external;

  function getAddress(bytes32 id) external view returns (address);

  function getLendingPool() external view returns (address);

  function setLendingPoolImpl(address pool) external;

  function getLendingPoolConfigurator() external view returns (address);

  function setLendingPoolConfiguratorImpl(address configurator) external;

  function getLendingPoolCollateralManager() external view returns (address);

  function setLendingPoolCollateralManager(address manager) external;

  function getPoolAdmin() external view returns (address);

  function setPoolAdmin(address admin) external;

  function getEmergencyAdmin() external view returns (address);

  function setEmergencyAdmin(address admin) external;

  function getPriceOracle() external view returns (address);

  function setPriceOracle(address priceOracle) external;

  function getLendingRateOracle() external view returns (address);

  function setLendingRateOracle(address lendingRateOracle) external;
}


// File contracts/protocol/libraries/types/DataTypes.sol

pragma solidity 0.6.12;

library DataTypes {
  // refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
  struct ReserveData {
    //stores the reserve configuration
    ReserveConfigurationMap configuration;
    //the liquidity index. Expressed in ray
    uint128 liquidityIndex;
    //variable borrow index. Expressed in ray
    uint128 variableBorrowIndex;
    //the current supply rate. Expressed in ray
    uint128 currentLiquidityRate;
    //the current variable borrow rate. Expressed in ray
    uint128 currentVariableBorrowRate;
    //the current stable borrow rate. Expressed in ray
    uint128 currentStableBorrowRate;
    uint40 lastUpdateTimestamp;
    //tokens addresses
    address aTokenAddress;
    address stableDebtTokenAddress;
    address variableDebtTokenAddress;
    //address of the interest rate strategy
    address interestRateStrategyAddress;
    //the id of the reserve. Represents the position in the list of the active reserves
    uint8 id;
  }

  struct ReserveConfigurationMap {
    //bit 0-15: LTV
    //bit 16-31: Liq. threshold
    //bit 32-47: Liq. bonus
    //bit 48-55: Decimals
    //bit 56: Reserve is active
    //bit 57: reserve is frozen
    //bit 58: borrowing is enabled
    //bit 59: stable rate borrowing enabled
    //bit 60-63: reserved
    //bit 64-79: reserve factor
    uint256 data;
  }

  struct UserConfigurationMap {
    uint256 data;
  }

  enum InterestRateMode {NONE, STABLE, VARIABLE}
}


// File contracts/interfaces/IPriceOracleGetter.sol

pragma solidity 0.6.12;

/**
 * @title IPriceOracleGetter interface
 * @notice Interface for the Aave price oracle.
 **/

interface IPriceOracleGetter {
  /**
   * @dev returns the asset price in ETH
   * @param asset the address of the asset
   * @return the ETH price of the asset
   **/
  function getAssetPrice(address asset) external view returns (uint256);
}


// File contracts/interfaces/IERC20WithPermit.sol

pragma solidity 0.6.12;

interface IERC20WithPermit is IERC20 {
  function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external;
}


// File contracts/interfaces/ILendingPool.sol

pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;


interface ILendingPool {
  /**
   * @dev Emitted on deposit()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address initiating the deposit
   * @param onBehalfOf The beneficiary of the deposit, receiving the aTokens
   * @param amount The amount deposited
   * @param referral The referral code used
   **/
  event Deposit(
    address indexed reserve,
    address user,
    address indexed onBehalfOf,
    uint256 amount,
    uint16 indexed referral
  );

  /**
   * @dev Emitted on withdraw()
   * @param reserve The address of the underlyng asset being withdrawn
   * @param user The address initiating the withdrawal, owner of aTokens
   * @param to Address that will receive the underlying
   * @param amount The amount to be withdrawn
   **/
  event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);

  /**
   * @dev Emitted on borrow() and flashLoan() when debt needs to be opened
   * @param reserve The address of the underlying asset being borrowed
   * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
   * initiator of the transaction on flashLoan()
   * @param onBehalfOf The address that will be getting the debt
   * @param amount The amount borrowed out
   * @param borrowRateMode The rate mode: 1 for Stable, 2 for Variable
   * @param borrowRate The numeric rate at which the user has borrowed
   * @param referral The referral code used
   **/
  event Borrow(
    address indexed reserve,
    address user,
    address indexed onBehalfOf,
    uint256 amount,
    uint256 borrowRateMode,
    uint256 borrowRate,
    uint16 indexed referral
  );

  /**
   * @dev Emitted on repay()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The beneficiary of the repayment, getting his debt reduced
   * @param repayer The address of the user initiating the repay(), providing the funds
   * @param amount The amount repaid
   **/
  event Repay(
    address indexed reserve,
    address indexed user,
    address indexed repayer,
    uint256 amount
  );

  /**
   * @dev Emitted on swapBorrowRateMode()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user swapping his rate mode
   * @param rateMode The rate mode that the user wants to swap to
   **/
  event Swap(address indexed reserve, address indexed user, uint256 rateMode);

  /**
   * @dev Emitted on setUserUseReserveAsCollateral()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user enabling the usage as collateral
   **/
  event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);

  /**
   * @dev Emitted on setUserUseReserveAsCollateral()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user enabling the usage as collateral
   **/
  event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);

  /**
   * @dev Emitted on rebalanceStableBorrowRate()
   * @param reserve The address of the underlying asset of the reserve
   * @param user The address of the user for which the rebalance has been executed
   **/
  event RebalanceStableBorrowRate(address indexed reserve, address indexed user);

  /**
   * @dev Emitted on flashLoan()
   * @param target The address of the flash loan receiver contract
   * @param initiator The address initiating the flash loan
   * @param asset The address of the asset being flash borrowed
   * @param amount The amount flash borrowed
   * @param premium The fee flash borrowed
   * @param referralCode The referral code used
   **/
  event FlashLoan(
    address indexed target,
    address indexed initiator,
    address indexed asset,
    uint256 amount,
    uint256 premium,
    uint16 referralCode
  );

  /**
   * @dev Emitted when the pause is triggered.
   */
  event Paused();

  /**
   * @dev Emitted when the pause is lifted.
   */
  event Unpaused();

  /**
   * @dev Emitted when a borrower is liquidated. This event is emitted by the LendingPool via
   * LendingPoolCollateral manager using a DELEGATECALL
   * This allows to have the events in the generated ABI for LendingPool.
   * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
   * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
   * @param user The address of the borrower getting liquidated
   * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
   * @param liquidatedCollateralAmount The amount of collateral received by the liiquidator
   * @param liquidator The address of the liquidator
   * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
   * to receive the underlying collateral asset directly
   **/
  event LiquidationCall(
    address indexed collateralAsset,
    address indexed debtAsset,
    address indexed user,
    uint256 debtToCover,
    uint256 liquidatedCollateralAmount,
    address liquidator,
    bool receiveAToken
  );

  /**
   * @dev Emitted when the state of a reserve is updated. NOTE: This event is actually declared
   * in the ReserveLogic library and emitted in the updateInterestRates() function. Since the function is internal,
   * the event will actually be fired by the LendingPool contract. The event is therefore replicated here so it
   * gets added to the LendingPool ABI
   * @param reserve The address of the underlying asset of the reserve
   * @param liquidityRate The new liquidity rate
   * @param stableBorrowRate The new stable borrow rate
   * @param variableBorrowRate The new variable borrow rate
   * @param liquidityIndex The new liquidity index
   * @param variableBorrowIndex The new variable borrow index
   **/
  event ReserveDataUpdated(
    address indexed reserve,
    uint256 liquidityRate,
    uint256 stableBorrowRate,
    uint256 variableBorrowRate,
    uint256 liquidityIndex,
    uint256 variableBorrowIndex
  );

  /**
   * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
   * - E.g. User deposits 100 USDC and gets in return 100 aUSDC
   * @param asset The address of the underlying asset to deposit
   * @param amount The amount to be deposited
   * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
   *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
   *   is a different wallet
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   **/
  function deposit(
    address asset,
    uint256 amount,
    address onBehalfOf,
    uint16 referralCode
  ) external;

  /**
   * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
   * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
   * @param asset The address of the underlying asset to withdraw
   * @param amount The underlying amount to be withdrawn
   *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
   * @param to Address that will receive the underlying, same as msg.sender if the user
   *   wants to receive it on his own wallet, or a different address if the beneficiary is a
   *   different wallet
   * @return The final amount withdrawn
   **/
  function withdraw(
    address asset,
    uint256 amount,
    address to
  ) external returns (uint256);

  /**
   * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
   * already deposited enough collateral, or he was given enough allowance by a credit delegator on the
   * corresponding debt token (StableDebtToken or VariableDebtToken)
   * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
   *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
   * @param asset The address of the underlying asset to borrow
   * @param amount The amount to be borrowed
   * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
   * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
   * if he has been given credit delegation allowance
   **/
  function borrow(
    address asset,
    uint256 amount,
    uint256 interestRateMode,
    uint16 referralCode,
    address onBehalfOf
  ) external;

  /**
   * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
   * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
   * @param asset The address of the borrowed underlying asset previously borrowed
   * @param amount The amount to repay
   * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
   * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
   * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
   * user calling the function if he wants to reduce/remove his own debt, or the address of any other
   * other borrower whose debt should be removed
   * @return The final amount repaid
   **/
  function repay(
    address asset,
    uint256 amount,
    uint256 rateMode,
    address onBehalfOf
  ) external returns (uint256);

  /**
   * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
   * @param asset The address of the underlying asset borrowed
   * @param rateMode The rate mode that the user wants to swap to
   **/
  function swapBorrowRateMode(address asset, uint256 rateMode) external;

  /**
   * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
   * - Users can be rebalanced if the following conditions are satisfied:
   *     1. Usage ratio is above 95%
   *     2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
   *        borrowed at a stable rate and depositors are not earning enough
   * @param asset The address of the underlying asset borrowed
   * @param user The address of the user to be rebalanced
   **/
  function rebalanceStableBorrowRate(address asset, address user) external;

  /**
   * @dev Allows depositors to enable/disable a specific deposited asset as collateral
   * @param asset The address of the underlying asset deposited
   * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
   **/
  function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;

  /**
   * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
   * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
   *   a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
   * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
   * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
   * @param user The address of the borrower getting liquidated
   * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
   * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
   * to receive the underlying collateral asset directly
   **/
  function liquidationCall(
    address collateralAsset,
    address debtAsset,
    address user,
    uint256 debtToCover,
    bool receiveAToken
  ) external;

  /**
   * @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
   * as long as the amount taken plus a fee is returned.
   * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
   * For further details please visit https://developers.aave.com
   * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
   * @param assets The addresses of the assets being flash-borrowed
   * @param amounts The amounts amounts being flash-borrowed
   * @param modes Types of the debt to open if the flash loan is not returned:
   *   0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
   *   1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
   *   2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
   * @param onBehalfOf The address  that will receive the debt in the case of using on `modes` 1 or 2
   * @param params Variadic packed params to pass to the receiver as extra information
   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
   *   0 if the action is executed directly by the user, without any middle-man
   **/
  function flashLoan(
    address receiverAddress,
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata modes,
    address onBehalfOf,
    bytes calldata params,
    uint16 referralCode
  ) external;

  /**
   * @dev Returns the user account data across all the reserves
   * @param user The address of the user
   * @return totalCollateralETH the total collateral in ETH of the user
   * @return totalDebtETH the total debt in ETH of the user
   * @return availableBorrowsETH the borrowing power left of the user
   * @return currentLiquidationThreshold the liquidation threshold of the user
   * @return ltv the loan to value of the user
   * @return healthFactor the current health factor of the user
   **/
  function getUserAccountData(address user)
    external
    view
    returns (
      uint256 totalCollateralETH,
      uint256 totalDebtETH,
      uint256 availableBorrowsETH,
      uint256 currentLiquidationThreshold,
      uint256 ltv,
      uint256 healthFactor
    );

  function initReserve(
    address reserve,
    address aTokenAddress,
    address stableDebtAddress,
    address variableDebtAddress,
    address interestRateStrategyAddress
  ) external;

  function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress)
    external;

  function setConfiguration(address reserve, uint256 configuration) external;

  /**
   * @dev Returns the configuration of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The configuration of the reserve
   **/
  function getConfiguration(address asset)
    external
    view
    returns (DataTypes.ReserveConfigurationMap memory);

  /**
   * @dev Returns the configuration of the user across all the reserves
   * @param user The user address
   * @return The configuration of the user
   **/
  function getUserConfiguration(address user)
    external
    view
    returns (DataTypes.UserConfigurationMap memory);

  /**
   * @dev Returns the normalized income normalized income of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The reserve's normalized income
   */
  function getReserveNormalizedIncome(address asset) external view returns (uint256);

  /**
   * @dev Returns the normalized variable debt per unit of asset
   * @param asset The address of the underlying asset of the reserve
   * @return The reserve normalized variable debt
   */
  function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);

  /**
   * @dev Returns the state and configuration of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The state of the reserve
   **/
  function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);

  function finalizeTransfer(
    address asset,
    address from,
    address to,
    uint256 amount,
    uint256 balanceFromAfter,
    uint256 balanceToBefore
  ) external;

  function getReservesList() external view returns (address[] memory);

  function getAddressesProvider() external view returns (ILendingPoolAddressesProvider);

  function setPause(bool val) external;

  function paused() external view returns (bool);
}


// File contracts/flashloan/interfaces/IFlashLoanReceiver.sol

pragma solidity 0.6.12;


/**
 * @title IFlashLoanReceiver interface
 * @notice Interface for the Aave fee IFlashLoanReceiver.
 * @author Aave
 * @dev implement this interface to develop a flashloan-compatible flashLoanReceiver contract
 **/
interface IFlashLoanReceiver {
  function executeOperation(
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata premiums,
    address initiator,
    bytes calldata params
  ) external returns (bool);

  function ADDRESSES_PROVIDER() external view returns (ILendingPoolAddressesProvider);

  function LENDING_POOL() external view returns (ILendingPool);
}


// File contracts/flashloan/base/FlashLoanReceiverBase.sol

pragma solidity 0.6.12;






abstract contract FlashLoanReceiverBase is IFlashLoanReceiver {
  using SafeERC20 for IERC20;
  using SafeMath for uint256;

  ILendingPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
  ILendingPool public immutable override LENDING_POOL;

  constructor(ILendingPoolAddressesProvider provider) public {
    ADDRESSES_PROVIDER = provider;
    LENDING_POOL = ILendingPool(provider.getLendingPool());
  }
}


// File contracts/adapters/BaseParaSwapAdapter.sol

pragma solidity 0.6.12;










/**
 * @title BaseParaSwapAdapter
 * @notice Utility functions for adapters using ParaSwap
 * @author Jason Raymond Bell
 */
abstract contract BaseParaSwapAdapter is FlashLoanReceiverBase, Ownable {
  using SafeMath for uint256;
  using SafeERC20 for IERC20;
  using SafeERC20 for IERC20Detailed;
  using SafeERC20 for IERC20WithPermit;

  struct PermitSignature {
    uint256 amount;
    uint256 deadline;
    uint8 v;
    bytes32 r;
    bytes32 s;
  }

  // Max slippage percent allowed
  uint256 public constant MAX_SLIPPAGE_PERCENT = 3000; // 30%

  IPriceOracleGetter public immutable ORACLE;

  event Swapped(address indexed fromAsset, address indexed toAsset, uint256 fromAmount, uint256 receivedAmount);

  constructor(
    ILendingPoolAddressesProvider addressesProvider
  ) public FlashLoanReceiverBase(addressesProvider) {
    ORACLE = IPriceOracleGetter(addressesProvider.getPriceOracle());
  }

  /**
   * @dev Get the price of the asset from the oracle denominated in eth
   * @param asset address
   * @return eth price for the asset
   */
  function _getPrice(address asset) internal view returns (uint256) {
    return ORACLE.getAssetPrice(asset);
  }

  /**
   * @dev Get the decimals of an asset
   * @return number of decimals of the asset
   */
  function _getDecimals(IERC20Detailed asset) internal view returns (uint8) {
    uint8 decimals = asset.decimals();
    // Ensure 10**decimals won't overflow a uint256
    require(decimals <= 77, 'TOO_MANY_DECIMALS_ON_TOKEN');
    return decimals;
  }

  /**
   * @dev Get the aToken associated to the asset
   * @return address of the aToken
   */
  function _getReserveData(address asset) internal view returns (DataTypes.ReserveData memory) {
    return LENDING_POOL.getReserveData(asset);
  }

  /**
   * @dev Pull the ATokens from the user
   * @param reserve address of the asset
   * @param reserveAToken address of the aToken of the reserve
   * @param user address
   * @param amount of tokens to be transferred to the contract
   * @param permitSignature struct containing the permit signature
   */
  function _pullATokenAndWithdraw(
    address reserve,
    IERC20WithPermit reserveAToken,
    address user,
    uint256 amount,
    PermitSignature memory permitSignature
  ) internal {
    // If deadline is set to zero, assume there is no signature for permit
    if (permitSignature.deadline != 0) {
      reserveAToken.permit(
        user,
        address(this),
        permitSignature.amount,
        permitSignature.deadline,
        permitSignature.v,
        permitSignature.r,
        permitSignature.s
      );
    }

    // transfer from user to adapter
    reserveAToken.safeTransferFrom(user, address(this), amount);

    // withdraw reserve
    require(
      LENDING_POOL.withdraw(reserve, amount, address(this)) == amount,
      'UNEXPECTED_AMOUNT_WITHDRAWN'
    );
  }

  /**
   * @dev Emergency rescue for token stucked on this contract, as failsafe mechanism
   * - Funds should never remain in this contract more time than during transactions
   * - Only callable by the owner
   */
  function rescueTokens(IERC20 token) external onlyOwner {
    token.safeTransfer(owner(), token.balanceOf(address(this)));
  }
}


// File contracts/protocol/libraries/helpers/Errors.sol

pragma solidity 0.6.12;

/**
 * @title Errors library
 * @author Aave
 * @notice Defines the error messages emitted by the different contracts of the Aave protocol
 * @dev Error messages prefix glossary:
 *  - VL = ValidationLogic
 *  - MATH = Math libraries
 *  - CT = Common errors between tokens (AToken, VariableDebtToken and StableDebtToken)
 *  - AT = AToken
 *  - SDT = StableDebtToken
 *  - VDT = VariableDebtToken
 *  - LP = LendingPool
 *  - LPAPR = LendingPoolAddressesProviderRegistry
 *  - LPC = LendingPoolConfiguration
 *  - RL = ReserveLogic
 *  - LPCM = LendingPoolCollateralManager
 *  - P = Pausable
 */
library Errors {
  //common errors
  string public constant CALLER_NOT_POOL_ADMIN = '33'; // 'The caller must be the pool admin'
  string public constant BORROW_ALLOWANCE_NOT_ENOUGH = '59'; // User borrows on behalf, but allowance are too small

  //contract specific errors
  string public constant VL_INVALID_AMOUNT = '1'; // 'Amount must be greater than 0'
  string public constant VL_NO_ACTIVE_RESERVE = '2'; // 'Action requires an active reserve'
  string public constant VL_RESERVE_FROZEN = '3'; // 'Action cannot be performed because the reserve is frozen'
  string public constant VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = '4'; // 'The current liquidity is not enough'
  string public constant VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE = '5'; // 'User cannot withdraw more than the available balance'
  string public constant VL_TRANSFER_NOT_ALLOWED = '6'; // 'Transfer cannot be allowed.'
  string public constant VL_BORROWING_NOT_ENABLED = '7'; // 'Borrowing is not enabled'
  string public constant VL_INVALID_INTEREST_RATE_MODE_SELECTED = '8'; // 'Invalid interest rate mode selected'
  string public constant VL_COLLATERAL_BALANCE_IS_0 = '9'; // 'The collateral balance is 0'
  string public constant VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = '10'; // 'Health factor is lesser than the liquidation threshold'
  string public constant VL_COLLATERAL_CANNOT_COVER_NEW_BORROW = '11'; // 'There is not enough collateral to cover a new borrow'
  string public constant VL_STABLE_BORROWING_NOT_ENABLED = '12'; // stable borrowing not enabled
  string public constant VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY = '13'; // collateral is (mostly) the same currency that is being borrowed
  string public constant VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = '14'; // 'The requested amount is greater than the max loan size in stable rate mode
  string public constant VL_NO_DEBT_OF_SELECTED_TYPE = '15'; // 'for repayment of stable debt, the user needs to have stable debt, otherwise, he needs to have variable debt'
  string public constant VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = '16'; // 'To repay on behalf of an user an explicit amount to repay is needed'
  string public constant VL_NO_STABLE_RATE_LOAN_IN_RESERVE = '17'; // 'User does not have a stable rate loan in progress on this reserve'
  string public constant VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE = '18'; // 'User does not have a variable rate loan in progress on this reserve'
  string public constant VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = '19'; // 'The underlying balance needs to be greater than 0'
  string public constant VL_DEPOSIT_ALREADY_IN_USE = '20'; // 'User deposit is already being used as collateral'
  string public constant LP_NOT_ENOUGH_STABLE_BORROW_BALANCE = '21'; // 'User does not have any stable rate loan for this reserve'
  string public constant LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = '22'; // 'Interest rate rebalance conditions were not met'
  string public constant LP_LIQUIDATION_CALL_FAILED = '23'; // 'Liquidation call failed'
  string public constant LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW = '24'; // 'There is not enough liquidity available to borrow'
  string public constant LP_REQUESTED_AMOUNT_TOO_SMALL = '25'; // 'The requested amount is too small for a FlashLoan.'
  string public constant LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = '26'; // 'The actual balance of the protocol is inconsistent'
  string public constant LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR = '27'; // 'The caller of the function is not the lending pool configurator'
  string public constant LP_INCONSISTENT_FLASHLOAN_PARAMS = '28';
  string public constant CT_CALLER_MUST_BE_LENDING_POOL = '29'; // 'The caller of this function must be a lending pool'
  string public constant CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = '30'; // 'User cannot give allowance to himself'
  string public constant CT_TRANSFER_AMOUNT_NOT_GT_0 = '31'; // 'Transferred amount needs to be greater than zero'
  string public constant RL_RESERVE_ALREADY_INITIALIZED = '32'; // 'Reserve has already been initialized'
  string public constant LPC_RESERVE_LIQUIDITY_NOT_0 = '34'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_ATOKEN_POOL_ADDRESS = '35'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS = '36'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS = '37'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = '38'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = '39'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_ADDRESSES_PROVIDER_ID = '40'; // 'The liquidity of the reserve needs to be 0'
  string public constant LPC_INVALID_CONFIGURATION = '75'; // 'Invalid risk parameters for the reserve'
  string public constant LPC_CALLER_NOT_EMERGENCY_ADMIN = '76'; // 'The caller must be the emergency admin'
  string public constant LPAPR_PROVIDER_NOT_REGISTERED = '41'; // 'Provider is not registered'
  string public constant LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = '42'; // 'Health factor is not below the threshold'
  string public constant LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED = '43'; // 'The collateral chosen cannot be liquidated'
  string public constant LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = '44'; // 'User did not borrow the specified currency'
  string public constant LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = '45'; // "There isn't enough liquidity available to liquidate"
  string public constant LPCM_NO_ERRORS = '46'; // 'No errors'
  string public constant LP_INVALID_FLASHLOAN_MODE = '47'; //Invalid flashloan mode selected
  string public constant MATH_MULTIPLICATION_OVERFLOW = '48';
  string public constant MATH_ADDITION_OVERFLOW = '49';
  string public constant MATH_DIVISION_BY_ZERO = '50';
  string public constant RL_LIQUIDITY_INDEX_OVERFLOW = '51'; //  Liquidity index overflows uint128
  string public constant RL_VARIABLE_BORROW_INDEX_OVERFLOW = '52'; //  Variable borrow index overflows uint128
  string public constant RL_LIQUIDITY_RATE_OVERFLOW = '53'; //  Liquidity rate overflows uint128
  string public constant RL_VARIABLE_BORROW_RATE_OVERFLOW = '54'; //  Variable borrow rate overflows uint128
  string public constant RL_STABLE_BORROW_RATE_OVERFLOW = '55'; //  Stable borrow rate overflows uint128
  string public constant CT_INVALID_MINT_AMOUNT = '56'; //invalid amount to mint
  string public constant LP_FAILED_REPAY_WITH_COLLATERAL = '57';
  string public constant CT_INVALID_BURN_AMOUNT = '58'; //invalid amount to burn
  string public constant LP_FAILED_COLLATERAL_SWAP = '60';
  string public constant LP_INVALID_EQUAL_ASSETS_TO_SWAP = '61';
  string public constant LP_REENTRANCY_NOT_ALLOWED = '62';
  string public constant LP_CALLER_MUST_BE_AN_ATOKEN = '63';
  string public constant LP_IS_PAUSED = '64'; // 'Pool is paused'
  string public constant LP_NO_MORE_RESERVES_ALLOWED = '65';
  string public constant LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN = '66';
  string public constant RC_INVALID_LTV = '67';
  string public constant RC_INVALID_LIQ_THRESHOLD = '68';
  string public constant RC_INVALID_LIQ_BONUS = '69';
  string public constant RC_INVALID_DECIMALS = '70';
  string public constant RC_INVALID_RESERVE_FACTOR = '71';
  string public constant LPAPR_INVALID_ADDRESSES_PROVIDER_ID = '72';
  string public constant VL_INCONSISTENT_FLASHLOAN_PARAMS = '73';
  string public constant LP_INCONSISTENT_PARAMS_LENGTH = '74';
  string public constant UL_INVALID_INDEX = '77';
  string public constant LP_NOT_CONTRACT = '78';
  string public constant SDT_STABLE_DEBT_OVERFLOW = '79';
  string public constant SDT_BURN_EXCEEDS_BALANCE = '80';

  enum CollateralManagerErrors {
    NO_ERROR,
    NO_COLLATERAL_AVAILABLE,
    COLLATERAL_CANNOT_BE_LIQUIDATED,
    CURRRENCY_NOT_BORROWED,
    HEALTH_FACTOR_ABOVE_THRESHOLD,
    NOT_ENOUGH_LIQUIDITY,
    NO_ACTIVE_RESERVE,
    HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD,
    INVALID_EQUAL_ASSETS_TO_SWAP,
    FROZEN_RESERVE
  }
}


// File contracts/protocol/libraries/math/PercentageMath.sol

pragma solidity 0.6.12;

/**
 * @title PercentageMath library
 * @author Aave
 * @notice Provides functions to perform percentage calculations
 * @dev Percentages are defined by default with 2 decimals of precision (100.00). The precision is indicated by PERCENTAGE_FACTOR
 * @dev Operations are rounded half up
 **/

library PercentageMath {
  uint256 constant PERCENTAGE_FACTOR = 1e4; //percentage plus two decimals
  uint256 constant HALF_PERCENT = PERCENTAGE_FACTOR / 2;

  /**
   * @dev Executes a percentage multiplication
   * @param value The value of which the percentage needs to be calculated
   * @param percentage The percentage of the value to be calculated
   * @return The percentage of value
   **/
  function percentMul(uint256 value, uint256 percentage) internal pure returns (uint256) {
    if (value == 0 || percentage == 0) {
      return 0;
    }

    require(
      value <= (type(uint256).max - HALF_PERCENT) / percentage,
      Errors.MATH_MULTIPLICATION_OVERFLOW
    );

    return (value * percentage + HALF_PERCENT) / PERCENTAGE_FACTOR;
  }

  /**
   * @dev Executes a percentage division
   * @param value The value of which the percentage needs to be calculated
   * @param percentage The percentage of the value to be calculated
   * @return The value divided the percentage
   **/
  function percentDiv(uint256 value, uint256 percentage) internal pure returns (uint256) {
    require(percentage != 0, Errors.MATH_DIVISION_BY_ZERO);
    uint256 halfPercentage = percentage / 2;

    require(
      value <= (type(uint256).max - halfPercentage) / PERCENTAGE_FACTOR,
      Errors.MATH_MULTIPLICATION_OVERFLOW
    );

    return (value * PERCENTAGE_FACTOR + halfPercentage) / percentage;
  }
}


// File contracts/interfaces/IParaSwapAugustus.sol

pragma solidity 0.6.12;

interface IParaSwapAugustus {
  function getTokenTransferProxy() external view returns (address);
}


// File contracts/interfaces/IParaSwapAugustusRegistry.sol

pragma solidity 0.6.12;

interface IParaSwapAugustusRegistry {
  function isValidAugustus(address augustus) external view returns (bool);
}


// File contracts/adapters/BaseParaSwapSellAdapter.sol

pragma solidity 0.6.12;






/**
 * @title BaseParaSwapSellAdapter
 * @notice Implements the logic for selling tokens on ParaSwap
 * @author Jason Raymond Bell
 */
abstract contract BaseParaSwapSellAdapter is BaseParaSwapAdapter {
  using PercentageMath for uint256;

  IParaSwapAugustusRegistry public immutable AUGUSTUS_REGISTRY;

  constructor(
    ILendingPoolAddressesProvider addressesProvider,
    IParaSwapAugustusRegistry augustusRegistry
  ) public BaseParaSwapAdapter(addressesProvider) {
    // Do something on Augustus registry to check the right contract was passed
    require(!augustusRegistry.isValidAugustus(address(0)));
    AUGUSTUS_REGISTRY = augustusRegistry;
  }

  /**
   * @dev Swaps a token for another using ParaSwap
   * @param fromAmountOffset Offset of fromAmount in Augustus calldata if it should be overwritten, otherwise 0
   * @param swapCalldata Calldata for ParaSwap's AugustusSwapper contract
   * @param augustus Address of ParaSwap's AugustusSwapper contract
   * @param assetToSwapFrom Address of the asset to be swapped from
   * @param assetToSwapTo Address of the asset to be swapped to
   * @param amountToSwap Amount to be swapped
   * @param minAmountToReceive Minimum amount to be received from the swap
   * @return amountReceived The amount received from the swap
   */
  function _sellOnParaSwap(
    uint256 fromAmountOffset,
    bytes memory swapCalldata,
    IParaSwapAugustus augustus,
    IERC20Detailed assetToSwapFrom,
    IERC20Detailed assetToSwapTo,
    uint256 amountToSwap,
    uint256 minAmountToReceive
  ) internal returns (uint256 amountReceived) {
    require(AUGUSTUS_REGISTRY.isValidAugustus(address(augustus)), 'INVALID_AUGUSTUS');

    {
      uint256 fromAssetDecimals = _getDecimals(assetToSwapFrom);
      uint256 toAssetDecimals = _getDecimals(assetToSwapTo);

      uint256 fromAssetPrice = _getPrice(address(assetToSwapFrom));
      uint256 toAssetPrice = _getPrice(address(assetToSwapTo));

      uint256 expectedMinAmountOut =
        amountToSwap
          .mul(fromAssetPrice.mul(10**toAssetDecimals))
          .div(toAssetPrice.mul(10**fromAssetDecimals))
          .percentMul(PercentageMath.PERCENTAGE_FACTOR - MAX_SLIPPAGE_PERCENT);

      require(expectedMinAmountOut <= minAmountToReceive, 'MIN_AMOUNT_EXCEEDS_MAX_SLIPPAGE');
    }

    uint256 balanceBeforeAssetFrom = assetToSwapFrom.balanceOf(address(this));
    require(balanceBeforeAssetFrom >= amountToSwap, 'INSUFFICIENT_BALANCE_BEFORE_SWAP');
    uint256 balanceBeforeAssetTo = assetToSwapTo.balanceOf(address(this));

    address tokenTransferProxy = augustus.getTokenTransferProxy();
    assetToSwapFrom.safeApprove(tokenTransferProxy, 0);
    assetToSwapFrom.safeApprove(tokenTransferProxy, amountToSwap);

    if (fromAmountOffset != 0) {
      // Ensure 256 bit (32 bytes) fromAmount value is within bounds of the
      // calldata, not overlapping with the first 4 bytes (function selector).
      require(fromAmountOffset >= 4 &&
        fromAmountOffset <= swapCalldata.length.sub(32),
        'FROM_AMOUNT_OFFSET_OUT_OF_RANGE');
      // Overwrite the fromAmount with the correct amount for the swap.
      // In memory, swapCalldata consists of a 256 bit length field, followed by
      // the actual bytes data, that is why 32 is added to the byte offset.
      assembly {
        mstore(add(swapCalldata, add(fromAmountOffset, 32)), amountToSwap)
      }
    }
    (bool success,) = address(augustus).call(swapCalldata);
    if (!success) {
      // Copy revert reason from call
      assembly {
        returndatacopy(0, 0, returndatasize())
        revert(0, returndatasize())
      }
    }
    require(assetToSwapFrom.balanceOf(address(this)) == balanceBeforeAssetFrom - amountToSwap, 'WRONG_BALANCE_AFTER_SWAP');
    amountReceived = assetToSwapTo.balanceOf(address(this)).sub(balanceBeforeAssetTo);
    require(amountReceived >= minAmountToReceive, 'INSUFFICIENT_AMOUNT_RECEIVED');

    emit Swapped(
      address(assetToSwapFrom),
      address(assetToSwapTo),
      amountToSwap,
      amountReceived
    );
  }
}


// File contracts/dependencies/openzeppelin/contracts/ReentrancyGuard.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/adapters/ParaSwapLiquiditySwapAdapter.sol

pragma solidity 0.6.12;







/**
 * @title ParaSwapLiquiditySwapAdapter
 * @notice Adapter to swap liquidity using ParaSwap.
 * @author Jason Raymond Bell
 */
contract ParaSwapLiquiditySwapAdapter is BaseParaSwapSellAdapter, ReentrancyGuard {
  constructor(
    ILendingPoolAddressesProvider addressesProvider,
    IParaSwapAugustusRegistry augustusRegistry
  ) public BaseParaSwapSellAdapter(addressesProvider, augustusRegistry) {
    // This is only required to initialize BaseParaSwapSellAdapter
  }

  /**
   * @dev Swaps the received reserve amount from the flash loan into the asset specified in the params.
   * The received funds from the swap are then deposited into the protocol on behalf of the user.
   * The user should give this contract allowance to pull the ATokens in order to withdraw the underlying asset and repay the flash loan.
   * @param assets Address of the underlying asset to be swapped from
   * @param amounts Amount of the flash loan i.e. maximum amount to swap
   * @param premiums Fee of the flash loan
   * @param initiator Account that initiated the flash loan
   * @param params Additional variadic field to include extra params. Expected parameters:
   *   address assetToSwapTo Address of the underlying asset to be swapped to and deposited
   *   uint256 minAmountToReceive Min amount to be received from the swap
   *   uint256 swapAllBalanceOffset Set to offset of fromAmount in Augustus calldata if wanting to swap all balance, otherwise 0
   *   bytes swapCalldata Calldata for ParaSwap's AugustusSwapper contract
   *   address augustus Address of ParaSwap's AugustusSwapper contract
   *   PermitSignature permitParams Struct containing the permit signatures, set to all zeroes if not used
   */
  function executeOperation(
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata premiums,
    address initiator,
    bytes calldata params
  ) external override nonReentrant returns (bool) {
    require(msg.sender == address(LENDING_POOL), 'CALLER_MUST_BE_LENDING_POOL');
    require(
      assets.length == 1 && amounts.length == 1 && premiums.length == 1,
      'FLASHLOAN_MULTIPLE_ASSETS_NOT_SUPPORTED'
    );

    uint256 flashLoanAmount = amounts[0];
    uint256 premium = premiums[0];
    address initiatorLocal = initiator;
    IERC20Detailed assetToSwapFrom = IERC20Detailed(assets[0]);
    (
      IERC20Detailed assetToSwapTo,
      uint256 minAmountToReceive,
      uint256 swapAllBalanceOffset,
      bytes memory swapCalldata,
      IParaSwapAugustus augustus,
      PermitSignature memory permitParams
    ) = abi.decode(params, (
      IERC20Detailed,
      uint256,
      uint256,
      bytes,
      IParaSwapAugustus,
      PermitSignature
    ));

    _swapLiquidity(
      swapAllBalanceOffset,
      swapCalldata,
      augustus,
      permitParams,
      flashLoanAmount,
      premium,
      initiatorLocal,
      assetToSwapFrom,
      assetToSwapTo,
      minAmountToReceive
    );

    return true;
  }

  /**
   * @dev Swaps an amount of an asset to another and deposits the new asset amount on behalf of the user without using a flash loan.
   * This method can be used when the temporary transfer of the collateral asset to this contract does not affect the user position.
   * The user should give this contract allowance to pull the ATokens in order to withdraw the underlying asset and perform the swap.
   * @param assetToSwapFrom Address of the underlying asset to be swapped from
   * @param assetToSwapTo Address of the underlying asset to be swapped to and deposited
   * @param amountToSwap Amount to be swapped, or maximum amount when swapping all balance
   * @param minAmountToReceive Minimum amount to be received from the swap
   * @param swapAllBalanceOffset Set to offset of fromAmount in Augustus calldata if wanting to swap all balance, otherwise 0
   * @param swapCalldata Calldata for ParaSwap's AugustusSwapper contract
   * @param augustus Address of ParaSwap's AugustusSwapper contract
   * @param permitParams Struct containing the permit signatures, set to all zeroes if not used
   */
  function swapAndDeposit(
    IERC20Detailed assetToSwapFrom,
    IERC20Detailed assetToSwapTo,
    uint256 amountToSwap,
    uint256 minAmountToReceive,
    uint256 swapAllBalanceOffset,
    bytes calldata swapCalldata,
    IParaSwapAugustus augustus,
    PermitSignature calldata permitParams
  ) external nonReentrant {
    IERC20WithPermit aToken =
      IERC20WithPermit(_getReserveData(address(assetToSwapFrom)).aTokenAddress);

    if (swapAllBalanceOffset != 0) {
      uint256 balance = aToken.balanceOf(msg.sender);
      require(balance <= amountToSwap, 'INSUFFICIENT_AMOUNT_TO_SWAP');
      amountToSwap = balance;
    }

    _pullATokenAndWithdraw(
      address(assetToSwapFrom),
      aToken,
      msg.sender,
      amountToSwap,
      permitParams
    );

    uint256 amountReceived = _sellOnParaSwap(
      swapAllBalanceOffset,
      swapCalldata,
      augustus,
      assetToSwapFrom,
      assetToSwapTo,
      amountToSwap,
      minAmountToReceive
    );

    assetToSwapTo.safeApprove(address(LENDING_POOL), 0);
    assetToSwapTo.safeApprove(address(LENDING_POOL), amountReceived);
    LENDING_POOL.deposit(address(assetToSwapTo), amountReceived, msg.sender, 0);
  }

  /**
   * @dev Swaps an amount of an asset to another and deposits the funds on behalf of the initiator.
   * @param swapAllBalanceOffset Set to offset of fromAmount in Augustus calldata if wanting to swap all balance, otherwise 0
   * @param swapCalldata Calldata for ParaSwap's AugustusSwapper contract
   * @param augustus Address of ParaSwap's AugustusSwapper contract
   * @param permitParams Struct containing the permit signatures, set to all zeroes if not used
   * @param flashLoanAmount Amount of the flash loan i.e. maximum amount to swap
   * @param premium Fee of the flash loan
   * @param initiator Account that initiated the flash loan
   * @param assetToSwapFrom Address of the underyling asset to be swapped from
   * @param assetToSwapTo Address of the underlying asset to be swapped to and deposited
   * @param minAmountToReceive Min amount to be received from the swap
   */
  function _swapLiquidity (
    uint256 swapAllBalanceOffset,
    bytes memory swapCalldata,
    IParaSwapAugustus augustus,
    PermitSignature memory permitParams,
    uint256 flashLoanAmount,
    uint256 premium,
    address initiator,
    IERC20Detailed assetToSwapFrom,
    IERC20Detailed assetToSwapTo,
    uint256 minAmountToReceive
  ) internal {
    IERC20WithPermit aToken =
      IERC20WithPermit(_getReserveData(address(assetToSwapFrom)).aTokenAddress);
    uint256 amountToSwap = flashLoanAmount;

    uint256 balance = aToken.balanceOf(initiator);
    if (swapAllBalanceOffset != 0) {
      uint256 balanceToSwap = balance.sub(premium);
      require(balanceToSwap <= amountToSwap, 'INSUFFICIENT_AMOUNT_TO_SWAP');
      amountToSwap = balanceToSwap;
    } else {
      require(balance >= amountToSwap.add(premium), 'INSUFFICIENT_ATOKEN_BALANCE');
    }

    uint256 amountReceived = _sellOnParaSwap(
      swapAllBalanceOffset,
      swapCalldata,
      augustus,
      assetToSwapFrom,
      assetToSwapTo,
      amountToSwap,
      minAmountToReceive
    );

    assetToSwapTo.safeApprove(address(LENDING_POOL), 0);
    assetToSwapTo.safeApprove(address(LENDING_POOL), amountReceived);
    LENDING_POOL.deposit(address(assetToSwapTo), amountReceived, initiator, 0);

    _pullATokenAndWithdraw(
      address(assetToSwapFrom),
      aToken,
      initiator,
      amountToSwap.add(premium),
      permitParams
    );

    // Repay flash loan
    assetToSwapFrom.safeApprove(address(LENDING_POOL), 0);
    assetToSwapFrom.safeApprove(address(LENDING_POOL), flashLoanAmount.add(premium));
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ILendingPoolAddressesProvider","name":"addressesProvider","type":"address"},{"internalType":"contract IParaSwapAugustusRegistry","name":"augustusRegistry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fromAsset","type":"address"},{"indexed":true,"internalType":"address","name":"toAsset","type":"address"},{"indexed":false,"internalType":"uint256","name":"fromAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"receivedAmount","type":"uint256"}],"name":"Swapped","type":"event"},{"inputs":[],"name":"ADDRESSES_PROVIDER","outputs":[{"internalType":"contract ILendingPoolAddressesProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"AUGUSTUS_REGISTRY","outputs":[{"internalType":"contract IParaSwapAugustusRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LENDING_POOL","outputs":[{"internalType":"contract ILendingPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SLIPPAGE_PERCENT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ORACLE","outputs":[{"internalType":"contract IPriceOracleGetter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"uint256[]","name":"premiums","type":"uint256[]"},{"internalType":"address","name":"initiator","type":"address"},{"internalType":"bytes","name":"params","type":"bytes"}],"name":"executeOperation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Detailed","name":"assetToSwapFrom","type":"address"},{"internalType":"contract IERC20Detailed","name":"assetToSwapTo","type":"address"},{"internalType":"uint256","name":"amountToSwap","type":"uint256"},{"internalType":"uint256","name":"minAmountToReceive","type":"uint256"},{"internalType":"uint256","name":"swapAllBalanceOffset","type":"uint256"},{"internalType":"bytes","name":"swapCalldata","type":"bytes"},{"internalType":"contract IParaSwapAugustus","name":"augustus","type":"address"},{"components":[{"internalType":"uint256","name":"amount","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"}],"internalType":"struct BaseParaSwapAdapter.PermitSignature","name":"permitParams","type":"tuple"}],"name":"swapAndDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000b53c1a33016b2dc2ff3653530bff1848a515c8c5000000000000000000000000a68bea62dc4034a689aa0f58a76681433caca663

-----Decoded View---------------
Arg [0] : addressesProvider (address): 0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5
Arg [1] : augustusRegistry (address): 0xa68bEA62Dc4034A689AA0F58A76681433caCa663

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b53c1a33016b2dc2ff3653530bff1848a515c8c5
Arg [1] : 000000000000000000000000a68bea62dc4034a689aa0f58a76681433caca663

61634:7848:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42981:127;;;;;;:::i;:::-;;:::i;:::-;;39386:74;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40304:51;;;:::i;:::-;;;;;;;:::i;40369:42::-;;;:::i;54771:60::-;;;:::i;15594:138::-;;;:::i;14992:73::-;;;:::i;63242:1307::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39465:51::-;;;:::i;65678:1230::-;;;;;;:::i;:::-;;:::i;15877:230::-;;;;;;:::i;:::-;;:::i;42981:127::-;15196:12;:10;:12::i;:::-;15186:6;;:22;:6;;;:22;;;15178:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43043:59:::1;43062:7;:5;:7::i;:::-;43071:30;::::0;;;;:15:::1;::::0;::::1;::::0;::::1;::::0;:30:::1;::::0;43095:4:::1;::::0;43071:30:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43043:18;::::0;::::1;::::0;:59;:18:::1;:59::i;:::-;42981:127:::0;:::o;39386:74::-;;;:::o;40304:51::-;40351:4;40304:51;:::o;40369:42::-;;;:::o;54771:60::-;;;:::o;15594:138::-;15196:12;:10;:12::i;:::-;15186:6;;:22;:6;;;:22;;;15178:67;;;;;;;;;;;;:::i;:::-;15697:1:::1;15681:6:::0;;15660:40:::1;::::0;::::1;15681:6:::0;;::::1;::::0;15660:40:::1;::::0;15697:1;;15660:40:::1;15724:1;15707:19:::0;;;::::1;::::0;;15594:138::o;14992:73::-;15030:7;15053:6;;;14992:73;:::o;63242:1307::-;63464:4;60440:1;61046:7;;:19;;61038:63;;;;;;;;;;;;:::i;:::-;60440:1;61179:7;:18;63485:10:::1;:35;63507:12;63485:35;;63477:75;;;;;;;;;;;;:::i;:::-;63592:1;63575:18:::0;::::1;:41:::0;::::1;;;-1:-1:-1::0;63615:1:0::1;63597:19:::0;::::1;63575:41;:65;;;;-1:-1:-1::0;63639:1:0::1;63620:20:::0;::::1;63575:65;63559:138;;;;;;;;;;;;:::i;:::-;63706:23;63732:7;;63740:1;63732:10;;;;;;;;;;;;;63706:36;;63749:15;63767:8;;63776:1;63767:11;;;;;;;;;;;;;63749:29;;63785:22;63810:9;63785:34;;63826:30;63874:6;;63881:1;63874:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;63826:58;;63900:28;63937:26:::0;63972:28:::1;64009:25;64043:26;64078:35;;:::i;:::-;64123:146;::::0;;::::1;64134:6:::0;64123:146:::1;:::i;:::-;63891:378;;;;;;;;;;;;64278:245;64301:20;64330:12;64351:8;64368:12;64389:15;64413:7;64429:14;64452:15;64476:13;64498:18;64278:14;:245::i;:::-;64539:4;64532:11;;;;;;;;;;;;60396:1:::0;61358:22;;63242:1307;;-1:-1:-1;;;;;;;;;63242:1307:0:o;39465:51::-;;;:::o;65678:1230::-;60440:1;61046:7;;:19;;61038:63;;;;;;;;;;;;:::i;:::-;60440:1;61179:7;:18;66014:23:::1;66064:41;66088:15:::0;66064::::1;:41::i;:::-;:55;;::::0;;-1:-1:-1;66133:25:0;;66129:197:::1;;66187:28;::::0;;;;66169:15:::1;::::0;66187:16:::1;::::0;::::1;::::0;::::1;::::0;:28:::1;::::0;66204:10:::1;::::0;66187:28:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66169:46;;66243:12;66232:7;:23;;66224:63;;;;;;;;;;;;:::i;:::-;66311:7:::0;-1:-1:-1;66129:197:0::1;66334:138;66373:15:::0;66398:6;66413:10:::1;66432:12:::0;66334:138:::1;;::::0;;::::1;::::0;::::1;66453:12:::0;66334:138:::1;:::i;:::-;:22;:138::i;:::-;66481:22;66506:183;66530:20;66559:12;;66506:183;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66580:8;66597:15;66621:13;66643:12;66664:18;66506:15;:183::i;:::-;66481:208:::0;-1:-1:-1;66698:51:0::1;:25;::::0;::::1;66732:12;66747:1;66698:25;:51::i;:::-;66756:64;:25;::::0;::::1;66790:12;66805:14:::0;66756:25:::1;:64::i;:::-;66827:75;::::0;;;;:20:::1;:12;:20;::::0;::::1;::::0;:75:::1;::::0;66856:13;;66872:14;;66888:10:::1;::::0;66900:1:::1;::::0;66827:75:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;60396:1:0;61358:22;;-1:-1:-1;;;;;;;;;;;;;65678:1230:0:o;15877:230::-;15196:12;:10;:12::i;:::-;15186:6;;:22;:6;;;:22;;;15178:67;;;;;;;;;;;;:::i;:::-;15962:22:::1;::::0;::::1;15954:73;;;;;;;;;;;;:::i;:::-;16060:6;::::0;;16039:38:::1;::::0;::::1;::::0;;::::1;::::0;16060:6;::::1;::::0;16039:38:::1;::::0;::::1;16084:6;:17:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;15877:230::o;13583:100::-;13667:10;13583:100;:::o;11584:190::-;11683:85;11702:5;11732:23;;;11757:2;11761:5;11709:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11683:18;:85::i;:::-;11584:190;;;:::o;67825:1654::-;68194:23;68244:41;68268:15;68244;:41::i;:::-;:55;;;68372:27;;;;;68244:55;;-1:-1:-1;68330:15:0;;68307:20;;68372:16;;;;;;:27;;68389:9;;68372:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68354:45;-1:-1:-1;68410:25:0;;68406:306;;68446:21;68470:20;:7;68482;68470:11;:20::i;:::-;68446:44;;68524:12;68507:13;:29;;68499:69;;;;;;;;;;;;:::i;:::-;68592:13;-1:-1:-1;68406:306:0;;;68647:25;:12;68664:7;68647:16;:25::i;:::-;68636:7;:36;;68628:76;;;;;;;;;;;;:::i;:::-;68720:22;68745:183;68769:20;68798:12;68819:8;68836:15;68860:13;68882:12;68903:18;68745:15;:183::i;:::-;68720:208;-1:-1:-1;68937:51:0;:25;;;68971:12;68986:1;68937:25;:51::i;:::-;68995:64;:25;;;69029:12;69044:14;68995:25;:64::i;:::-;69066:74;;;;;:20;:12;:20;;;;:74;;69095:13;;69111:14;;69127:9;;69138:1;;69066:74;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69149:150;69188:15;69213:6;69228:9;69246:25;69263:7;69246:12;:16;;:25;;;;:::i;:::-;69280:12;69149:22;:150::i;:::-;69333:53;:27;;;69369:12;69384:1;69333:27;:53::i;:::-;69393:80;69429:12;69444:28;:15;69464:7;69444:19;:28::i;:::-;69393:27;;;;:80;:27;:80::i;:::-;67825:1654;;;;;;;;;;;;;;:::o;41467:147::-;41530:28;;:::i;:::-;41574:34;;;;;:27;:12;:27;;;;:34;;41602:5;;41574:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41567:41;41467:147;-1:-1:-1;;41467:147:0:o;41940:814::-;42217:24;;;;:29;42213:272;;42257:13;:20;;;42288:4;42311;42327:15;:22;;;42360:15;:24;;;42395:15;:17;;;42423:15;:17;;;42451:15;:17;;;42257:220;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42213:272;42531:59;:30;;;42562:4;42576;42583:6;42531:30;:59::i;:::-;42640:53;;;;;42697:6;;42640:21;:12;:21;;;;:53;;42662:7;;42697:6;;42687:4;;42640:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:63;42624:124;;;;;;;;;;;;:::i;:::-;41940:814;;;;;:::o;55844:2822::-;56159:52;;;;;56120:22;;56159:33;:17;:33;;;;:52;;56201:8;;56159:52;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56151:81;;;;;;;;;;;;:::i;:::-;56250:25;56278:29;56291:15;56278:12;:29::i;:::-;56250:57;;;;56316:23;56342:27;56355:13;56342:12;:27::i;:::-;56316:53;;;;56380:22;56405:35;56423:15;56405:9;:35::i;:::-;56380:60;;56449:20;56472:33;56490:13;56472:9;:33::i;:::-;56449:56;-1:-1:-1;56516:28:0;56556:206;56706:55;56556:126;56642:39;56449:56;56659:2;:21;;;56642:16;:39::i;:::-;56556:69;56585:39;:14;56604:2;:19;;;56585:18;:39::i;:::-;56556:12;;:28;:69::i;:::-;:85;;:126::i;:::-;:149;;:206::i;:::-;56516:246;;56805:18;56781:20;:42;;56773:86;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;56908:40:0;;;;;56875:30;;-1:-1:-1;56908:25:0;;;;-1:-1:-1;56908:25:0;;-1:-1:-1;56908:40:0;;56942:4;;56908:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56875:73;;56989:12;56963:22;:38;;56955:83;;;;;;;;;;;;:::i;:::-;57076:38;;;;;57045:28;;57076:23;;;;;;:38;;57108:4;;57076:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57045:69;;57123:26;57152:8;:30;;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57123:61;-1:-1:-1;57191:50:0;:27;;;57123:61;57239:1;57191:27;:50::i;:::-;57248:61;:27;;;57276:18;57296:12;57248:27;:61::i;:::-;57322:21;;57318:670;;57539:1;57519:16;:21;;:81;;;;-1:-1:-1;57573:19:0;;:27;;57597:2;57573:23;:27::i;:::-;57553:16;:47;;57519:81;57511:134;;;;;;;;;;;;:::i;:::-;57959:12;57953:2;57935:16;57931:25;57917:12;57913:44;57906:66;57895:86;57995:12;58020:8;58012:22;;58035:12;58012:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57994:54;;;58060:7;58055:173;;58158:16;58155:1;;58137:38;58195:16;58155:1;58185:27;58126:95;58242:40;;;;;58286:37;;;;58242:25;;;;;;:40;;58276:4;;58242:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:81;58234:118;;;;;;;;;;;;:::i;:::-;58376:64;58419:20;58376:13;:23;;;58408:4;58376:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:42;;:64::i;:::-;58359:81;;58473:18;58455:14;:36;;58447:77;;;;;;;;;;;;:::i;:::-;58595:13;58538:122;;58562:15;58538:122;;;58618:12;58639:14;58538:122;;;;;;;:::i;:::-;;;;;;;;55844:2822;;;;;;;;;;;;;:::o;12009:355::-;12129:10;;;12128:62;;-1:-1:-1;12145:39:0;;;;;:15;;;;;;:39;;12169:4;;12176:7;;12145:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;12128:62;12112:150;;;;;;;;;;;;:::i;:::-;12269:89;12288:5;12318:22;;;12342:7;12351:5;12295:62;;;;;;;;;:::i;12370:567::-;12454:27;12462:5;12454:25;;;:27::i;:::-;12446:71;;;;;;;;;;;;:::i;:::-;12583:12;12597:23;12632:5;12624:19;;12644:4;12624:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12582:67;;;;12664:7;12656:52;;;;;;;;;;;;:::i;:::-;12721:17;;:21;12717:215;;12858:10;12847:30;;;;;;;;;;;;:::i;:::-;12839:85;;;;;;;;;;;;:::i;:::-;12370:567;;;;:::o;1433:130::-;1491:7;1514:43;1518:1;1521;1514:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1507:50;1433:130;-1:-1:-1;;;1433:130:0:o;1011:167::-;1069:7;1097:5;;;1117:6;;;;1109:46;;;;;;;;;;;;:::i;11780:223::-;11902:95;11921:5;11951:27;;;11980:4;11986:2;11990:5;11928:68;;;;;;;;;;:::i;41106:255::-;41173:5;41187:14;41204:5;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41187:33;;41300:2;41288:8;:14;;;;41280:53;;;;;;;;;;;;:::i;40887:113::-;40967:27;;;;;40944:7;;40967:20;:6;:20;;;;:27;;40988:5;;40967:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2267:431::-;2325:7;2554:6;2550:37;;-1:-1:-1;2578:1:0;2571:8;;2550:37;2607:5;;;2611:1;2607;:5;:1;2627:5;;;;;:10;2619:56;;;;;;;;;;;;:::i;3142:126::-;3200:7;3223:39;3227:1;3230;3223:39;;;;;;;;;;;;;;;;;:3;:39::i;52988:362::-;53066:7;53086:10;;;:29;;-1:-1:-1;53100:15:0;;53086:29;53082:60;;;-1:-1:-1;53133:1:0;53126:8;;53082:60;53212:10;53176:32;53212:10;53175:47;;;;;53166:5;:56;;53231:35;;;;;;;;;;;;;;;;;53150:123;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;52643:3:0;53290:18;;52714:21;53290:33;53289:55;;52988:362::o;9043:597::-;9103:4;9550:20;;9394:66;9591:23;;;;;;:42;;-1:-1:-1;9618:15:0;;;9591:42;9583:51;9043:597;-1:-1:-1;;;;9043:597:0:o;1838:198::-;1944:7;1976:12;1968:6;;;;1960:29;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;2008:5:0;;;1838:198::o;3732:343::-;3838:7;3932:12;3925:5;3917:28;;;;;;;;;;;;;:::i;:::-;;3952:9;3968:1;3964;:5;;;;;;;3732:343;-1:-1:-1;;;;;3732:343:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::o;142:134::-;220:13;;238:33;220:13;238:33;:::i;301:352::-;;;431:3;424:4;416:6;412:17;408:27;398:2;;-1:-1;;439:12;398:2;-1:-1;469:20;;509:18;498:30;;495:2;;;-1:-1;;531:12;495:2;575:4;567:6;563:17;551:29;;626:3;575:4;;610:6;606:17;567:6;592:32;;589:41;586:2;;;643:1;;633:12;586:2;391:262;;;;;:::o;1325:336::-;;;1439:3;1432:4;1424:6;1420:17;1416:27;1406:2;;-1:-1;;1447:12;1406:2;-1:-1;1477:20;;1517:18;1506:30;;1503:2;;;-1:-1;;1539:12;1503:2;1583:4;1575:6;1571:17;1559:29;;1634:3;1583:4;1614:17;1575:6;1600:32;;1597:41;1594:2;;;1651:1;;1641:12;2464:182;2557:20;;2582:59;2557:20;2582:59;:::i;2927:903::-;;3049:4;3037:9;3032:3;3028:19;3024:30;3021:2;;;-1:-1;;3057:12;3021:2;3085:20;3049:4;3085:20;:::i;:::-;3076:29;;6797:6;6784:20;3171:16;3164:75;3304:2;3362:9;3358:22;6784:20;3304:2;3323:5;3319:16;3312:75;3445:2;3501:9;3497:22;7199:20;7224:31;7249:5;7224:31;:::i;:::-;3478:47;3445:2;3464:5;3460:16;3453:73;;3584:2;3642:9;3638:22;1241:20;3584:2;3603:5;3599:16;3592:75;3725:3;3784:9;3780:22;1241:20;3725:3;3745:5;3741:16;3734:75;3015:815;;;;:::o;3884:360::-;;4024:4;4012:9;4007:3;4003:19;3999:30;3996:2;;;-1:-1;;4032:12;3996:2;4060:20;4024:4;4060:20;:::i;:::-;6932:13;;4137:86;;-1:-1;4051:29;3990:254;-1:-1;3990:254::o;6576:134::-;6654:13;;40685:34;40674:46;;44498:35;;44488:2;;44547:1;;44537:12;6995:132;7072:13;;41102:12;41091:24;;44745:34;;44735:2;;44793:1;;44783:12;7267:130;7343:13;;7361:31;7343:13;7361:31;:::i;7404:241::-;;7508:2;7496:9;7487:7;7483:23;7479:32;7476:2;;;-1:-1;;7514:12;7476:2;85:6;72:20;97:33;124:5;97:33;:::i;7652:263::-;;7767:2;7755:9;7746:7;7742:23;7738:32;7735:2;;;-1:-1;;7773:12;7735:2;226:6;220:13;238:33;265:5;238:33;:::i;7922:1335::-;;;;;;;;;;8218:3;8206:9;8197:7;8193:23;8189:33;8186:2;;;-1:-1;;8225:12;8186:2;8283:17;8270:31;8321:18;;8313:6;8310:30;8307:2;;;-1:-1;;8343:12;8307:2;8381:80;8453:7;8444:6;8433:9;8429:22;8381:80;:::i;:::-;8363:98;;-1:-1;8363:98;-1:-1;8526:2;8511:18;;8498:32;;-1:-1;8539:30;;;8536:2;;;-1:-1;;8572:12;8536:2;8610:80;8682:7;8673:6;8662:9;8658:22;8610:80;:::i;:::-;8592:98;;-1:-1;8592:98;-1:-1;8755:2;8740:18;;8727:32;;-1:-1;8768:30;;;8765:2;;;-1:-1;;8801:12;8765:2;8839:80;8911:7;8902:6;8891:9;8887:22;8839:80;:::i;:::-;8821:98;;-1:-1;8821:98;-1:-1;8956:2;8995:22;;72:20;;-1:-1;97:33;72:20;97:33;:::i;:::-;8964:63;;-1:-1;9092:3;9077:19;;9064:33;;9106:30;;;9103:2;;;-1:-1;;9139:12;9103:2;;9177:64;9233:7;9224:6;9213:9;9209:22;9177:64;:::i;:::-;9159:82;;;;;;;;;;8180:1077;;;;;;;;;;;:::o;9264:257::-;;9376:2;9364:9;9355:7;9351:23;9347:32;9344:2;;;-1:-1;;9382:12;9344:2;1120:6;1114:13;43782:5;40151:13;40144:21;43760:5;43757:32;43747:2;;-1:-1;;43793:12;9528:1455;;;;;;;;;;9863:9;9854:7;9850:23;9875:3;9850:23;9846:33;9843:2;;;-1:-1;;9882:12;9843:2;2220:6;2207:20;2232:55;2281:5;2232:55;:::i;:::-;9934:85;-1:-1;10056:2;10117:22;;2207:20;2232:55;2207:20;2232:55;:::i;:::-;10064:85;-1:-1;10186:2;10225:22;;6784:20;;-1:-1;10294:2;10333:22;;6784:20;;-1:-1;10402:3;10442:22;;6784:20;;-1:-1;10539:3;10524:19;;10511:33;10564:18;10553:30;;10550:2;;;-1:-1;;10586:12;10550:2;10624:64;10680:7;10671:6;10660:9;10656:22;10624:64;:::i;:::-;10606:82;;-1:-1;10606:82;-1:-1;;10725:3;10791:22;;2557:20;2582:59;2557:20;2582:59;:::i;:::-;10734:89;-1:-1;10539:3;2805:16;;;2801:26;2798:2;;;-1:-1;;2830:12;2798:2;;10860:3;10939:9;10935:22;10869:98;;9837:1146;;;;;;;;;;;:::o;10990:1135::-;;;;;;;11269:3;11257:9;11248:7;11244:23;11240:33;11237:2;;;-1:-1;;11276:12;11237:2;2220:6;2207:20;2232:55;2281:5;2232:55;:::i;:::-;11328:85;-1:-1;11450:2;11489:22;;6784:20;;-1:-1;11558:2;11597:22;;6784:20;;-1:-1;11694:2;11679:18;;11666:32;11718:18;11707:30;;11704:2;;;-1:-1;;11740:12;11704:2;11800:22;;1764:4;1752:17;;1748:27;-1:-1;1738:2;;-1:-1;;1779:12;1738:2;1826:6;1813:20;1848:64;1863:48;1904:6;1863:48;:::i;:::-;1848:64;:::i;:::-;1932:6;1925:5;1918:21;2036:3;11450:2;2027:6;1960;2018:16;;2015:25;2012:2;;;-1:-1;;2043:12;2012:2;2063:41;2097:6;11450:2;1994:5;1990:16;11450:2;1960:6;1956:17;2063:41;:::i;:::-;11760:72;;;;;;11888:79;11959:7;11869:3;11939:9;11935:22;11888:79;:::i;:::-;11878:89;;12023:86;12101:7;12004:3;12081:9;12077:22;12023:86;:::i;:::-;12013:96;;11231:894;;;;;;;;:::o;12408:308::-;;12545:3;12533:9;12524:7;12520:23;12516:33;12513:2;;;-1:-1;;12552:12;12513:2;12614:86;12692:7;12668:22;12614:86;:::i;12723:320::-;;12866:3;;12854:9;12845:7;12841:23;12837:33;12834:2;;;-1:-1;;12873:12;12834:2;4452:22;12866:3;4452:22;:::i;:::-;4443:31;;4565:100;4661:3;4637:22;4565:100;:::i;:::-;4547:16;4540:126;4770:60;4826:3;4737:2;4806:9;4802:22;4770:60;:::i;:::-;4737:2;4756:5;4752:16;4745:86;4940:60;4996:3;4907:2;4976:9;4972:22;4940:60;:::i;:::-;4907:2;4926:5;4922:16;4915:86;5111:60;5167:3;5078:2;5147:9;5143:22;5111:60;:::i;:::-;5078:2;5097:5;5093:16;5086:86;5288:60;5344:3;5254;5324:9;5320:22;5288:60;:::i;:::-;5254:3;5274:5;5270:16;5263:86;5463:60;5519:3;5429;5499:9;5495:22;5463:60;:::i;:::-;5429:3;5449:5;5445:16;5438:86;5634:59;5689:3;5600;5669:9;5665:22;5634:59;:::i;:::-;5600:3;5620:5;5616:16;5609:85;5798:60;5854:3;5764;5834:9;5830:22;5798:60;:::i;:::-;5764:3;5784:5;5780:16;5773:86;5938:3;5974:60;6030:3;5938;6010:9;6006:22;5974:60;:::i;:::-;5954:18;;;5947:88;6116:3;6152:60;6208:3;6184:22;;;6152:60;:::i;:::-;6132:18;;;6125:88;6297:3;6333:60;6389:3;6365:22;;;6333:60;:::i;:::-;6313:18;;;6306:88;6453:3;6489:58;6543:3;6519:22;;;6489:58;:::i;:::-;6469:18;;;6462:86;6473:5;12828:215;-1:-1;;;12828:215::o;13050:263::-;;13165:2;13153:9;13144:7;13140:23;13136:32;13133:2;;;-1:-1;;13171:12;13133:2;-1:-1;6932:13;;13127:186;-1:-1;13127:186::o;13320:259::-;;13433:2;13421:9;13412:7;13408:23;13404:32;13401:2;;;-1:-1;;13439:12;13401:2;7349:6;7343:13;7361:31;7386:5;7361:31;:::i;23281:271::-;;14246:5;39492:12;14357:52;14402:6;14397:3;14390:4;14383:5;14379:16;14357:52;:::i;:::-;14421:16;;;;;23415:137;-1:-1;;23415:137::o;23559:222::-;40896:42;40885:54;;;;13806:37;;23686:2;23671:18;;23657:124::o;24033:333::-;40896:42;40885:54;;;13806:37;;40885:54;;24352:2;24337:18;;13806:37;24188:2;24173:18;;24159:207::o;24373:444::-;40896:42;40885:54;;;13806:37;;40885:54;;;;24720:2;24705:18;;13806:37;24803:2;24788:18;;14037:37;;;;24556:2;24541:18;;24527:290::o;24824:884::-;40896:42;40885:54;;;13806:37;;40885:54;;;;25280:2;25265:18;;13806:37;25363:2;25348:18;;14037:37;;;;25446:2;25431:18;;14037:37;;;;41198:4;41187:16;25525:3;25510:19;;23234:35;25609:3;25594:19;;14037:37;25693:3;25678:19;;14037:37;;;;25115:3;25100:19;;25086:622::o;25715:333::-;40896:42;40885:54;;;;13806:37;;26034:2;26019:18;;14037:37;25870:2;25855:18;;25841:207::o;26055:444::-;40896:42;40885:54;;;13806:37;;26402:2;26387:18;;14037:37;;;;40885:54;;;26485:2;26470:18;;13806:37;26238:2;26223:18;;26209:290::o;26506:586::-;40896:42;40885:54;;;13806:37;;26897:2;26882:18;;14037:37;;;;40885:54;;26988:2;26973:18;;13665:58;40804:6;40793:18;;;27078:2;27063:18;;15295:57;26732:3;26717:19;;26703:389::o;27676:210::-;40151:13;;40144:21;13920:34;;27797:2;27782:18;;27768:118::o;29045:310::-;;29192:2;29213:17;29206:47;15509:5;39492:12;39931:6;29192:2;29181:9;29177:18;39919:19;15603:52;15648:6;39959:14;29181:9;39959:14;29192:2;15629:5;15625:16;15603:52;:::i;:::-;43560:2;43540:14;43556:7;43536:28;15667:39;;;;39959:14;15667:39;;29163:192;-1:-1;;29163:192::o;29362:416::-;29562:2;29576:47;;;15943:2;29547:18;;;39919:19;15979:29;39959:14;;;15959:50;16028:12;;;29533:245::o;29785:416::-;29985:2;29999:47;;;16279:2;29970:18;;;39919:19;16315:29;39959:14;;;16295:50;16364:12;;;29956:245::o;30208:416::-;30408:2;30422:47;;;16615:2;30393:18;;;39919:19;16651:34;39959:14;;;16631:55;16720:8;16706:12;;;16699:30;16748:12;;;30379:245::o;30631:416::-;30831:2;30845:47;;;16999:2;30816:18;;;39919:19;17035:29;39959:14;;;17015:50;17084:12;;;30802:245::o;31054:416::-;31254:2;31268:47;;;17335:2;31239:18;;;39919:19;17371:34;39959:14;;;17351:55;17440:9;17426:12;;;17419:31;17469:12;;;31225:245::o;31477:416::-;31677:2;31691:47;;;17720:2;31662:18;;;39919:19;17756:18;39959:14;;;17736:39;17794:12;;;31648:245::o;31900:416::-;32100:2;32114:47;;;32085:18;;;39919:19;18081:34;39959:14;;;18061:55;18135:12;;;32071:245::o;32323:416::-;32523:2;32537:47;;;32508:18;;;39919:19;18422:34;39959:14;;;18402:55;18476:12;;;32494:245::o;32746:416::-;32946:2;32960:47;;;18727:2;32931:18;;;39919:19;18763:30;39959:14;;;18743:51;18813:12;;;32917:245::o;33169:416::-;33369:2;33383:47;;;19064:2;33354:18;;;39919:19;19100:33;39959:14;;;19080:54;19153:12;;;33340:245::o;33592:416::-;33792:2;33806:47;;;19404:2;33777:18;;;39919:19;19440:29;39959:14;;;19420:50;19489:12;;;33763:245::o;34015:416::-;34215:2;34229:47;;;19740:2;34200:18;;;39919:19;19776:34;39959:14;;;19756:55;19845:3;19831:12;;;19824:25;19868:12;;;34186:245::o;34438:416::-;34638:2;34652:47;;;34623:18;;;39919:19;20155:34;39959:14;;;20135:55;20209:12;;;34609:245::o;34861:416::-;35061:2;35075:47;;;20460:2;35046:18;;;39919:19;20496:26;39959:14;;;20476:47;20542:12;;;35032:245::o;35284:416::-;35484:2;35498:47;;;20793:2;35469:18;;;39919:19;20829:34;39959:14;;;20809:55;20898:12;20884;;;20877:34;20930:12;;;35455:245::o;35707:416::-;35907:2;35921:47;;;21181:2;35892:18;;;39919:19;21217:33;39959:14;;;21197:54;21270:12;;;35878:245::o;36130:416::-;36330:2;36344:47;;;21521:2;36315:18;;;39919:19;21557:34;39959:14;;;21537:55;21626:24;21612:12;;;21605:46;21670:12;;;36301:245::o;36553:416::-;36753:2;36767:47;;;21921:2;36738:18;;;39919:19;21957:33;39959:14;;;21937:54;22010:12;;;36724:245::o;36976:416::-;37176:2;37190:47;;;22261:2;37161:18;;;39919:19;22297:29;39959:14;;;22277:50;22346:12;;;37147:245::o;37399:416::-;37599:2;37613:47;;;22597:2;37584:18;;;39919:19;22633:33;39959:14;;;22613:54;22686:12;;;37570:245::o;37822:416::-;38022:2;38036:47;;;22937:2;38007:18;;;39919:19;22973:28;39959:14;;;22953:49;23021:12;;;37993:245::o;38245:222::-;14037:37;;;38372:2;38357:18;;38343:124::o;38474:333::-;14037:37;;;38793:2;38778:18;;14037:37;38629:2;38614:18;;38600:207::o;38814:256::-;38876:2;38870:9;38902:17;;;38977:18;38962:34;;38998:22;;;38959:62;38956:2;;;39034:1;;39024:12;38956:2;38876;39043:22;38854:216;;-1:-1;38854:216::o;39077:321::-;;39220:18;39212:6;39209:30;39206:2;;;-1:-1;;39242:12;39206:2;-1:-1;39319:4;39296:17;39315:9;39292:33;39383:4;39373:15;;39143:255::o;43042:145::-;43123:6;43118:3;43113;43100:30;-1:-1;43179:1;43161:16;;43154:27;43093:94::o;43196:268::-;43261:1;43268:101;43282:6;43279:1;43276:13;43268:101;;;43349:11;;;43343:18;43330:11;;;43323:39;43304:2;43297:10;43268:101;;;43384:6;43381:1;43378:13;43375:2;;;-1:-1;;43261:1;43431:16;;43424:27;43245:219::o;43577:117::-;40896:42;43664:5;40885:54;43639:5;43636:35;43626:2;;43685:1;;43675:12;44809:113;41198:4;44892:5;41187:16;44869:5;44866:33;44856:2;;44913:1;;44903:12

ipfs://68de4a26d51f06b21a413b75e907d8f9100bef32d22642b997b9f9385e992c23