Contract 0x9093F303C897717edaD0445C26BD0B33Fe45fD11 2

/**
 *Submitted for verification at polygonscan.com on 2021-06-25
*/

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

// File @openzeppelin/contracts/utils/[email protected]



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 @openzeppelin/contracts/utils/[email protected]



pragma solidity >=0.6.2 <0.8.0;

/**
 * @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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @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");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/math/[email protected]



pragma solidity >=0.6.0 <0.8.0;

/**
 * @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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * 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);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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 @openzeppelin/contracts/token/ERC20/[email protected]



pragma solidity >=0.6.0 <0.8.0;

/**
 * @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 @openzeppelin/contracts/token/ERC20/[email protected]



pragma solidity >=0.6.0 <0.8.0;



/**
 * @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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        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 safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "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/interface/IUniswapV2Router01.sol

pragma solidity >=0.6.0 <0.8.0;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}


// File contracts/interface/IUniswapV2Pair.sol

pragma solidity >=0.6.0 <0.8.0;

interface IUniswapV2Pair {
    function token0() external pure returns (address);

    function token1() external pure returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 _reserve0,
            uint112 _reserve1,
            uint32 _blockTimestampLast
        );
}


// File contracts/interface/IUniswapFactory.sol

pragma solidity >=0.6.0 <0.8.0;


interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}


// File contracts/interface/IWETH.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.6.0 <0.8.0;

interface IWETH {
    function deposit() external payable;
    function transfer(address to, uint value) external returns (bool);
    function withdraw(uint) external;
}


// File contracts/OneSidedFarm.sol

pragma solidity ^0.7.3;








interface IHybridStaking{
    function depositFor(uint256 _pid, uint256 _amount, address _user) external;
}

contract OneSidedFarm is ReentrancyGuard {
    using SafeMath for uint256;
    using Address for address;
    using SafeERC20 for IERC20;

    IUniswapV2Factory public immutable factory;

    IUniswapV2Router01 public immutable router;

    address public immutable wmatic;

    IHybridStaking public immutable hybridStaking;

    uint256 private constant DEADLINE =
        0xf000000000000000000000000000000000000000000000000000000000000000;

    constructor(IUniswapV2Router01 _router, IHybridStaking _hybridStaking) {
        router = _router;
        factory = IUniswapV2Factory(_router.factory());
        wmatic = _router.WETH();
        hybridStaking = _hybridStaking;
    }

    receive() external payable {}

    event SwapedTokens(
        address sender,
        uint256 amount,
        address fromToken,
        address toToken
    );

    event PooledLiquidity(
        address sender,
        address pool,
        address tokenA,
        uint256 amountA,
        address tokenB,
        uint256 amountB
    );

    /**
    @notice This function is used to invest in given Uniswap V2 pair through either of the tokens
    @param _fromToken The ERC20 token used for investment (address(0x00) if matic)
    @param _pid PoolID of Hybrid Staking Contract
    @param _pairAddress The Uniswap pair address
    @param _fromTokenAmount The amount of fromToken to invest
    @return Amount of LP bought
     */
    function poolLiquidity(
        address _fromToken,
        uint256 _pid,
        address _pairAddress,
        uint256 _fromTokenAmount
    ) public payable nonReentrant returns (uint256) {
        address user = msg.sender; 
        bool isMaticDeposit;
        uint256 toInvest = _pullTokens(_fromToken, _fromTokenAmount);
        if(_fromToken == address(0)) {
            isMaticDeposit = true;
            _fromToken = wmatic;
        } 

        uint256 lpBought =
            _poolLiquidity(
                _fromToken,
                _pairAddress,
                toInvest,
                isMaticDeposit
            );

        IERC20(_pairAddress).safeApprove(address(hybridStaking), lpBought);
        hybridStaking.depositFor(_pid, lpBought, user);

        return lpBought;
    }

    function _getPairTokens(address _pairAddress)
        internal
        pure
        returns (address token0, address token1)
    {
        IUniswapV2Pair uniPair = IUniswapV2Pair(_pairAddress);
        token0 = uniPair.token0();
        token1 = uniPair.token1();
    }

    function _pullTokens(address token, uint256 amount)
        internal
        returns (uint256 value)
    {
        if (token == address(0)) {
            require(msg.value > 0, "No Matic sent");
            IWETH(wmatic).deposit{value: msg.value}();
            return msg.value;
        }
        require(amount > 0, "Invalid token amount");
        require(msg.value == 0, "Matic sent with token");

        //transfer token
        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);

        return amount;
    }

    function _poolLiquidity(
        address _fromToken,
        address _pairAddress,
        uint256 _amount,
        bool _isMaticDeposit
    ) internal returns (uint256) {
        (address _token0, address _token1) = _getPairTokens(_pairAddress);

        // divide intermediate into appropriate amount to add liquidity
        (uint256 token0Bought, uint256 token1Bought) =
            _swapTokens(
                _fromToken,
                _token0,
                _token1,
                _amount
            );

        (uint256 lpAmount, uint256 amountA, uint256 amountB) =
            _poolDeposit(
                _token0,
                _token1,
                token0Bought,
                token1Bought,
                _isMaticDeposit
            );

        emit PooledLiquidity(
            msg.sender,
            _pairAddress,
            _token0,
            amountA,
            _token1,
            amountB
        );

        return lpAmount;
    }

    function _poolDeposit(
        address _toToken0,
        address _toToken1,
        uint256 token0Bought,
        uint256 token1Bought,
        bool _isMaticDeposit
    )
        internal
        returns (
            uint256,
            uint256,
            uint256
        )
    {   
        IERC20(_toToken0).safeApprove(address(router), 0);
        IERC20(_toToken1).safeApprove(address(router), 0);

        IERC20(_toToken0).safeApprove(
            address(router),
            token0Bought
        );
        IERC20(_toToken1).safeApprove(
            address(router),
            token1Bought
        );

        (uint256 amountA, uint256 amountB, uint256 lp) =
            router.addLiquidity(
                _toToken0,
                _toToken1,
                token0Bought,
                token1Bought,
                1,
                1,
                address(this),
                DEADLINE
            );

        uint256 token0Residue = token0Bought.sub(amountA);

        uint256 token1Residue = token1Bought.sub(amountB);

        //Returning Residue in token0, if any.
        if (token0Residue > 0) {
            if(_isMaticDeposit) {
                IWETH(wmatic).withdraw(token0Residue);
                safeTransferETH(msg.sender, token0Residue);
            } 
            else{ 
                IERC20(_toToken0).safeTransfer(msg.sender, token0Residue);
            }
        }

        //Returning Residue in token1, if any
        if (token1Residue > 0) {
            if(_isMaticDeposit) {
                IWETH(wmatic).withdraw(token1Residue);
                safeTransferETH(msg.sender, token1Residue);
            } 
            else{ 
                IERC20(_toToken1).safeTransfer(msg.sender, token1Residue);
            }
        }

        return (lp, amountA, amountB);
    }

    function _swapTokens(
        address _fromToken,
        address _toToken0,
        address _toToken1,
        uint256 _amount
    ) internal returns (uint256 token0Bought, uint256 token1Bought) {
        IUniswapV2Pair pair =
            IUniswapV2Pair(
                factory.getPair(
                    _toToken0,
                    _toToken1
                )
            );
        (uint256 res0, uint256 res1, ) = pair.getReserves();
        if (_fromToken == _toToken0) {
            uint256 amountToSwap = getSwapAmt(res0, _amount);
            //if no reserve or a new pair is created
            if (amountToSwap <= 0) amountToSwap = _amount.div(2);
            token1Bought = _swapTokensInternal(
                _fromToken,
                _toToken1,
                amountToSwap
            );
            token0Bought = _amount.sub(amountToSwap);
        } else {
            uint256 amountToSwap = getSwapAmt(res1, _amount);
            //if no reserve or a new pair is created
            if (amountToSwap <= 0) amountToSwap = _amount.div(2);
            token0Bought = _swapTokensInternal(
                _fromToken,
                _toToken0,
                amountToSwap
            );
            token1Bought = _amount.sub(amountToSwap);
        }
    }

    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }

    function getSwapAmt(uint256 reserveIn, uint256 userIn)
        internal
        pure
        returns (uint256)
    {   
        return sqrt(reserveIn.mul(userIn.mul(3988000).add(reserveIn.mul(3988009))))
                    .sub(reserveIn.mul(1997)) / 1994;
    }

    /**
    @notice This function is used to swap ERC20 <> ERC20
    @param _fromToken The token address to swap from.
    @param _toTokenContractAddress The token address to swap to. 
    @param tokens2Trade The amount of tokens to swap
    @return tokenBought The quantity of tokens bought
    */
    function _swapTokensInternal(
        address _fromToken,
        address _toTokenContractAddress,
        uint256 tokens2Trade
    ) internal returns (uint256 tokenBought) {
        if (_fromToken == _toTokenContractAddress) {
            return tokens2Trade;
        }
        IERC20(_fromToken).safeApprove(
            address(router),
            0
        );
        IERC20(_fromToken).safeApprove(
            address(router),
            tokens2Trade
        );

        address[] memory path = new address[](2);
        path[0] = _fromToken;
        path[1] = _toTokenContractAddress;

        tokenBought = router.swapExactTokensForTokens(
            tokens2Trade,
            1,
            path,
            address(this),
            DEADLINE
        )[path.length - 1];

        require(tokenBought > 0, "Error Swapping Tokens 2");

        emit SwapedTokens(
            msg.sender,
            tokens2Trade,
            _fromToken,
            _toTokenContractAddress
        );
    }

    function getEstimatedLPTokens(	
        uint256 _amountIn,		
        address _fromToken,		
        address _pairAddress		
    ) public view returns (uint256 estimatedLps) {		
        (uint256 res0, uint256 res1, ) = IUniswapV2Pair(_pairAddress).getReserves();		
        (address _token0, address _token1) = _getPairTokens(_pairAddress);
        if (_fromToken == _token0) {		
            uint256 amountToSwap = getSwapAmt(res0, _amountIn);		
            estimatedLps = _amountIn		
                .sub(amountToSwap)		
                .mul(IERC20(_pairAddress).totalSupply())		
                .div(res0);		
        } else if (_fromToken == _token1) {		
            uint256 amountToSwap = getSwapAmt(res1, _amountIn);		
            estimatedLps = _amountIn		
                .sub(amountToSwap)		
                .mul(IERC20(_pairAddress).totalSupply())		
                .div(res1);		
        }		
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, "TransferHelper: ETH_TRANSFER_FAILED");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IUniswapV2Router01","name":"_router","type":"address"},{"internalType":"contract IHybridStaking","name":"_hybridStaking","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"pool","type":"address"},{"indexed":false,"internalType":"address","name":"tokenA","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountA","type":"uint256"},{"indexed":false,"internalType":"address","name":"tokenB","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountB","type":"uint256"}],"name":"PooledLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"fromToken","type":"address"},{"indexed":false,"internalType":"address","name":"toToken","type":"address"}],"name":"SwapedTokens","type":"event"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"address","name":"_fromToken","type":"address"},{"internalType":"address","name":"_pairAddress","type":"address"}],"name":"getEstimatedLPTokens","outputs":[{"internalType":"uint256","name":"estimatedLps","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hybridStaking","outputs":[{"internalType":"contract IHybridStaking","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_fromToken","type":"address"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_pairAddress","type":"address"},{"internalType":"uint256","name":"_fromTokenAmount","type":"uint256"}],"name":"poolLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router01","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wmatic","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000a102072a4c07f06ec3b4900fdc4c7b80b6c57429000000000000000000000000dc5a8f4d53e6ffb1f5e356f64577702af9348d7d

-----Decoded View---------------
Arg [0] : _router (address): 0xa102072a4c07f06ec3b4900fdc4c7b80b6c57429
Arg [1] : _hybridStaking (address): 0xdc5a8f4d53e6ffb1f5e356f64577702af9348d7d

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000a102072a4c07f06ec3b4900fdc4c7b80b6c57429
Arg [1] : 000000000000000000000000dc5a8f4d53e6ffb1f5e356f64577702af9348d7d

30201:10443:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30491:45;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;30491:45:0;;;;;;;;;;;;;;31671:820;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;31671:820:0;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;39517:921;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39517:921:0;;;-1:-1:-1;;;;;39517:921:0;;;;;;;;;;;;:::i;30349:42::-;;;;;;;;;;;;;:::i;30400:::-;;;;;;;;;;;;;:::i;30451:31::-;;;;;;;;;;;;;:::i;30491:45::-;;;:::o;31671:820::-;31856:7;1822:1;2428:7;;:19;;2420:63;;;;;-1:-1:-1;;;2420:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1822:1;2561:7;:18;;;31891:10:::1;::::0;2561:7;31962:41:::1;31974:10:::0;31986:16;31962:11:::1;:41::i;:::-;31943:60:::0;-1:-1:-1;;;;;;32017:24:0;::::1;32014:111;;32075:4;32058:21;;32107:6;32094:19;;32014:111;32138:16;32170:149;32203:10;32232:12;32263:8;32290:14;32170;:149::i;:::-;32138:181:::0;-1:-1:-1;32332:66:0::1;-1:-1:-1::0;;;;;32332:32:0;::::1;32373:13;32138:181:::0;32332:32:::1;:66::i;:::-;32409:13;-1:-1:-1::0;;;;;32409:24:0::1;;32434:4;32440:8;32450:4;32409:46;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;32409:46:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;1778:1:0;2740:7;:22;-1:-1:-1;32475:8:0;;31671:820;-1:-1:-1;;;;;;;;;31671:820:0:o;39517:921::-;39670:20;39706:12;39720;39753;-1:-1:-1;;;;;39738:40:0;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39738:42:0;;;;;;;-1:-1:-1;;;;;39705:75:0;;;;-1:-1:-1;39705:75:0;;-1:-1:-1;39794:15:0;;39830:28;39845:12;39830:14;:28::i;:::-;39793:65;;;;39887:7;-1:-1:-1;;;;;39873:21:0;:10;-1:-1:-1;;;;;39873:21:0;;39869:560;;;39913:20;39936:27;39947:4;39953:9;39936:10;:27::i;:::-;39913:50;;39995:137;40127:4;39995:107;40074:12;-1:-1:-1;;;;;40067:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40067:34:0;39995:47;:9;40029:12;39995:33;:47::i;:::-;:71;;:107::i;:::-;:131;;:137::i;:::-;39980:152;;39869:560;;;;40170:7;-1:-1:-1;;;;;40156:21:0;:10;-1:-1:-1;;;;;40156:21:0;;40152:277;;;40196:20;40219:27;40230:4;40236:9;40219:10;:27::i;:::-;40196:50;;40278:137;40410:4;40278:107;40357:12;-1:-1:-1;;;;;40350:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40278:137;40263:152;;40152:277;;39517:921;;;;;;;;;:::o;30349:42::-;;;:::o;30400:::-;;;:::o;30451:31::-;;;:::o;32784:547::-;32872:13;-1:-1:-1;;;;;32907:19:0;;32903:178;;32963:1;32951:9;:13;32943:39;;;;;-1:-1:-1;;;32943:39:0;;;;;;;;;;;;-1:-1:-1;;;32943:39:0;;;;;;;;;;;;;;;33003:6;-1:-1:-1;;;;;32997:21:0;;33026:9;32997:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33060:9;33053:16;;;;32903:178;33108:1;33099:6;:10;33091:43;;;;;-1:-1:-1;;;33091:43:0;;;;;;;;;;;;-1:-1:-1;;;33091:43:0;;;;;;;;;;;;;;;33153:9;:14;33145:48;;;;;-1:-1:-1;;;33145:48:0;;;;;;;;;;;;-1:-1:-1;;;33145:48:0;;;;;;;;;;;;;;;33232:65;-1:-1:-1;;;;;33232:30:0;;33263:10;33283:4;33290:6;33232:30;:65::i;:::-;-1:-1:-1;33317:6:0;32784:547;;;;;:::o;33339:1006::-;33505:7;33526:15;33543;33562:28;33577:12;33562:14;:28::i;:::-;33525:65;;;;33677:20;33699;33736:133;33766:10;33795:7;33821;33847;33736:11;:133::i;:::-;33676:193;;;;33883:16;33901:15;33918;33950:175;33981:7;34007;34033:12;34064;34095:15;33950:12;:175::i;:::-;33882:243;;;;;;34143:166;34173:10;34198:12;34225:7;34247;34269;34291;34143:166;;;;-1:-1:-1;;;;;34143:166:0;;;;;;-1:-1:-1;;;;;34143:166:0;;;;;;-1:-1:-1;;;;;34143:166:0;;;;;;;;;;;-1:-1:-1;;;;;34143:166:0;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34329:8:0;;33339:1006;-1:-1:-1;;;;;;;;;;33339:1006:0:o;22440:622::-;22810:10;;;22809:62;;-1:-1:-1;22826:39:0;;;-1:-1:-1;;;22826:39:0;;22850:4;22826:39;;;;-1:-1:-1;;;;;22826:39:0;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22826:39:0;:44;22809:62;22801:152;;;;-1:-1:-1;;;22801:152:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22991:62;;;-1:-1:-1;;;;;22991:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22991:62:0;-1:-1:-1;;;22991:62:0;;;22964:90;;22984:5;;22964:19;:90::i;:::-;22440:622;;;:::o;32499:277::-;32595:14;32611;32643:22;32683:12;32643:53;;32716:7;-1:-1:-1;;;;;32716:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32716:16:0;32752;;;-1:-1:-1;;;32752:16:0;;;;32716;;-1:-1:-1;;;;;;32752:14:0;;;;;:16;;;;;32716;;32752;;;;;;;;:14;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32752:16:0;32499:277;;32752:16;;-1:-1:-1;;;32499:277:0:o;37887:270::-;37992:7;38145:4;38027:115;38122:19;:9;38136:4;38122:13;:19::i;:::-;38027:68;38032:62;38046:47;38070:22;:9;38084:7;38070:13;:22::i;:::-;38046:19;:6;38057:7;38046:10;:19::i;:::-;:23;;:47::i;:::-;38032:9;;:13;:62::i;:::-;38027:4;:68::i;:::-;:94;;:115::i;:::-;:122;;;;;;;37887:270;-1:-1:-1;;;37887:270:0:o;14085:158::-;14143:7;14176:1;14171;:6;;14163:49;;;;;-1:-1:-1;;;14163:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14230:5:0;;;14085:158::o;14502:220::-;14560:7;14584:6;14580:20;;-1:-1:-1;14599:1:0;14592:8;;14580:20;14623:5;;;14627:1;14623;:5;:1;14647:5;;;;;:10;14639:56;;;;-1:-1:-1;;;14639:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14713:1;14502:220;-1:-1:-1;;;14502:220:0:o;15200:153::-;15258:7;15290:1;15286;:5;15278:44;;;;;-1:-1:-1;;;15278:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15344:1;15340;:5;;;;21966:205;22094:68;;;-1:-1:-1;;;;;22094:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22094:68:0;-1:-1:-1;;;22094:68:0;;;22067:96;;22087:5;;22067:19;:96::i;:::-;21966:205;;;;:::o;36245:1314::-;36402:20;36424;36457:19;36525:7;-1:-1:-1;;;;;36525:15:0;;36563:9;36595;36525:98;;;;;;;;;;;;;-1:-1:-1;;;;;36525:98:0;;;;;;-1:-1:-1;;;;;36525:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36525:98:0;36682:18;;;-1:-1:-1;;;36682:18:0;;;;36525:98;;-1:-1:-1;36650:12:0;;;;-1:-1:-1;;;;;36682:16:0;;;;;:18;;;;;;;;;;;;;;;:16;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36682:18:0;;;;;;;-1:-1:-1;;;;;36649:51:0;;;;-1:-1:-1;36649:51:0;;-1:-1:-1;;;;;;36715:23:0;;;;;;;36711:841;;;36755:20;36778:25;36789:4;36795:7;36778:10;:25::i;:::-;36755:48;;36892:1;36876:12;:17;36872:52;;36910:14;:7;36922:1;36910:11;:14::i;:::-;36895:29;;36872:52;36954:122;36992:10;37021:9;37049:12;36954:19;:122::i;:::-;36939:137;-1:-1:-1;37106:25:0;:7;37118:12;37106:11;:25::i;:::-;37091:40;;36711:841;;;;37164:20;37187:25;37198:4;37204:7;37187:10;:25::i;:::-;37164:48;;37301:1;37285:12;:17;37281:52;;37319:14;:7;37331:1;37319:11;:14::i;:::-;37304:29;;37281:52;37363:122;37401:10;37430:9;37458:12;37363:19;:122::i;:::-;37348:137;-1:-1:-1;37515:25:0;:7;37527:12;37515:11;:25::i;:::-;37500:40;;36711:841;;36245:1314;;;;;;;;;;:::o;34353:1884::-;34581:7;;;34663:49;-1:-1:-1;;;;;34663:29:0;;34701:6;34581:7;34663:29;:49::i;:::-;34723;-1:-1:-1;;;;;34723:29:0;;34761:6;34770:1;34723:29;:49::i;:::-;34785:97;-1:-1:-1;;;;;34785:29:0;;34837:6;34859:12;34785:29;:97::i;:::-;34893;-1:-1:-1;;;;;34893:29:0;;34945:6;34967:12;34893:29;:97::i;:::-;35065:251;;;-1:-1:-1;;;35065:251:0;;-1:-1:-1;;;;;35065:251:0;;;;;;;;;;;;;;;;;;;;;;;;;;35221:1;35065:251;;;;;;;;;;35269:4;35065:251;;;;-1:-1:-1;;;35065:251:0;;;;;;-1:-1:-1;;;;;;35065:6:0;:19;;;;;;:251;;;;;;;;;;;;;;;-1:-1:-1;35065:19:0;:251;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35065:251:0;;;;;;;;;;;;;-1:-1:-1;35065:251:0;;-1:-1:-1;35065:251:0;-1:-1:-1;35329:21:0;35353:25;:12;35065:251;35353:16;:25::i;:::-;35329:49;-1:-1:-1;35391:21:0;35415:25;:12;35432:7;35415:16;:25::i;:::-;35391:49;-1:-1:-1;35505:17:0;;35501:314;;35542:15;35539:265;;;35584:6;-1:-1:-1;;;;;35578:22:0;;35601:13;35578:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35634:42;35650:10;35662:13;35634:15;:42::i;:::-;35539:265;;;35731:57;-1:-1:-1;;;;;35731:30:0;;35762:10;35774:13;35731:30;:57::i;:::-;35878:17;;35874:314;;35915:15;35912:265;;;35957:6;-1:-1:-1;;;;;35951:22:0;;35974:13;35951:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36007:42;36023:10;36035:13;36007:15;:42::i;:::-;35912:265;;;36104:57;-1:-1:-1;;;;;36104:30:0;;36135:10;36147:13;36104:30;:57::i;:::-;-1:-1:-1;36208:2:0;;36212:7;;-1:-1:-1;36221:7:0;;-1:-1:-1;34353:1884:0;;-1:-1:-1;;;;;;;34353:1884:0:o;24086:761::-;24510:23;24536:69;24564:4;24536:69;;;;;;;;;;;;;;;;;24544:5;-1:-1:-1;;;;;24536:27:0;;;:69;;;;;:::i;:::-;24620:17;;24510:95;;-1:-1:-1;24620:21:0;24616:224;;24762:10;24751:30;;;;;;;;;;;;;;;-1:-1:-1;24751:30:0;24743:85;;;;-1:-1:-1;;;24743:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13623:179;13681:7;13713:5;;;13737:6;;;;13729:46;;;;;-1:-1:-1;;;13729:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;37567:312;37615:9;37645:1;37641;:5;37637:235;;;-1:-1:-1;37667:1:0;37703;37699;37695:5;;:9;37719:92;37730:1;37726;:5;37719:92;;;37756:1;37752:5;;37794:1;37789;37785;37781;:5;;;;;;:9;37780:15;;;;;;37776:19;;37719:92;;;37637:235;;;;37832:6;;37828:44;;-1:-1:-1;37859:1:0;37828:44;37567:312;;;:::o;38471:1038::-;38627:19;38677:23;-1:-1:-1;;;;;38663:37:0;:10;-1:-1:-1;;;;;38663:37:0;;38659:89;;;-1:-1:-1;38724:12:0;38717:19;;38659:89;38758:87;-1:-1:-1;;;;;38758:30:0;;38811:6;38833:1;38758:30;:87::i;:::-;38856:98;-1:-1:-1;;;;;38856:30:0;;38909:6;38931:12;38856:30;:98::i;:::-;38991:16;;;39005:1;38991:16;;;38967:21;38991:16;;;;;38967:21;38991:16;;;;;;;;;;-1:-1:-1;38991:16:0;38967:40;;39028:10;39018:4;39023:1;39018:7;;;;;;;;;;;;;:20;-1:-1:-1;;;;;39018:20:0;;;-1:-1:-1;;;;;39018:20:0;;;;;39059:23;39049:4;39054:1;39049:7;;;;;;;;;;;;;:33;-1:-1:-1;;;;;39049:33:0;;;-1:-1:-1;;;;;39049:33:0;;;;;39109:6;-1:-1:-1;;;;;39109:31:0;;39155:12;39182:1;39198:4;39225;-1:-1:-1;;;39109:155:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;39109:155:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;39109:155:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39109:155:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39279:1;39265:4;:11;:15;39109:172;;;;;;;;;;;;;;39095:186;;39316:1;39302:11;:15;39294:51;;;;;-1:-1:-1;;;39294:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;39363:138;;;39390:10;39363:138;;;;;;;;-1:-1:-1;;;;;39363:138:0;;;;;;;;;;;;;;;;;;;;;;;;38471:1038;;;;;;:::o;40446:195::-;40554:12;;;40516;40554;;;;;;;;;-1:-1:-1;;;;;40533:7:0;;;40547:5;;40533:34;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40533:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40515:52;;;40586:7;40578:55;;;;-1:-1:-1;;;40578:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21781:177;21891:58;;;-1:-1:-1;;;;;21891:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21891:58:0;-1:-1:-1;;;21891:58:0;;;21864:86;;21884:5;;21864:19;:86::i;6477:195::-;6580:12;6612:52;6634:6;6642:4;6648:1;6651:12;6612:21;:52::i;:::-;6605:59;6477:195;-1:-1:-1;;;;6477:195:0:o;7529:530::-;7656:12;7714:5;7689:21;:30;;7681:81;;;;-1:-1:-1;;;7681:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7781:18;7792:6;7781:10;:18::i;:::-;7773:60;;;;;-1:-1:-1;;;7773:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7907:12;7921:23;7948:6;-1:-1:-1;;;;;7948:11:0;7968:5;7976:4;7948:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7948:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7906:75;;;;7999:52;8017:7;8026:10;8038:12;7999:17;:52::i;:::-;7992:59;7529:530;-1:-1:-1;;;;;;;7529:530:0:o;3559:422::-;3926:20;3965:8;;;3559:422::o;10069:742::-;10184:12;10213:7;10209:595;;;-1:-1:-1;10244:10:0;10237:17;;10209:595;10358:17;;:21;10354:439;;10621:10;10615:17;10682:15;10669:10;10665:2;10661:19;10654:44;10569:148;10764:12;10757:20;;-1:-1:-1;;;10757:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://895aae9b85d570b0a9d0cbccc4d2fdb306767ce50423e4d321907f48cc6ac449