Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(
•    - function mod(uint256 a, uint256 b)
•    - function mod(
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Detailed is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function callOptionalReturn(IERC20 to ...
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• interface ILendingPoolAddressesProvid ...
•    - function getMarketId()
•    - function setMarketId(string calldata ...
•    - function setAddress(bytes32 id, addre ...
•    - function setAddressAsProxy(bytes32 id ...
•    - function getAddress(bytes32 id)
•    - function getLendingPool()
•    - function setLendingPoolImpl(address p ...
•    - function getLendingPoolConfigurator()
•    - function setLendingPoolConfiguratorIm ...
•    - function getLendingPoolCollateralMana ...
•    - function setLendingPoolCollateralMana ...
•    - function getPoolAdmin()
•    - function setPoolAdmin(address admin)
•    - function getEmergencyAdmin()
•    - function setEmergencyAdmin(address ad ...
•    - function getPriceOracle()
•    - function setPriceOracle(address price ...
•    - function getLendingRateOracle()
•    - function setLendingRateOracle(address ...
• library DataTypes
• interface IPriceOracleGetter
•    - function getAssetPrice(address asset)
• interface IERC20WithPermit is IERC20
•    - function permit(
• interface ILendingPool
•    - function deposit(
•    - function withdraw(
•    - function borrow(
•    - function repay(
•    - function swapBorrowRateMode(address a ...
•    - function rebalanceStableBorrowRate(ad ...
•    - function setUserUseReserveAsCollatera ...
•    - function liquidationCall(
•    - function flashLoan(
•    - function getUserAccountData(address u ...
•    - function initReserve(
•    - function setReserveInterestRateStrate ...
•    - function setConfiguration(address res ...
•    - function getConfiguration(address ass ...
•    - function getUserConfiguration(address ...
•    - function getReserveNormalizedIncome(a ...
•    - function getReserveNormalizedVariable ...
•    - function getReserveData(address asset ...
•    - function finalizeTransfer(
•    - function getReservesList()
•    - function getAddressesProvider()
•    - function setPause(bool val)
•    - function paused()
• interface IFlashLoanReceiver
•    - function executeOperation(
•    - function ADDRESSES_PROVIDER()
•    - function LENDING_POOL()
•    - function _getPrice(address asset)
•    - function _getDecimals(IERC20Detailed ...
•    - function _getReserveData(address asse ...
•    - function _pullATokenAndWithdraw(
•    - function _pullATokenAndWithdraw(
•    - function rescueTokens(IERC20 token)
• library Errors
• library PercentageMath
•    - function percentMul(uint256 value, ui ...
•    - function percentDiv(uint256 value, ui ...
• interface IParaSwapAugustus
•    - function getTokenTransferProxy()
• interface IParaSwapAugustusRegistry
•    - function isValidAugustus(address augu ...
•    - function _buyOnParaSwap(
•  contract ParaSwapRepayAdapter is B ... *
•    - function executeOperation(
•    - function swapAndRepay(
•    - function _swapAndRepay(
•    - function getDebtRepayAmount(

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at snowscan.xyz on 2022-02-04
*/

// 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
  );
  event Bought(
    address indexed fromAsset,
    address indexed toAsset,
    uint256 amountSold,
    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);
  }

  function _pullATokenAndWithdraw(
    address reserve,
    address user,
    uint256 amount,
    PermitSignature memory permitSignature
  ) internal {
    IERC20WithPermit reserveAToken =
      IERC20WithPermit(_getReserveData(address(reserve)).aTokenAddress);
    _pullATokenAndWithdraw(reserve, reserveAToken, user, amount, permitSignature);
  }

  /**
   * @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/BaseParaSwapBuyAdapter.sol

pragma solidity 0.6.12;






/**
 * @title BaseParaSwapBuyAdapter
 * @notice Implements the logic for buying tokens on ParaSwap
 */
abstract contract BaseParaSwapBuyAdapter 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)), "Not a valid Augustus address");
    AUGUSTUS_REGISTRY = augustusRegistry;
  }

  /**
   * @dev Swaps a token for another using ParaSwap
   * @param toAmountOffset Offset of toAmount in Augustus calldata if it should be overwritten, otherwise 0
   * @param paraswapData Data for Paraswap Adapter
   * @param assetToSwapFrom Address of the asset to be swapped from
   * @param assetToSwapTo Address of the asset to be swapped to
   * @param maxAmountToSwap Max amount to be swapped
   * @param amountToReceive Amount to be received from the swap
   * @return amountSold The amount sold during the swap
   */
  function _buyOnParaSwap(
    uint256 toAmountOffset,
    bytes memory paraswapData,
    IERC20Detailed assetToSwapFrom,
    IERC20Detailed assetToSwapTo,
    uint256 maxAmountToSwap,
    uint256 amountToReceive
  ) internal returns (uint256 amountSold) {
    (bytes memory buyCalldata, IParaSwapAugustus augustus) =
      abi.decode(paraswapData, (bytes, IParaSwapAugustus));

    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 expectedMaxAmountToSwap =
        amountToReceive
          .mul(toAssetPrice.mul(10**fromAssetDecimals))
          .div(fromAssetPrice.mul(10**toAssetDecimals))
          .percentMul(PercentageMath.PERCENTAGE_FACTOR.add(MAX_SLIPPAGE_PERCENT));

      require(maxAmountToSwap <= expectedMaxAmountToSwap, 'maxAmountToSwap exceed max slippage');
    }

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

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

    if (toAmountOffset != 0) {
      // Ensure 256 bit (32 bytes) toAmountOffset value is within bounds of the
      // calldata, not overlapping with the first 4 bytes (function selector).
      require(
        toAmountOffset >= 4 && toAmountOffset <= buyCalldata.length.sub(32),
        'TO_AMOUNT_OFFSET_OUT_OF_RANGE'
      );
      // Overwrite the toAmount with the correct amount for the buy.
      // In memory, buyCalldata 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(buyCalldata, add(toAmountOffset, 32)), amountToReceive)
      }
    }
    (bool success, ) = address(augustus).call(buyCalldata);
    if (!success) {
      // Copy revert reason from call
      assembly {
        returndatacopy(0, 0, returndatasize())
        revert(0, returndatasize())
      }
    }

    uint256 balanceAfterAssetFrom = assetToSwapFrom.balanceOf(address(this));
    amountSold = balanceBeforeAssetFrom - balanceAfterAssetFrom;
    require(amountSold <= maxAmountToSwap, 'WRONG_BALANCE_AFTER_SWAP');
    uint256 amountReceived = assetToSwapTo.balanceOf(address(this)).sub(balanceBeforeAssetTo);
    require(amountReceived >= amountToReceive, 'INSUFFICIENT_AMOUNT_RECEIVED');

    emit Bought(address(assetToSwapFrom), address(assetToSwapTo), amountSold, 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/ParaSwapRepayAdapter.sol

pragma solidity 0.6.12;









/**
 * @title UniswapRepayAdapter
 * @notice Uniswap V2 Adapter to perform a repay of a debt with collateral.
 * @author Aave
 **/
contract ParaSwapRepayAdapter is BaseParaSwapBuyAdapter, ReentrancyGuard {
  struct RepayParams {
    address collateralAsset;
    uint256 collateralAmount;
    uint256 rateMode;
    PermitSignature permitSignature;
    bool useEthPath;
  }

  constructor(
    ILendingPoolAddressesProvider addressesProvider,
    IParaSwapAugustusRegistry augustusRegistry
  ) public BaseParaSwapBuyAdapter(addressesProvider, augustusRegistry) {
    // This is only required to initialize BaseParaSwapBuyAdapter
  }

  /**
   * @dev Uses the received funds from the flash loan to repay a debt on the protocol on behalf of the user. Then pulls
   * the collateral from the user and swaps it to the debt asset to repay the flash loan.
   * The user should give this contract allowance to pull the ATokens in order to withdraw the underlying asset, swap it
   * and repay the flash loan.
   * Supports only one asset on the flash loan.
   * @param assets Address of collateral asset(Flash loan asset)
   * @param amounts Amount of flash loan taken
   * @param premiums Fee of the flash loan
   * @param initiator Address of the user
   * @param params Additional variadic field to include extra params. Expected parameters:
   *   IERC20Detailed debtAsset Address of the debt asset
   *   uint256 debtAmount Amount of debt to be repaid
   *   uint256 rateMode Rate modes of the debt to be repaid
   *   uint256 deadline Deadline for the permit signature
   *   uint256 debtRateMode Rate mode of the debt to be repaid
   *   bytes paraswapData Paraswap Data
   *                    * bytes buyCallData Call data for augustus
   *                    * IParaSwapAugustus augustus Address of Augustus Swapper
   *   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 collateralAmount = amounts[0];
    uint256 premium = premiums[0];
    address initiatorLocal = initiator;
    
    IERC20Detailed collateralAsset = IERC20Detailed(assets[0]);
    
    _swapAndRepay(
      params,
      premium,
      initiatorLocal,
      collateralAsset,
      collateralAmount
    );

    return true;
  }

  /**
   * @dev Swaps the user collateral for the debt asset and then repay the debt on the protocol on behalf of the user
   * without using flash loans. 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
   * @param collateralAsset Address of asset to be swapped
   * @param debtAsset Address of debt asset
   * @param collateralAmount max Amount of the collateral to be swapped
   * @param debtRepayAmount Amount of the debt to be repaid, or maximum amount when repaying entire debt
   * @param debtRateMode Rate mode of the debt to be repaid
   * @param buyAllBalanceOffset Set to offset of toAmount in Augustus calldata if wanting to pay entire debt, otherwise 0
   * @param paraswapData Data for Paraswap Adapter
   * @param permitSignature struct containing the permit signature

   */
  function swapAndRepay(
    IERC20Detailed collateralAsset,
    IERC20Detailed debtAsset,
    uint256 collateralAmount,
    uint256 debtRepayAmount,
    uint256 debtRateMode,
    uint256 buyAllBalanceOffset,
    bytes calldata paraswapData,
    PermitSignature calldata permitSignature
  ) external nonReentrant {

    debtRepayAmount = getDebtRepayAmount(
      debtAsset,
      debtRateMode,
      buyAllBalanceOffset,
      debtRepayAmount,
      msg.sender
    );

    // Pull aTokens from user
    _pullATokenAndWithdraw(address(collateralAsset), msg.sender, collateralAmount, permitSignature);
    //buy debt asset using collateral asset
    uint256 amountSold =
      _buyOnParaSwap(
        buyAllBalanceOffset,
        paraswapData,
        collateralAsset,
        debtAsset,
        collateralAmount,
        debtRepayAmount
      );

    uint256 collateralBalanceLeft = collateralAmount - amountSold;

    //deposit collateral back in the pool, if left after the swap(buy)
    if (collateralBalanceLeft > 0) {
      IERC20(collateralAsset).safeApprove(address(LENDING_POOL), 0);
      IERC20(collateralAsset).safeApprove(address(LENDING_POOL), collateralBalanceLeft);
      LENDING_POOL.deposit(address(collateralAsset), collateralBalanceLeft, msg.sender, 0);
    }

    // Repay debt. Approves 0 first to comply with tokens that implement the anti frontrunning approval fix
    IERC20(debtAsset).safeApprove(address(LENDING_POOL), 0);
    IERC20(debtAsset).safeApprove(address(LENDING_POOL), debtRepayAmount);
    LENDING_POOL.repay(address(debtAsset), debtRepayAmount, debtRateMode, msg.sender);
  }

  /**
   * @dev Perform the repay of the debt, pulls the initiator collateral and swaps to repay the flash loan
   * @param premium Fee of the flash loan
   * @param initiator Address of the user
   * @param collateralAsset Address of token to be swapped
   * @param collateralAmount Amount of the reserve to be swapped(flash loan amount)
   */

  function _swapAndRepay(
    bytes calldata params,
    uint256 premium,
    address initiator,
    IERC20Detailed collateralAsset,
    uint256 collateralAmount
  ) private {

    (
      IERC20Detailed debtAsset,
      uint256 debtRepayAmount,
      uint256 buyAllBalanceOffset,
      uint256 rateMode,
      bytes memory paraswapData,
      PermitSignature memory permitSignature
    ) = abi.decode(params, (IERC20Detailed, uint256, uint256, uint256, bytes, PermitSignature));

    debtRepayAmount = getDebtRepayAmount(
      debtAsset,
      rateMode,
      buyAllBalanceOffset,
      debtRepayAmount,
      initiator
    );

    uint256 amountSold =
      _buyOnParaSwap(
        buyAllBalanceOffset,
        paraswapData,
        collateralAsset,
        debtAsset,
        collateralAmount,
        debtRepayAmount
      );

    // Repay debt. Approves for 0 first to comply with tokens that implement the anti frontrunning approval fix.
    IERC20(debtAsset).safeApprove(address(LENDING_POOL), 0);
    IERC20(debtAsset).safeApprove(address(LENDING_POOL), debtRepayAmount);
    LENDING_POOL.repay(address(debtAsset), debtRepayAmount, rateMode, initiator);

    uint256 neededForFlashLoanRepay = amountSold.add(premium);

    // Pull aTokens from user
    _pullATokenAndWithdraw(
      address(collateralAsset),
      initiator,
      neededForFlashLoanRepay,
      permitSignature
    );

    // Repay flashloan. Approves for 0 first to comply with tokens that implement the anti frontrunning approval fix.
    IERC20(collateralAsset).safeApprove(address(LENDING_POOL), 0);
    IERC20(collateralAsset).safeApprove(address(LENDING_POOL), collateralAmount.add(premium));
  }

  function getDebtRepayAmount(
    IERC20Detailed debtAsset,
    uint256 rateMode,
    uint256 buyAllBalanceOffset,
    uint256 debtRepayAmount,
    address initiator
  ) private view returns (uint256) {
    DataTypes.ReserveData memory debtReserveData = _getReserveData(address(debtAsset));

    address debtToken =
      DataTypes.InterestRateMode(rateMode) == DataTypes.InterestRateMode.STABLE
        ? debtReserveData.stableDebtTokenAddress
        : debtReserveData.variableDebtTokenAddress;

    uint256 currentDebt = IERC20(debtToken).balanceOf(initiator);

    if (buyAllBalanceOffset != 0) {
      require(currentDebt <= debtRepayAmount, 'INSUFFICIENT_AMOUNT_TO_REPAY');
      debtRepayAmount = currentDebt;
    } else {
      require(debtRepayAmount <= currentDebt, 'INVALID_DEBT_REPAY_AMOUNT');
    }

    return debtRepayAmount;
  }
}

• 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":"fromAsset","type":"address"},{"indexed":true,"internalType":"address","name":"toAsset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountSold","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"receivedAmount","type":"uint256"}],"name":"Bought","type":"event"},{"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":"collateralAsset","type":"address"},{"internalType":"contract IERC20Detailed","name":"debtAsset","type":"address"},{"internalType":"uint256","name":"collateralAmount","type":"uint256"},{"internalType":"uint256","name":"debtRepayAmount","type":"uint256"},{"internalType":"uint256","name":"debtRateMode","type":"uint256"},{"internalType":"uint256","name":"buyAllBalanceOffset","type":"uint256"},{"internalType":"bytes","name":"paraswapData","type":"bytes"},{"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":"permitSignature","type":"tuple"}],"name":"swapAndRepay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000b6a86025f0fe1862b372cb0ca18ce3ede02a318f000000000000000000000000fd1e5821f07f1af812bb7f3102bfd9ffb279513a

-----Decoded View---------------
Arg [0] : addressesProvider (address): 0xb6A86025F0FE1862B372cb0ca18CE3EDe02A318f
Arg [1] : augustusRegistry (address): 0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b6a86025f0fe1862b372cb0ca18ce3ede02a318f
Arg [1] : 000000000000000000000000fd1e5821f07f1af812bb7f3102bfd9ffb279513a

62215:8282:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43508:127;;;;;;:::i;:::-;;:::i;:::-;;39386:74;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40304:51;;;:::i;:::-;;;;;;;:::i;40369:42::-;;;:::i;55263:60::-;;;:::i;65874:1657::-;;;;;;:::i;:::-;;:::i;15594:138::-;;;:::i;14992:73::-;;;:::i;64053:813::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39465:51::-;;;:::i;15877:230::-;;;;;;:::i;:::-;;:::i;43508:127::-;15196:12;:10;:12::i;:::-;15186:6;;:22;:6;;;:22;;;15178:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43570:59:::1;43589:7;:5;:7::i;:::-;43598:30;::::0;;;;:15:::1;::::0;::::1;::::0;::::1;::::0;:30:::1;::::0;43622:4:::1;::::0;43598:30:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43570:18;::::0;::::1;::::0;:59;:18:::1;:59::i;:::-;43508:127:::0;:::o;39386:74::-;;;:::o;40304:51::-;40351:4;40304:51;:::o;40369:42::-;;;:::o;55263:60::-;;;:::o;65874:1657::-;61024:1;61630:7;;:19;;61622:63;;;;;;;;;;;;:::i;:::-;61024:1;61763:7;:18;66221:135:::1;66248:9:::0;66266:12;66287:19;66315:15;66339:10:::1;66221:18;:135::i;:::-;66203:153:::0;-1:-1:-1;66396:95:0::1;66427:15:::0;66445:10:::1;66457:16:::0;66396:95:::1;;::::0;;::::1;::::0;::::1;66475:15:::0;66396:95:::1;:::i;:::-;:22;:95::i;:::-;66543:18;66571:175;66596:19;66626:12;;66571:175;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;66649:15:0;;-1:-1:-1;66675:9:0;;-1:-1:-1;66695:16:0;;-1:-1:-1;66722:15:0;66571:14:::1;:175::i;:::-;66543:203:::0;-1:-1:-1;66787:29:0;;::::1;66901:25:::0;;66897:292:::1;;66937:61;:35;::::0;::::1;66981:12;66996:1;66937:35;:61::i;:::-;67007:81;:35;::::0;::::1;67051:12;67066:21:::0;67007:35:::1;:81::i;:::-;67097:84;::::0;;;;:20:::1;:12;:20;::::0;::::1;::::0;:84:::1;::::0;67126:15;;67144:21;;67167:10:::1;::::0;67179:1:::1;::::0;67097:84:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;66897:292;67306:55;:29;::::0;::::1;67344:12;67359:1;67306:29;:55::i;:::-;67368:69;:29;::::0;::::1;67406:12;67421:15:::0;67368:29:::1;:69::i;:::-;67444:81;::::0;;;;:18:::1;:12;:18;::::0;::::1;::::0;:81:::1;::::0;67471:9;;67483:15;;67500:12;;67514:10:::1;::::0;67444:81:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;60980:1:0;61942:22;;-1:-1:-1;;;;;;;;;;65874:1657:0: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;64053:813::-;64275:4;61024:1;61630:7;;:19;;61622:63;;;;;;;;;;;;:::i;:::-;61024:1;61763:7;:18;64296:10:::1;:35;64318:12;64296:35;;64288:75;;;;;;;;;;;;:::i;:::-;64405:1;64388:18:::0;::::1;:41:::0;::::1;;;-1:-1:-1::0;64428:1:0::1;64410:19:::0;::::1;64388:41;:65;;;;-1:-1:-1::0;64452:1:0::1;64433:20:::0;::::1;64388:65;64372:138;;;;;;;;;;;;:::i;:::-;64519:24;64546:7;;64554:1;64546:10;;;;;;;;;;;;;64519:37;;64563:15;64581:8;;64590:1;64581:11;;;;;;;;;;;;;64563:29;;64599:22;64624:9;64599:34;;64646:30;64694:6;;64701:1;64694:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;64646:58;;64717:123;64739:6;;64754:7;64770:14;64793:15;64817:16;64717:13;:123::i;:::-;-1:-1:-1::0;;64856:4:0::1;61942:22:::0;;;64856:4;64053:813;-1:-1:-1;;;;;;;;;;;;64053:813:0:o;39465:51::-;;;:::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;69627:867::-;69824:7;69840:44;;:::i;:::-;69887:35;69911:9;69887:15;:35::i;:::-;69840:82;-1:-1:-1;69931:17:0;69998:33;69985:8;69958:36;;;;;;;;:73;;;;;;;;;:175;;70093:15;:40;;;69958:175;;;70043:15;:38;;;69958:175;69931:202;;70142:19;70171:9;70164:27;;;70192:9;70164:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70142:60;-1:-1:-1;70215:24:0;;70211:247;;70273:15;70258:11;:30;;70250:71;;;;;;;;;;;;:::i;:::-;70348:11;70330:29;;70211:247;;;70409:11;70390:15;:30;;70382:68;;;;;;;;;;;;:::i;:::-;-1:-1:-1;70473:15:0;;69627:867;-1:-1:-1;;;;;;;69627:867:0:o;41786:355::-;41946:30;42003:33;42027:7;42003:15;:33::i;:::-;:47;;;41946:105;;42058:77;42081:7;42090:13;42105:4;42111:6;42119:15;42058:22;:77::i;:::-;41786:355;;;;;:::o;56262:2988::-;56502:18;56530:24;56556:26;56604:12;56593:52;;;;;;;;;;;;:::i;:::-;56662;;;;;56529:116;;-1:-1:-1;56529:116:0;-1:-1:-1;56662:33:0;:17;:33;;;;:52;;56529:116;;56662:52;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56654:81;;;;;;;;;;;;:::i;:::-;56753:25;56781:29;56794:15;56781:12;:29::i;:::-;56753:57;;;;56819:23;56845:27;56858:13;56845:12;:27::i;:::-;56819:53;;;;56883:22;56908:35;56926:15;56908:9;:35::i;:::-;56883:60;;56952:20;56975:33;56993:13;56975:9;:33::i;:::-;56952:56;-1:-1:-1;57019:31:0;57062:212;57215:58;53170:3;40351:4;57215:36;:58::i;:::-;57062:129;57151:39;:14;57170:2;:19;;;57151:18;:39::i;:::-;57062:72;57094:39;:12;57111:2;:21;;;57094:16;:39::i;:::-;57062:15;;:31;:72::i;:::-;:88;;:129::i;:::-;:152;;:212::i;:::-;57019:255;;57312:23;57293:15;:42;;57285:90;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;57424:40:0;;;;;57391:30;;-1:-1:-1;57424:25:0;;;;-1:-1:-1;57424:25:0;;-1:-1:-1;57424:40:0;;57458:4;;57424:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57391:73;;57505:15;57479:22;:41;;57471:86;;;;;;;;;;;;:::i;:::-;57595:38;;;;;57564:28;;57595:23;;;;;;:38;;57627:4;;57595:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57564:69;;57642:26;57671:8;:30;;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57642:61;-1:-1:-1;57710:50:0;:27;;;57642:61;57758:1;57710:27;:50::i;:::-;57767:64;:27;;;57795:18;57815:15;57767:27;:64::i;:::-;57844:19;;57840:670;;58071:1;58053:14;:19;;:67;;;;-1:-1:-1;58094:18:0;;:26;;58117:2;58094:22;:26::i;:::-;58076:14;:44;;58053:67;58035:136;;;;;;;;;;;;:::i;:::-;58478:15;58472:2;58456:14;58452:23;58439:11;58435:41;58428:66;58417:86;58517:12;58543:8;58535:22;;58558:11;58535:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58516:54;;;58582:7;58577:173;;58680:16;58677:1;;58659:38;58717:16;58677:1;58707:27;58648:95;58790:40;;;;;58758:29;;58790:25;;;;;;:40;;58824:4;;58790:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58758:72;;58875:21;58850:22;:46;58837:59;;58925:15;58911:10;:29;;58903:66;;;;;;;;;;;;:::i;:::-;58976:22;59001:64;59044:20;59001:13;:23;;;59033:4;59001:38;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:42;;:64::i;:::-;58976:89;;59098:15;59080:14;:33;;59072:74;;;;;;;;;;;;:::i;:::-;59201:13;59160:84;;59175:15;59160:84;;;59217:10;59229:14;59160:84;;;;;;;:::i;:::-;;;;;;;;56262:2988;;;;;;;;;;;;;;;;:::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;67891:1730::-;68087:24;68120:23;68152:27;68188:16;68213:25;68247:38;;:::i;:::-;68295:87;;;;68306:6;68295:87;:::i;:::-;68078:304;;;;;;;;;;;;68409:130;68436:9;68454:8;68471:19;68499:15;68523:9;68409:18;:130::i;:::-;68391:148;;68548:18;68576:175;68601:19;68631:12;68654:15;68680:9;68700:16;68727:15;68576:14;:175::i;:::-;68548:203;-1:-1:-1;68874:55:0;:29;;;68912:12;68927:1;68874:29;:55::i;:::-;68936:69;:29;;;68974:12;68989:15;68936:29;:69::i;:::-;69012:12;:18;;;69039:9;69051:15;69068:8;69078:9;69012:76;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;69097:31:0;69131:23;:10;69146:7;69131:14;:23::i;:::-;69097:57;;69194:136;69233:15;69258:9;69276:23;69308:15;69194:22;:136::i;:::-;69458:61;:35;;;69502:12;69517:1;69458:35;:61::i;:::-;69526:89;69570:12;69585:29;:16;69606:7;69585:20;:29::i;:::-;69526:35;;;;:89;:35;:89::i;:::-;67891:1730;;;;;;;;;;;;;;:::o;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;41633:147::-;41696:28;;:::i;:::-;41740:34;;;;;:27;:12;:27;;;;:34;;41768:5;;41740:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41733:41;41633:147;-1:-1:-1;;41633:147:0:o;42467:814::-;42744:24;;;;:29;42740:272;;42784:13;:20;;;42815:4;42838;42854:15;:22;;;42887:15;:24;;;42922:15;:17;;;42950:15;:17;;;42978:15;:17;;;42784:220;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42740:272;43058:59;:30;;;43089:4;43103;43110:6;43058:30;:59::i;:::-;43167:53;;;;;43224:6;;43167:21;:12;:21;;;;:53;;43189:7;;43224:6;;43214:4;;43167:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:63;43151:124;;;;;;;;;;;;:::i;41272:255::-;41339:5;41353:14;41370:5;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41353:33;;41466:2;41454:8;:14;;;;41446:53;;;;;;;;;;;;:::i;41053:113::-;41133:27;;;;;41110:7;;41133:20;:6;:20;;;;:27;;41154:5;;41133:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;1011:167::-;1069:7;1097:5;;;1117:6;;;;1109:46;;;;;;;;;;;;:::i;:::-;1171:1;1011:167;-1:-1:-1;;;1011:167:0:o;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;53515:362::-;53593:7;53613:10;;;:29;;-1:-1:-1;53627:15:0;;53613:29;53609:60;;;-1:-1:-1;53660:1:0;53653:8;;53609:60;53739:10;53703:32;53739:10;53702:47;;;;;53693:5;:56;;53758:35;;;;;;;;;;;;;;;;;53677:123;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;53170:3:0;53817:18;;53241:21;53817:33;53816:55;;53515:362::o;1433:130::-;1491:7;1514:43;1518:1;1521;1514:43;;;;;;;;;;;;;;;;;:3;:43::i;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;11780:223::-;11902:95;11921:5;11951:27;;;11980:4;11986:2;11990:5;11928:68;;;;;;;;;;:::i;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;1838:198::-;1944:7;1976:12;1968:6;;;;1960:29;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;2008:5:0;;;1838:198::o;-1:-1:-1:-;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::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;3382:903;;3504:4;3492:9;3487:3;3483:19;3479:30;3476:2;;;-1:-1;;3512:12;3476:2;3540:20;3504:4;3540:20;:::i;:::-;3531:29;;7252:6;7239:20;3626:16;3619:75;3759:2;3817:9;3813:22;7239:20;3759:2;3778:5;3774:16;3767:75;3900:2;3956:9;3952:22;7654:20;7679:31;7704:5;7679:31;:::i;:::-;3933:47;3900:2;3919:5;3915:16;3908:73;;4039:2;4097:9;4093:22;1241:20;4039:2;4058:5;4054:16;4047:75;4180:3;4239:9;4235:22;1241:20;4180:3;4200:5;4196:16;4189:75;3470:815;;;;:::o;4339:360::-;;4479:4;4467:9;4462:3;4458:19;4454:30;4451:2;;;-1:-1;;4487:12;4451:2;4515:20;4479:4;4515:20;:::i;:::-;7387:13;;4592:86;;-1:-1;4506:29;4445:254;-1:-1;4445:254::o;7031:134::-;7109:13;;41949:34;41938:46;;45762:35;;45752:2;;45811:1;;45801:12;7450:132;7527:13;;42366:12;42355:24;;46009:34;;45999:2;;46057:1;;46047:12;7722:130;7798:13;;7816:31;7798:13;7816:31;:::i;7859:241::-;;7963:2;7951:9;7942:7;7938:23;7934:32;7931:2;;;-1:-1;;7969:12;7931:2;85:6;72:20;97:33;124:5;97:33;:::i;8107:263::-;;8222:2;8210:9;8201:7;8197:23;8193:32;8190:2;;;-1:-1;;8228:12;8190:2;226:6;220:13;238:33;265:5;238:33;:::i;8377:1335::-;;;;;;;;;;8673:3;8661:9;8652:7;8648:23;8644:33;8641:2;;;-1:-1;;8680:12;8641:2;8738:17;8725:31;8776:18;;8768:6;8765:30;8762:2;;;-1:-1;;8798:12;8762:2;8836:80;8908:7;8899:6;8888:9;8884:22;8836:80;:::i;:::-;8818:98;;-1:-1;8818:98;-1:-1;8981:2;8966:18;;8953:32;;-1:-1;8994:30;;;8991:2;;;-1:-1;;9027:12;8991:2;9065:80;9137:7;9128:6;9117:9;9113:22;9065:80;:::i;:::-;9047:98;;-1:-1;9047:98;-1:-1;9210:2;9195:18;;9182:32;;-1:-1;9223:30;;;9220:2;;;-1:-1;;9256:12;9220:2;9294:80;9366:7;9357:6;9346:9;9342:22;9294:80;:::i;:::-;9276:98;;-1:-1;9276:98;-1:-1;9411:2;9450:22;;72:20;;-1:-1;97:33;72:20;97:33;:::i;:::-;9419:63;;-1:-1;9547:3;9532:19;;9519:33;;9561:30;;;9558:2;;;-1:-1;;9594:12;9558:2;;9632:64;9688:7;9679:6;9668:9;9664:22;9632:64;:::i;:::-;9614:82;;;;;;;;;;8635:1077;;;;;;;;;;;:::o;9719:257::-;;9831:2;9819:9;9810:7;9806:23;9802:32;9799:2;;;-1:-1;;9837:12;9799:2;1120:6;1114:13;45046:5;41415:13;41408:21;45024:5;45021:32;45011:2;;-1:-1;;45057:12;9983:548;;;10150:2;10138:9;10129:7;10125:23;10121:32;10118:2;;;-1:-1;;10156:12;10118:2;10207:17;10201:24;10245:18;10237:6;10234:30;10231:2;;;-1:-1;;10267:12;10231:2;10338:22;;2224:4;2212:17;;2208:27;-1:-1;2198:2;;-1:-1;;2239:12;2198:2;2279:6;2273:13;2301:64;2316:48;2357:6;2316:48;:::i;:::-;2301:64;:::i;:::-;2385:6;2378:5;2371:21;2489:3;2421:4;2480:6;2413;2471:16;;2468:25;2465:2;;;-1:-1;;2496:12;2465:2;2516:39;2548:6;2421:4;2447:5;2443:16;2421:4;2413:6;2409:17;2516:39;:::i;:::-;10287:83;;;;;;2421:4;10487:9;10483:22;3019:13;3037:59;3090:5;3037:59;:::i;:::-;10415:100;;;;10112:419;;;;;:::o;10538:1403::-;;;;;;;;;;10847:9;10838:7;10834:23;10859:3;10834:23;10830:33;10827:2;;;-1:-1;;10866:12;10827:2;2671:6;2658:20;2683:55;2732:5;2683:55;:::i;:::-;10918:85;-1:-1;11040:2;11101:22;;2658:20;2683:55;2658:20;2683:55;:::i;:::-;11048:85;-1:-1;11170:2;11209:22;;7239:20;;-1:-1;11278:2;11317:22;;7239:20;;-1:-1;11386:3;11426:22;;7239:20;;-1:-1;11495:3;11535:22;;7239:20;;-1:-1;11632:3;11617:19;;11604:33;11657:18;11646:30;;11643:2;;;-1:-1;;11679:12;11643:2;11717:64;11773:7;11764:6;11753:9;11749:22;11717:64;:::i;:::-;11699:82;;-1:-1;11699:82;-1:-1;;11495:3;3260:16;;;3256:26;3253:2;;;-1:-1;;3285:12;3253:2;;11818:3;11897:9;11893:22;11827:98;;10821:1120;;;;;;;;;;;:::o;11948:1083::-;;;;;;;12201:3;12189:9;12180:7;12176:23;12172:33;12169:2;;;-1:-1;;12208:12;12169:2;2671:6;2658:20;2683:55;2732:5;2683:55;:::i;:::-;12260:85;-1:-1;12382:2;12421:22;;7239:20;;-1:-1;12490:2;12529:22;;7239:20;;-1:-1;12598:2;12637:22;;7239:20;;-1:-1;12734:3;12719:19;;12706:33;12759:18;12748:30;;12745:2;;;-1:-1;;12781:12;12745:2;12841: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::-;1932:6;1925:5;1918:21;2036:3;12382:2;2027:6;1960;2018:16;;2015:25;2012:2;;;-1:-1;;2043:12;2012:2;44387:6;12382:2;1960:6;1956:17;12382:2;1994:5;1990:16;44364:30;44425:16;;;12382:2;44425:16;44418:27;;;;-1:-1;12929:86;13007:7;12910:3;12983:22;;12929:86;:::i;:::-;12919:96;;12163:868;;;;;;;;:::o;13314:308::-;;13451:3;13439:9;13430:7;13426:23;13422:33;13419:2;;;-1:-1;;13458:12;13419:2;13520:86;13598:7;13574:22;13520:86;:::i;13629:320::-;;13772:3;;13760:9;13751:7;13747:23;13743:33;13740:2;;;-1:-1;;13779:12;13740:2;4907:22;13772:3;4907:22;:::i;:::-;4898:31;;5020:100;5116:3;5092:22;5020:100;:::i;:::-;5002:16;4995:126;5225:60;5281:3;5192:2;5261:9;5257:22;5225:60;:::i;:::-;5192:2;5211:5;5207:16;5200:86;5395:60;5451:3;5362:2;5431:9;5427:22;5395:60;:::i;:::-;5362:2;5381:5;5377:16;5370:86;5566:60;5622:3;5533:2;5602:9;5598:22;5566:60;:::i;:::-;5533:2;5552:5;5548:16;5541:86;5743:60;5799:3;5709;5779:9;5775:22;5743:60;:::i;:::-;5709:3;5729:5;5725:16;5718:86;5918:60;5974:3;5884;5954:9;5950:22;5918:60;:::i;:::-;5884:3;5904:5;5900:16;5893:86;6089:59;6144:3;6055;6124:9;6120:22;6089:59;:::i;:::-;6055:3;6075:5;6071:16;6064:85;6253:60;6309:3;6219;6289:9;6285:22;6253:60;:::i;:::-;6219:3;6239:5;6235:16;6228:86;6393:3;6429:60;6485:3;6393;6465:9;6461:22;6429:60;:::i;:::-;6409:18;;;6402:88;6571:3;6607:60;6663:3;6639:22;;;6607:60;:::i;:::-;6587:18;;;6580:88;6752:3;6788:60;6844:3;6820:22;;;6788:60;:::i;:::-;6768:18;;;6761:88;6908:3;6944:58;6998:3;6974:22;;;6944:58;:::i;:::-;6924:18;;;6917:86;6928:5;13734:215;-1:-1;;;13734:215::o;13956:263::-;;14071:2;14059:9;14050:7;14046:23;14042:32;14039:2;;;-1:-1;;14077:12;14039:2;-1:-1;7387:13;;14033:186;-1:-1;14033:186::o;14226:259::-;;14339:2;14327:9;14318:7;14314:23;14310:32;14307:2;;;-1:-1;;14345:12;14307:2;7804:6;7798:13;7816:31;7841:5;7816:31;:::i;24225:271::-;;15152:5;40756:12;15263:52;15308:6;15303:3;15296:4;15289:5;15285:16;15263:52;:::i;:::-;15327:16;;;;;24359:137;-1:-1;;24359:137::o;24503:222::-;42160:42;42149:54;;;;14712:37;;24630:2;24615:18;;24601:124::o;24732:333::-;42160:42;42149:54;;;14712:37;;42149:54;;25051:2;25036:18;;14712:37;24887:2;24872:18;;24858:207::o;25072:444::-;42160:42;42149:54;;;14712:37;;42149:54;;;;25419:2;25404:18;;14712:37;25502:2;25487:18;;14943:37;;;;25255:2;25240:18;;25226:290::o;25523:884::-;42160:42;42149:54;;;14712:37;;42149:54;;;;25979:2;25964:18;;14712:37;26062:2;26047:18;;14943:37;;;;26145:2;26130:18;;14943:37;;;;42462:4;42451:16;26224:3;26209:19;;24178:35;26308:3;26293:19;;14943:37;26392:3;26377:19;;14943:37;;;;25814:3;25799:19;;25785:622::o;26414:333::-;42160:42;42149:54;;;;14712:37;;26733:2;26718:18;;14943:37;26569:2;26554:18;;26540:207::o;26754:444::-;42160:42;42149:54;;;14712:37;;27101:2;27086:18;;14943:37;;;;42149:54;;;27184:2;27169:18;;14712:37;26937:2;26922:18;;26908:290::o;27205:586::-;42160:42;42149:54;;;14712:37;;27596:2;27581:18;;14943:37;;;;42149:54;;27687:2;27672:18;;14571:58;42068:6;42057:18;;;27777:2;27762:18;;16201:57;27431:3;27416:19;;27402:389::o;27798:556::-;42160:42;42149:54;;;14712:37;;28174:2;28159:18;;14943:37;;;;28257:2;28242:18;;14943:37;;;;42149:54;;;28340:2;28325:18;;14712:37;28009:3;27994:19;;27980:374::o;28940:210::-;41415:13;;41408:21;14826:34;;29061:2;29046:18;;29032:118::o;30309:310::-;;30456:2;30477:17;30470:47;16415:5;40756:12;41195:6;30456:2;30445:9;30441:18;41183:19;16509:52;16554:6;41223:14;30445:9;41223:14;30456:2;16535:5;16531:16;16509:52;:::i;:::-;44824:2;44804:14;44820:7;44800:28;16573:39;;;;41223:14;16573:39;;30427:192;-1:-1;;30427:192::o;30626:416::-;30826:2;30840:47;;;16849:2;30811:18;;;41183:19;16885:30;41223:14;;;16865:51;16935:12;;;30797:245::o;31049:416::-;31249:2;31263:47;;;17186:2;31234:18;;;41183:19;17222:29;41223:14;;;17202:50;17271:12;;;31220:245::o;31472:416::-;31672:2;31686:47;;;17522:2;31657:18;;;41183:19;17558:34;41223:14;;;17538:55;17627:8;17613:12;;;17606:30;17655:12;;;31643:245::o;31895:416::-;32095:2;32109:47;;;17906:2;32080:18;;;41183:19;17942:29;41223:14;;;17922:50;17991:12;;;32066:245::o;32318:416::-;32518:2;32532:47;;;18242:2;32503:18;;;41183:19;18278:34;41223:14;;;18258:55;18347:9;18333:12;;;18326:31;18376:12;;;32489:245::o;32741:416::-;32941:2;32955:47;;;18627:2;32926:18;;;41183:19;18663:18;41223:14;;;18643:39;18701:12;;;32912:245::o;33164:416::-;33364:2;33378:47;;;33349:18;;;41183:19;18988:34;41223:14;;;18968:55;19042:12;;;33335:245::o;33587:416::-;33787:2;33801:47;;;19293:2;33772:18;;;41183:19;19329:31;41223:14;;;19309:52;19380:12;;;33758:245::o;34010:416::-;34210:2;34224:47;;;34195:18;;;41183:19;19667:34;41223:14;;;19647:55;19721:12;;;34181:245::o;34433:416::-;34633:2;34647:47;;;19972:2;34618:18;;;41183:19;20008:34;41223:14;;;19988:55;20077:5;20063:12;;;20056:27;20102:12;;;34604:245::o;34856:416::-;35056:2;35070:47;;;20353:2;35041:18;;;41183:19;20389:30;41223:14;;;20369:51;20439:12;;;35027:245::o;35279:416::-;35479:2;35493:47;;;20690:2;35464:18;;;41183:19;20726:29;41223:14;;;20706:50;20775:12;;;35450:245::o;35702:416::-;35902:2;35916:47;;;21026:2;35887:18;;;41183:19;21062:34;41223:14;;;21042:55;21131:3;21117:12;;;21110:25;21154:12;;;35873:245::o;36125:416::-;36325:2;36339:47;;;36310:18;;;41183:19;21441:34;41223:14;;;21421:55;21495:12;;;36296:245::o;36548:416::-;36748:2;36762:47;;;21746:2;36733:18;;;41183:19;21782:26;41223:14;;;21762:47;21828:12;;;36719:245::o;36971:416::-;37171:2;37185:47;;;22079:2;37156:18;;;41183:19;22115:27;41223:14;;;22095:48;22162:12;;;37142:245::o;37394:416::-;37594:2;37608:47;;;22413:2;37579:18;;;41183:19;22449:34;41223:14;;;22429:55;22518:12;22504;;;22497:34;22550:12;;;37565:245::o;37817:416::-;38017:2;38031:47;;;22801:2;38002:18;;;41183:19;22837:33;41223:14;;;22817:54;22890:12;;;37988:245::o;38240:416::-;38440:2;38454:47;;;23141:2;38425:18;;;41183:19;23177:34;41223:14;;;23157:55;23246:24;23232:12;;;23225:46;23290:12;;;38411:245::o;38663:416::-;38863:2;38877:47;;;23541:2;38848:18;;;41183:19;23577:33;41223:14;;;23557:54;23630:12;;;38834:245::o;39086:416::-;39286:2;39300:47;;;23881:2;39271:18;;;41183:19;23917:28;41223:14;;;23897:49;23965:12;;;39257:245::o;39509:222::-;14943:37;;;39636:2;39621:18;;39607:124::o;39738:333::-;14943:37;;;40057:2;40042:18;;14943:37;39893:2;39878:18;;39864:207::o;40078:256::-;40140:2;40134:9;40166:17;;;40241:18;40226:34;;40262:22;;;40223:62;40220:2;;;40298:1;;40288:12;40220:2;40140;40307:22;40118:216;;-1:-1;40118:216::o;40341:321::-;;40484:18;40476:6;40473:30;40470:2;;;-1:-1;;40506:12;40470:2;-1:-1;40583:4;40560:17;40579:9;40556:33;40647:4;40637:15;;40407:255::o;44460:268::-;44525:1;44532:101;44546:6;44543:1;44540:13;44532:101;;;44613:11;;;44607:18;44594:11;;;44587:39;44568:2;44561:10;44532:101;;;44648:6;44645:1;44642:13;44639:2;;;-1:-1;;44525:1;44695:16;;44688:27;44509:219::o;44841:117::-;42160:42;44928:5;42149:54;44903:5;44900:35;44890:2;;44949:1;;44939:12;46073:113;42462:4;46156:5;42451:16;46133:5;46130:33;46120:2;;46177:1;;46167:12

ipfs://c9b32be27eb8e6f39b822c03422d06cde93a6ef03746732d7a648b2f0feab406