Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

// P1 - P3: OK
pragma solidity 0.8.13;

import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/IUniswapV2Factory.sol";
import "./Swapper.sol";

// BrewBoo is MasterChef's left hand and kinda a wizard. He can brew Boo from pretty much anything!
// This contract handles "serving up" rewards for xBoo holders by trading tokens collected from fees for Boo.
// The caller of convertMultiple, the function responsible for converting fees to BOO earns a 0.1% reward for calling.
contract BrewBooV3 is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IUniswapV2Factory public immutable factory;
    ISwapper public immutable swapper;

    address public immutable xboo;
    address private immutable boo;
    address private immutable wftm;
    uint public devCut;  // in basis points aka parts per 10,000 so 5000 is 50%, cap of 50%, default is 0
    uint public BOUNTY_FEE = 10;
    address public devAddr;
    //uint public slippage = 9;

    // set of addresses that can perform certain functions
    mapping(address => bool) public isAuth;
    address[] public authorized;

    modifier onlyAuth() {
        require(isAuth[_msgSender()], "BrewBoo: FORBIDDEN");
        _;
    }

    // C6: It's not a fool proof solution, but it prevents flash loans, so here it's ok to use tx.origin
    modifier onlyEOA() {
        // Try to make flash-loan exploit harder to do by only allowing externally owned addresses.
        require(msg.sender == tx.origin, "BrewBoo: must use EOA");
        _;
    }

    mapping(address => uint) internal converted;
    mapping(address => bool) public overrode;
    mapping(address => bool) public swapperApproved;

    //token bridges to try in order when swapping, first three are immutably wftm, usdc, dai
    mapping(uint => address) public bridgeRoute;
    uint public bridgeRouteAmount = 3; // "array" size aka next free slot in the mapping
    mapping(address => address) public lastRoute; //tokens last succesful route, will be tried first

    mapping(address => mapping(address => address)) public pairOf;

    event SetDevAddr(address _addr);
    event SetDevCut(uint _amount);
    event LogBridgeSet(address indexed token, address indexed bridge);
    event LogConvert(
        address indexed server,
        address indexed token0,
        uint256 amount0,
        uint256 amountBOO
    );
    event LogToggleOverrode(address _adr);
    event LogSlippageOverrode(address _adr);

    constructor(
    ) {
        address _factory = 0xEE4bC42157cf65291Ba2FE839AE127e3Cc76f741;
        address _xboo = 0xa95eA1cfaBcCf0E9eb94b646CeFe9eD71ff5D605;
        address _boo = 0x7A0C53F7eb34C5BC8B01691723669adA9D6CB384;
        address _wftm = 0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38;
        address route1 = 0x29219dd400f2Bf60E5a23d13Be72B486D4038894;
        address route2 = 0x50c42dEAcD8Fc9773493ED674b675bE577f2634b;
        factory = IUniswapV2Factory(_factory);
        xboo = _xboo;
        boo = _boo;
        wftm = _wftm;
        devAddr = msg.sender;
        isAuth[msg.sender] = true;
        authorized.push(msg.sender);
        bridgeRoute[0] = _wftm;
        bridgeRoute[1] = route1;
        bridgeRoute[2] = route2;
        swapper = new Swapper();
    }

    function setBridgeRoute(uint index, address token) external onlyAuth {
        //require(index > 2, "first 3 bridge tokens are immutable");
        require(index <= bridgeRouteAmount, "index too large, use next free slot");

        bridgeRoute[index] = token;
        if(index == bridgeRouteAmount)
            bridgeRouteAmount += 1;
    }

    function setBridgeRouteAmount(uint amount) external onlyAuth {
        require(amount > 2);
        bridgeRouteAmount = amount;
    }

    function isLpToken(address _adr) internal returns (bool) {
        if (overrode[_adr]) return false;
        IUniswapV2Pair pair = IUniswapV2Pair(_adr);
        try pair.token0() returns (address token0) {
            address token1 = pair.token1();
            address realPair = _getPair(token0, token1);
            // check if newly derived pair is the same as the address passed in
            if (_adr != realPair) {
                overrode[_adr] = true;
                emit LogToggleOverrode(_adr);
                return false;
            }
            return true;
        } catch {
            overrode[_adr] = true;
            return false;
        }
    }

    // Begin Owner functions
    function addAuth(address _auth) external onlyOwner {
        isAuth[_auth] = true;
        authorized.push(_auth);
    }

    function revokeAuth(address _auth) external onlyOwner {
        isAuth[_auth] = false;
    }


    function setDevCut(uint _amount) external onlyOwner {
        require(_amount <= 5000, "setDevCut: cut too high");
        devCut = _amount;

        emit SetDevCut(_amount);
    }

    function setDevAddr(address _addr) external {
        require(owner() == _msgSender() || devAddr == _msgSender(), "not allowed");
        require(_addr != address(0), "setDevAddr, address cannot be zero address");
        devAddr = _addr;

        emit SetDevAddr(_addr);
    }

    function setBounty(uint _amt) external onlyOwner {
        BOUNTY_FEE = _amt;
    }
    // End owner functions

    // onlyAuth type functions

    function overrideSlippage(address _token) external onlyAuth {
        swapper.overrideSlippage(_token);
        emit LogSlippageOverrode(_token);
    }

    function setSlippage(uint _amt) external onlyAuth {
        swapper.setSlippage(_amt);
    }

    function setBridge(address token, address bridge) external onlyAuth {
        // Checks
        require(
            token != boo && token != wftm && token != bridge,
            "BrewBoo: Invalid bridge"
        );

        // Effects
        lastRoute[token] = bridge;
        emit LogBridgeSet(token, bridge);
    }

    function convertMultiple(
        address[] calldata token0,
        address[] calldata token1,
        uint[] calldata LPamounts
    ) external onlyEOA() nonReentrant() {
        uint i;
        IUniswapV2Pair pair;
        for (i = 0; i < token0.length;) {
            if (token0[i] == token1[i]) {
                require(!isLpToken(token0[i]), "no LP allowed");
                unchecked {++i;}
                continue;
            }
            require(!isLpToken(token0[i]) && !isLpToken(token1[i]), "no LP allowed");
            pair = IUniswapV2Pair(_getPair(token0[i], token1[i]));
            require(address(pair) != address(0), "BrewBoo: Invalid pair");

            IERC20(address(pair)).safeTransfer(address(pair), LPamounts.length == 0 ? pair.balanceOf(address(this)) : LPamounts[i]);
            pair.burn(address(this));
            unchecked {++i;}
        }

        converted[wftm] = block.number; // wftm is done last
        for (i = 0; i < token0.length;) {
            if(block.number > converted[token0[i]]) {
                _convertStep(token0[i], IERC20(token0[i]).balanceOf(address(this)));
                converted[token0[i]] = block.number;
            }
            if(block.number > converted[token1[i]]) {
                _convertStep(token1[i], IERC20(token1[i]).balanceOf(address(this)));
                converted[token1[i]] = block.number;
            }
            unchecked {++i;}
        }
        // final step is to swap all wFTM to BOO and disperse it
        i = IERC20(wftm).balanceOf(address(this)); //reuse i for amount to save gas
        bool success;
        if (devCut > 0) {
            uint cut = i.mul(devCut).div(10000);
            IERC20(wftm).safeTransfer(devAddr, cut);
            i = i.sub(cut);
        }
        (, success) = _swap(wftm, boo, i);
        if(!success)
            revert("BrewBooV3: swap failure in toBOO");

        //disperse
        uint _amt = IERC20(boo).balanceOf(address(this));
        uint bounty = _amt.mul(BOUNTY_FEE).div(10000);
        i = _amt.sub(bounty); //reuse i for amount to save gas
        IERC20(boo).safeTransfer(xboo, i); // send xboo its share
        IERC20(boo).safeTransfer(_msgSender(), bounty); // send message sender their share of 0.1%
        emit LogConvert(_msgSender(), boo, _amt, i);
    }

    function donate(uint booAmount) external {
        IERC20(boo).transferFrom(msg.sender, xboo, booAmount);
        emit LogConvert(_msgSender(), boo, booAmount, booAmount);
    }

    // internal functions

    function _convertStep(
        address token0,
        uint256 amount
    ) internal returns (bool) {
        // Interactions
        if (token0 == wftm || token0 == boo) {
            return true;
        } else {
            address bridge = lastRoute[token0];
            bool success = false;
            if(bridge != address(0))
                (amount, success) = _swap(token0, bridge, amount);

            if(success)
                _convertStep(bridge, amount);
            else for(uint i = 0; i < bridgeRouteAmount;) {
                bridge = bridgeRoute[i];
                if(bridge == address(0)) {
                    unchecked {++i;}
                    continue;
                }
                (amount, success) = _swap(token0, bridge, amount);
                if(!success)
                    if(i == bridgeRouteAmount - 1)
                        revert("BrewBooV3: bridge route failure - all options exhausted");
                    else {
                        unchecked {++i;}
                        continue;
                    }
                lastRoute[token0] = bridge;
                _convertStep(bridge, amount);
                break;
            }
        }
        return true;
    }

    function _swap(
        address fromToken,
        address toToken,
        uint256 amountIn
    ) internal returns (uint256 amountOut, bool success) {
        if(fromToken == toToken)
            return (amountIn, false);

        if(!swapperApproved[fromToken]) {
            IERC20(fromToken).approve(address(swapper), 2**256 - 1);
            swapperApproved[fromToken] = true;
        }

        try swapper.swap(fromToken, IUniswapV2Pair(_getPair(fromToken, toToken)), amountIn) returns (uint amount) {
            return (amount, true);
        } catch {
            return (amountIn, false);
        }
    }

    function _getPair(address tokenA, address tokenB) internal returns (address pair) {
        (tokenA, tokenB) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        pair = pairOf[tokenA][tokenB];
        if(pair == address(0)) {
            pair = factory.getPair(tokenA, tokenB);
            pairOf[tokenA][tokenB] = pair;
        }
    }

    //allows migration of lp tokens balance ONLY to the new(current) brewboo
    function migrate(address[] calldata tokens) external {
        address feToo = factory.feeTo();
        for(uint i = 0; i < tokens.length; ++i)
            IERC20(tokens[i]).transfer(feToo, IERC20(tokens[i]).balanceOf(address(this)));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @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.
 */
abstract 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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
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) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            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) {
        unchecked {
            // 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) {
        unchecked {
            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) {
        unchecked {
            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) {
        return a + b;
    }

    /**
     * @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 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) {
        return a * b;
    }

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @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 Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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'
        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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^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() {
        _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 making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;

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

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

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

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

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.5.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;
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.13;

import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IUniswapV2Pair.sol";
import "./interfaces/ISwapper.sol";


contract Swapper is ISwapper, Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;


    uint public slippage = 9;
    mapping(address => bool) public slippageOverrode;


    // onlyAuth type functions

    function overrideSlippage(address _token) external onlyOwner {
        slippageOverrode[_token] = !slippageOverrode[_token];
    }

    function setSlippage(uint _amt) external onlyOwner {
        require(_amt < 20, "slippage setting too high"); // the higher this setting, the lower the slippage tolerance, too high and buybacks would never work
        slippage = _amt;
    }

    function swap(
        address fromToken,
        IUniswapV2Pair pair,
        uint256 amountIn
    ) external returns (uint256 amountOut) {
        require(address(pair) != address(0), "BrewBoo: Cannot convert");

        (uint256 ui1, uint256 ui2, ) = pair.getReserves();
        bool isToken0 = fromToken == pair.token0();
        (ui1, ui2) = isToken0 ? (ui1, ui2) : (ui2, ui1);
        
        IERC20(fromToken).safeTransferFrom(msg.sender, address(pair), amountIn);
        amountIn = IERC20(fromToken).balanceOf(address(pair)).sub(ui1); // calculate amount that was transferred, this accounts for transfer taxes
        require(ui1.div(amountIn) > slippage || slippageOverrode[fromToken], "slippage too high");

        require(amountIn > 0, 'BrewBoo: INSUFFICIENT_INPUT_AMOUNT');
        require(ui1 > 0 && ui2 > 0, 'BrewBoo: INSUFFICIENT_LIQUIDITY');
        amountIn = amountIn.mul(998);
        amountOut = amountIn.mul(ui2) / ui1.mul(1000).add(amountIn);

        (ui1, ui2) = isToken0 ? (uint(0), amountOut) : (amountOut, uint(0));
        pair.swap(ui1, ui2, msg.sender, new bytes(0));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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://consensys.net/diligence/blog/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.8.0/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");

        (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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;

import "./IUniswapV2Pair.sol";

interface ISwapper {
    function swap(
        address fromToken,
        IUniswapV2Pair pair,
        uint256 amountIn
    ) external returns (uint256 amountOut);
    function overrideSlippage(address _token) external;
    function setSlippage(uint _amt) external;

}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"bridge","type":"address"}],"name":"LogBridgeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"server","type":"address"},{"indexed":true,"internalType":"address","name":"token0","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountBOO","type":"uint256"}],"name":"LogConvert","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_adr","type":"address"}],"name":"LogSlippageOverrode","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_adr","type":"address"}],"name":"LogToggleOverrode","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":false,"internalType":"address","name":"_addr","type":"address"}],"name":"SetDevAddr","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"SetDevCut","type":"event"},{"inputs":[],"name":"BOUNTY_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_auth","type":"address"}],"name":"addAuth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"authorized","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bridgeRoute","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridgeRouteAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"token0","type":"address[]"},{"internalType":"address[]","name":"token1","type":"address[]"},{"internalType":"uint256[]","name":"LPamounts","type":"uint256[]"}],"name":"convertMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devCut","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"booAmount","type":"uint256"}],"name":"donate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isAuth","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastRoute","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"overrideSlippage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"overrode","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"pairOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_auth","type":"address"}],"name":"revokeAuth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amt","type":"uint256"}],"name":"setBounty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"bridge","type":"address"}],"name":"setBridge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"setBridgeRoute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setBridgeRouteAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setDevAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setDevCut","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amt","type":"uint256"}],"name":"setSlippage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapper","outputs":[{"internalType":"contract ISwapper","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"swapperApproved","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xboo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

754:10446:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;960:29;;;;;;;;-1:-1:-1;;;;;178:32:13;;;160:51;;148:2;133:18;960:29:8;;;;;;;;2114:33;;;;;;;;;368:25:13;;;356:2;341:18;2114:33:8;222:177:13;1918:47:8;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;957:14:13;;950:22;932:41;;920:2;905:18;1918:47:8;792:187:13;1369:27:8;;;;;;:::i;:::-;;:::i;1325:38::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;920:33;;;;;10958:240;;;;;;:::i;:::-;;:::i;:::-;;4729:120;;;;;;:::i;:::-;;:::i;5423:83::-;;;;;;:::i;:::-;;:::i;2203:44::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;2203:44:8;;;5140:277;;;;;;:::i;:::-;;:::i;1824:101:0:-;;;:::i;6150:2309:8:-;;;;;;:::i;:::-;;:::i;1201:85:0:-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;1201:85;;1872:40:8;;;;;;:::i;:::-;;;;;;;;;;;;;;;;1066:18;;;;;;5826:318;;;;;;:::i;:::-;;:::i;2065:43::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;2065:43:8;;;1172:27;;;;;;872:42;;;;;3884:133;;;;;;:::i;:::-;;:::i;1205:22::-;;;;;-1:-1:-1;;;;;1205:22:8;;;4954:180;;;;;;:::i;:::-;;:::i;2305:61::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2305:61:8;;;5728:92;;;;;;:::i;:::-;;:::i;8465:177::-;;;;;;:::i;:::-;;:::i;2074:198:0:-;;;;;;:::i;:::-;;:::i;3537:341:8:-;;;;;;:::i;:::-;;:::i;4855:92::-;;;;;;:::i;:::-;;:::i;5571:151::-;;;;;;:::i;:::-;;:::i;1369:27::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1369:27:8;;-1:-1:-1;1369:27:8;:::o;10958:240::-;11021:13;11037:7;-1:-1:-1;;;;;11037:13:8;;:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11021:31;;11066:6;11062:129;11078:17;;;11062:129;;;11121:6;;11128:1;11121:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11114:26:8;;11141:5;11155:6;;11162:1;11155:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;11148:42;;-1:-1:-1;;;11148:42:8;;11184:4;11148:42;;;160:51:13;-1:-1:-1;;;;;11148:27:8;;;;;;;133:18:13;;11148:42:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11114:77;;-1:-1:-1;;;;;;11114:77:8;;;;;;;-1:-1:-1;;;;;5017:32:13;;;11114:77:8;;;4999:51:13;5066:18;;;5059:34;4972:18;;11114:77:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;11097:3:8;;;:::i;:::-;;;11062:129;;;;11011:187;10958:240;;:::o;4729:120::-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;4790:13:8::1;;::::0;;;:6:::1;:13;::::0;;;;:20;;-1:-1:-1;;4790:20:8::1;4806:4;4790:20:::0;;::::1;::::0;;;4820:10:::1;:22:::0;;;;::::1;::::0;;;;;;::::1;::::0;;-1:-1:-1;;;;;;4820:22:8::1;::::0;;::::1;::::0;;4729:120::o;5423:83::-;1094:13:0;:11;:13::i;:::-;5482:10:8::1;:17:::0;5423:83::o;5140:277::-;1247:7:0;1273:6;-1:-1:-1;;;;;1273:6:0;734:10:6;5202:23:8;;:50;;-1:-1:-1;5229:7:8;;-1:-1:-1;;;;;5229:7:8;734:10:6;5229:23:8;5202:50;5194:74;;;;-1:-1:-1;;;5194:74:8;;5860:2:13;5194:74:8;;;5842:21:13;5899:2;5879:18;;;5872:30;-1:-1:-1;;;5918:18:13;;;5911:41;5969:18;;5194:74:8;;;;;;;;;-1:-1:-1;;;;;5286:19:8;;5278:74;;;;-1:-1:-1;;;5278:74:8;;6200:2:13;5278:74:8;;;6182:21:13;6239:2;6219:18;;;6212:30;6278:34;6258:18;;;6251:62;-1:-1:-1;;;6329:18:13;;;6322:40;6379:19;;5278:74:8;5998:406:13;5278:74:8;5362:7;:15;;-1:-1:-1;;;;;;5362:15:8;-1:-1:-1;;;;;5362:15:8;;;;;;;;5393:17;;160:51:13;;;5393:17:8;;148:2:13;133:18;5393:17:8;;;;;;;;5140:277;:::o;1824:101:0:-;1094:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;:::-;1824:101::o:0;6150:2309:8:-;1750:10;1764:9;1750:23;1742:57;;;;-1:-1:-1;;;1742:57:8;;6611:2:13;1742:57:8;;;6593:21:13;6650:2;6630:18;;;6623:30;-1:-1:-1;;;6669:18:13;;;6662:51;6730:18;;1742:57:8;6409:345:13;1742:57:8;2261:21:1::1;:19;:21::i;:::-;6330:6:8::2;::::0;6375:652:::2;6387:17:::0;;::::2;6375:652;;;6438:6;;6445:1;6438:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6425:22:8::2;:6;;6432:1;6425:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6425:22:8::2;::::0;6421:167:::2;;6476:20;6486:6;;6493:1;6486:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;6476;:20::i;:::-;6475:21;6467:47;;;::::0;-1:-1:-1;;;6467:47:8;;6961:2:13;6467:47:8::2;::::0;::::2;6943:21:13::0;7000:2;6980:18;;;6973:30;-1:-1:-1;;;7019:18:13;;;7012:43;7072:18;;6467:47:8::2;6759:337:13::0;6467:47:8::2;6543:3;;;;;6375:652;;6421:167;6610:20;6620:6;;6627:1;6620:9;;;;;;;:::i;6610:20::-;6609:21;:46;;;;;6635:20;6645:6;;6652:1;6645:9;;;;;;;:::i;6635:20::-;6634:21;6609:46;6601:72;;;::::0;-1:-1:-1;;;6601:72:8;;6961:2:13;6601:72:8::2;::::0;::::2;6943:21:13::0;7000:2;6980:18;;;6973:30;-1:-1:-1;;;7019:18:13;;;7012:43;7072:18;;6601:72:8::2;6759:337:13::0;6601:72:8::2;6709:30;6718:6;;6725:1;6718:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;6729:6;;6736:1;6729:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;6709:8;:30::i;:::-;6687:53:::0;-1:-1:-1;;;;;;6762:27:8;::::2;6754:61;;;::::0;-1:-1:-1;;;6754:61:8;;7303:2:13;6754:61:8::2;::::0;::::2;7285:21:13::0;7342:2;7322:18;;;7315:30;-1:-1:-1;;;7361:18:13;;;7354:51;7422:18;;6754:61:8::2;7101:345:13::0;6754:61:8::2;6830:119;6873:4:::0;6880:21;;:68:::2;;6936:9;;6946:1;6936:12;;;;;;;:::i;:::-;;;;;;;6880:68;;;6904:29;::::0;-1:-1:-1;;;6904:29:8;;6927:4:::2;6904:29;::::0;::::2;160:51:13::0;-1:-1:-1;;;;;6904:14:8;::::2;::::0;::::2;::::0;133:18:13;;6904:29:8::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6830:34:8;::::2;::::0;:119;:34:::2;:119::i;:::-;6963:24;::::0;-1:-1:-1;;;6963:24:8;;6981:4:::2;6963:24;::::0;::::2;160:51:13::0;-1:-1:-1;;;;;6963:9:8;::::2;::::0;::::2;::::0;133:18:13;;6963:24:8::2;::::0;::::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;7012:3;;;;;6375:652;;;-1:-1:-1::0;;;;;7047:4:8::2;7037:15;;::::0;;;:9:::2;:15;::::0;;;;7055:12:::2;7037:30:::0;;:15;-1:-1:-1;7098:484:8::2;7110:17:::0;;::::2;7098:484;;;7162:9;:20;7172:6;;7179:1;7172:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7162:20:8::2;-1:-1:-1::0;;;;;7162:20:8::2;;;;;;;;;;;;;7147:12;:35;7144:193;;;7202:67;7215:6;;7222:1;7215:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;7233:6;;7240:1;7233:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;7226:42;::::0;-1:-1:-1;;;7226:42:8;;7262:4:::2;7226:42;::::0;::::2;160:51:13::0;-1:-1:-1;;;;;7226:27:8;;;::::2;::::0;::::2;::::0;133:18:13;;7226:42:8::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7202:12;:67::i;:::-;;7310:12;7287:9;:20;7297:6;;7304:1;7297:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7287:20:8::2;::::0;;::::2;::::0;::::2;::::0;;;;;;-1:-1:-1;7287:20:8;:35;7144:193:::2;7368:9;:20;7378:6;;7385:1;7378:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7368:20:8::2;-1:-1:-1::0;;;;;7368:20:8::2;;;;;;;;;;;;;7353:12;:35;7350:193;;;7408:67;7421:6;;7428:1;7421:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;7439:6;;7446:1;7439:9;;;;;;;:::i;7408:67::-;;7516:12;7493:9;:20;7503:6;;7510:1;7503:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7493:20:8::2;::::0;;::::2;::::0;::::2;::::0;;;;;;-1:-1:-1;7493:20:8;:35;7350:193:::2;7567:3;;;;;7098:484;;;7660:37;::::0;-1:-1:-1;;;7660:37:8;;7691:4:::2;7660:37;::::0;::::2;160:51:13::0;7667:4:8::2;-1:-1:-1::0;;;;;7660:22:8::2;::::0;::::2;::::0;133:18:13;;7660:37:8::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7656:41;;7740:12;7775:1:::0;7766:6:::2;;:10;7762:157;;;7792:8;7803:24;7821:5;7803:13;7809:6;;7803:1;:5;;:13;;;;:::i;:::-;:17:::0;::::2;:24::i;:::-;7867:7;::::0;7792:35;;-1:-1:-1;7841:39:8::2;::::0;-1:-1:-1;;;;;7848:4:8::2;7841:25:::0;::::2;::::0;7867:7:::2;7792:35:::0;7841:25:::2;:39::i;:::-;7898:10;:1:::0;7904:3;7898:5:::2;:10::i;:::-;7894:14;;7778:141;7762:157;7942:19;7948:4;7954:3;7959:1;7942:5;:19::i;:::-;7928:33:::0;-1:-1:-1;7928:33:8;;-1:-1:-1;7971:67:8::2;;7996:42;::::0;-1:-1:-1;;;7996:42:8;;7903:2:13;7996:42:8::2;::::0;::::2;7885:21:13::0;;;7922:18;;;7915:30;7981:34;7961:18;;;7954:62;8033:18;;7996:42:8::2;7701:356:13::0;7971:67:8::2;8080:36;::::0;-1:-1:-1;;;8080:36:8;;8110:4:::2;8080:36;::::0;::::2;160:51:13::0;8068:9:8::2;::::0;8087:3:::2;-1:-1:-1::0;;;;;8080:21:8::2;::::0;::::2;::::0;133:18:13;;8080:36:8::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8068:48;;8126:11;8140:31;8165:5;8140:20;8149:10;;8140:4;:8;;:20;;;;:::i;:31::-;8126:45:::0;-1:-1:-1;8185:16:8::2;:4:::0;8126:45;8185:8:::2;:16::i;:::-;8181:20:::0;-1:-1:-1;8244:33:8::2;-1:-1:-1::0;;;;;8251:3:8::2;8244:24;8269:4;8181:20:::0;8244:24:::2;:33::i;:::-;8310:46;8317:3;-1:-1:-1::0;;;;;8310:24:8::2;734:10:6::0;8349:6:8;8310:24:::2;:46::i;:::-;8414:38;::::0;;8236:25:13;;;8292:2;8277:18;;8270:34;;;8439:3:8::2;-1:-1:-1::0;;;;;8414:38:8::2;::::0;734:10:6;;8414:38:8::2;::::0;8209:18:13;8414:38:8::2;;;;;;;6320:2139;;;;;2303:20:1::1;1716:1:::0;2809:22;;2629:209;2303:20:::1;6150:2309:8::0;;;;;;:::o;5826:318::-;734:10:6;1441:20:8;;;;:6;:20;;;;;;;;1433:51;;;;-1:-1:-1;;;1433:51:8;;;;;;;:::i;:::-;5952:3:::1;-1:-1:-1::0;;;;;5943:12:8::1;:5;-1:-1:-1::0;;;;;5943:12:8::1;;;:29;;;;;5968:4;-1:-1:-1::0;;;;;5959:13:8::1;:5;-1:-1:-1::0;;;;;5959:13:8::1;;;5943:29;:48;;;;;5985:6;-1:-1:-1::0;;;;;5976:15:8::1;:5;-1:-1:-1::0;;;;;5976:15:8::1;;;5943:48;5922:118;;;::::0;-1:-1:-1;;;5922:118:8;;8864:2:13;5922:118:8::1;::::0;::::1;8846:21:13::0;8903:2;8883:18;;;8876:30;8942:25;8922:18;;;8915:53;8985:18;;5922:118:8::1;8662:347:13::0;5922:118:8::1;-1:-1:-1::0;;;;;6070:16:8;;::::1;;::::0;;;:9:::1;:16;::::0;;;;;:25;;-1:-1:-1;;;;;;6070:25:8::1;::::0;;::::1;::::0;;::::1;::::0;;6110:27;::::1;::::0;6070:16;6110:27:::1;5826:318:::0;;:::o;3884:133::-;734:10:6;1441:20:8;;;;:6;:20;;;;;;;;1433:51;;;;-1:-1:-1;;;1433:51:8;;;;;;;:::i;:::-;3972:1:::1;3963:6;:10;3955:19;;;::::0;::::1;;3984:17;:26:::0;3884:133::o;4954:180::-;1094:13:0;:11;:13::i;:::-;5035:4:8::1;5024:7;:15;;5016:51;;;::::0;-1:-1:-1;;;5016:51:8;;9216:2:13;5016:51:8::1;::::0;::::1;9198:21:13::0;9255:2;9235:18;;;9228:30;9294:25;9274:18;;;9267:53;9337:18;;5016:51:8::1;9014:347:13::0;5016:51:8::1;5077:6;:16:::0;;;5109:18:::1;::::0;368:25:13;;;5109:18:8::1;::::0;356:2:13;341:18;5109::8::1;222:177:13::0;5728:92:8;734:10:6;1441:20:8;;;;:6;:20;;;;;;;;1433:51;;;;-1:-1:-1;;;1433:51:8;;;;;;;:::i;:::-;5788:25:::1;::::0;-1:-1:-1;;;5788:25:8;;::::1;::::0;::::1;368::13::0;;;5788:7:8::1;-1:-1:-1::0;;;;;5788:19:8::1;::::0;::::1;::::0;341:18:13;;5788:25:8::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;5728:92:::0;:::o;8465:177::-;8516:53;;-1:-1:-1;;;8516:53:8;;8541:10;8516:53;;;9606:34:13;-1:-1:-1;;;;;8553:4:8;9676:15:13;;9656:18;;;9649:43;9708:18;;;9701:34;;;8523:3:8;8516:24;;;;9541:18:13;;8516:53:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;8584:51:8;;;8236:25:13;;;8292:2;8277:18;;8270:34;;;8609:3:8;-1:-1:-1;;;;;8584:51:8;;734:10:6;;8584:51:8;;8209:18:13;8584:51:8;;;;;;;8465:177;:::o;2074:198:0:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2162:22:0;::::1;2154:73;;;::::0;-1:-1:-1;;;2154:73:0;;9948:2:13;2154:73:0::1;::::0;::::1;9930:21:13::0;9987:2;9967:18;;;9960:30;10026:34;10006:18;;;9999:62;-1:-1:-1;;;10077:18:13;;;10070:36;10123:19;;2154:73:0::1;9746:402:13::0;2154:73:0::1;2237:28;2256:8;2237:18;:28::i;:::-;2074:198:::0;:::o;3537:341:8:-;734:10:6;1441:20:8;;;;:6;:20;;;;;;;;1433:51;;;;-1:-1:-1;;;1433:51:8;;;;;;;:::i;:::-;3702:17:::1;;3693:5;:26;;3685:74;;;::::0;-1:-1:-1;;;3685:74:8;;10355:2:13;3685:74:8::1;::::0;::::1;10337:21:13::0;10394:2;10374:18;;;10367:30;10433:34;10413:18;;;10406:62;-1:-1:-1;;;10484:18:13;;;10477:33;10527:19;;3685:74:8::1;10153:399:13::0;3685:74:8::1;3770:18;::::0;;;:11:::1;:18;::::0;;;;:26;;-1:-1:-1;;;;;;3770:26:8::1;-1:-1:-1::0;;;;;3770:26:8;::::1;;::::0;;3818:17:::1;::::0;3809:26;;3806:65:::1;;3870:1;3849:17;;:22;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;3806:65:8::1;3537:341:::0;;:::o;4855:92::-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;4919:13:8::1;4935:5;4919:13:::0;;;:6:::1;:13;::::0;;;;:21;;-1:-1:-1;;4919:21:8::1;::::0;;4855:92::o;5571:151::-;734:10:6;1441:20:8;;;;:6;:20;;;;;;;;1433:51;;;;-1:-1:-1;;;1433:51:8;;;;;;;:::i;:::-;5641:32:::1;::::0;-1:-1:-1;;;5641:32:8;;-1:-1:-1;;;;;178:32:13;;;5641::8::1;::::0;::::1;160:51:13::0;5641:7:8::1;:24;::::0;::::1;::::0;133:18:13;;5641:32:8::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;5688:27:8::1;::::0;-1:-1:-1;;;;;178:32:13;;160:51;;5688:27:8::1;::::0;-1:-1:-1;148:2:13;133:18;;-1:-1:-1;5688:27:8::1;14:203:13::0;1359:130:0;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;734:10:6;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;10892:2:13;1414:68:0;;;10874:21:13;;;10911:18;;;10904:30;10970:34;10950:18;;;10943:62;11022:18;;1414:68:0;10690:356:13;2426:187:0;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;;;;;2534:17:0;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;2336:287:1:-;1759:1;2468:7;;:19;2460:63;;;;-1:-1:-1;;;2460:63:1;;11253:2:13;2460:63:1;;;11235:21:13;11292:2;11272:18;;;11265:30;11331:33;11311:18;;;11304:61;11382:18;;2460:63:1;11051:355:13;2460:63:1;1759:1;2598:7;:18;2336:287::o;4023:671:8:-;-1:-1:-1;;;;;4094:14:8;;4074:4;4094:14;;;:8;:14;;;;;;;;4090:32;;;-1:-1:-1;4117:5:8;;4023:671;-1:-1:-1;4023:671:8:o;4090:32::-;4132:19;4169:4;4132:42;;4188:4;-1:-1:-1;;;;;4188:11:8;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4188:13:8;;;;;;;;-1:-1:-1;;4188:13:8;;;;;;;;;;;;:::i;:::-;;;4184:504;;-1:-1:-1;;;;;;;4630:14:8;;;;;:8;:14;;;;;:21;;-1:-1:-1;;4630:21:8;4647:4;4630:21;;;:14;4023:671::o;4184:504::-;4241:14;4258:4;-1:-1:-1;;;;;4258:11:8;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4241:30;;4285:16;4304:24;4313:6;4321;4304:8;:24::i;:::-;4285:43;;4434:8;-1:-1:-1;;;;;4426:16:8;:4;-1:-1:-1;;;;;4426:16:8;;4422:152;;-1:-1:-1;;;;;4462:14:8;;;;;;:8;:14;;;;;;;;;:21;;-1:-1:-1;;4462:21:8;4479:4;4462:21;;;4506:23;;160:51:13;;;4506:23:8;;133:18:13;4506:23:8;;;;;;;-1:-1:-1;4554:5:8;;4023:671;-1:-1:-1;;;;;4023:671:8:o;4422:152::-;-1:-1:-1;4594:4:8;;4023:671;-1:-1:-1;;;;;4023:671:8:o;10527:348::-;10595:12;10647:6;-1:-1:-1;;;;;10638:15:8;:6;-1:-1:-1;;;;;10638:15:8;;:53;;10676:6;10684;10638:53;;;10657:6;10665;10638:53;-1:-1:-1;;;;;10708:14:8;;;;;;;:6;:14;;;;;;;;:22;;;;;;;;;;;10619:72;;-1:-1:-1;10619:72:8;;-1:-1:-1;10708:22:8;;-1:-1:-1;10708:22:8;10740:129;;10784:31;;-1:-1:-1;;;10784:31:8;;-1:-1:-1;;;;;11641:15:13;;;10784:31:8;;;11623:34:13;11693:15;;;11673:18;;;11666:43;10784:7:8;:15;;;;11558:18:13;;10784:31:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10829:14:8;;;;;;;:6;:14;;;;;;;;:22;;;;;;;;;;:29;;-1:-1:-1;;;;;;10829:29:8;;;;;;;;;;;-1:-1:-1;10740:129:8;10527:348;;;;:::o;941:175:4:-;1050:58;;;-1:-1:-1;;;;;5017:32:13;;1050:58:4;;;4999:51:13;5066:18;;;;5059:34;;;1050:58:4;;;;;;;;;;4972:18:13;;;;1050:58:4;;;;;;;;-1:-1:-1;;;;;1050:58:4;-1:-1:-1;;;1050:58:4;;;1023:86;;1043:5;;1023:19;:86::i;:::-;941:175;;;:::o;8675:1225:8:-;8769:4;8823;-1:-1:-1;;;;;8813:14:8;:6;-1:-1:-1;;;;;8813:14:8;;:31;;;;8841:3;-1:-1:-1;;;;;8831:13:8;:6;-1:-1:-1;;;;;8831:13:8;;8813:31;8809:1064;;;-1:-1:-1;8867:4:8;8860:11;;8809:1064;-1:-1:-1;;;;;8919:17:8;;;8902:14;8919:17;;;:9;:17;;;;;;;;;;8987:20;;8984:90;;9045:29;9051:6;9059;9067;9045:5;:29::i;:::-;9025:49;;-1:-1:-1;9025:49:8;-1:-1:-1;8984:90:8;9092:7;9089:774;;;9117:28;9130:6;9138;9117:12;:28::i;:::-;;9089:774;;;9168:6;9164:699;9184:17;;9180:1;:21;9164:699;;;9231:14;;;;:11;:14;;;;;;-1:-1:-1;;;;;9231:14:8;;-1:-1:-1;9231:14:8;9263:111;;9321:3;;9164:699;;9263:111;9411:29;9417:6;9425;9433;9411:5;:29::i;:::-;9391:49;;-1:-1:-1;9391:49:8;-1:-1:-1;9391:49:8;9458:278;;9519:1;9499:17;;:21;;;;:::i;:::-;9494:1;:26;9491:245;;9546:65;;-1:-1:-1;;;9546:65:8;;12052:2:13;9546:65:8;;;12034:21:13;12091:2;12071:18;;;12064:30;12130:34;12110:18;;;12103:62;12201:25;12181:18;;;12174:53;12244:19;;9546:65:8;11850:419:13;9491:245:8;9675:3;;9164:699;;9491:245;-1:-1:-1;;;;;9753:17:8;;;;;;;:9;:17;;;;;:26;;-1:-1:-1;;;;;;9753:26:8;;;;;;;;;;9797:28;9753:26;9818:6;9797:12;:28::i;:::-;;9164:699;;9089:774;8888:985;;-1:-1:-1;9889:4:8;8675:1225;;;;:::o;3465:96:7:-;3523:7;3549:5;3553:1;3549;:5;:::i;:::-;3542:12;3465:96;-1:-1:-1;;;3465:96:7:o;3850:::-;3908:7;3934:5;3938:1;3934;:5;:::i;3122:96::-;3180:7;3206:5;3210:1;3206;:5;:::i;9906:615:8:-;10023:17;10042:12;10082:7;-1:-1:-1;;;;;10069:20:8;:9;-1:-1:-1;;;;;10069:20:8;;10066:61;;-1:-1:-1;10111:8:8;;-1:-1:-1;10121:5:8;10103:24;;10066:61;-1:-1:-1;;;;;10142:26:8;;;;;;:15;:26;;;;;;;;10138:159;;10184:55;;-1:-1:-1;;;10184:55:8;;-1:-1:-1;;;;;10218:7:8;5017:32:13;;10184:55:8;;;4999:51:13;-1:-1:-1;;5066:18:13;;;5059:34;10184:25:8;;;;;4972:18:13;;10184:55:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;10253:26:8;;;;;;:15;:26;;;;;:33;;-1:-1:-1;;10253:33:8;10282:4;10253:33;;;10138:159;10311:7;-1:-1:-1;;;;;10311:12:8;;10324:9;10350:28;10359:9;10370:7;10350:8;:28::i;:::-;10311:79;;-1:-1:-1;;;;;;10311:79:8;;;;;;;-1:-1:-1;;;;;9624:15:13;;;10311:79:8;;;9606:34:13;9676:15;;9656:18;;;9649:43;9708:18;;;9701:34;;;9541:18;;10311:79:8;;;;;;;;;;;;;;;;;;;-1:-1:-1;10311:79:8;;;;;;;;-1:-1:-1;;10311:79:8;;;;;;;;;;;;:::i;:::-;;;10307:208;;-1:-1:-1;10488:8:8;;-1:-1:-1;10498:5:8;10480:24;;10307:208;10435:6;-1:-1:-1;10443:4:8;;-1:-1:-1;10307:208:8;9906:615;;;;;;:::o;5196:642:4:-;5615:23;5641:69;5669:4;5641:69;;;;;;;;;;;;;;;;;5649:5;-1:-1:-1;;;;;5641:27:4;;;:69;;;;;:::i;:::-;5615:95;;5728:10;:17;5749:1;5728:22;:56;;;;5765:10;5754:30;;;;;;;;;;;;:::i;:::-;5720:111;;;;-1:-1:-1;;;5720:111:4;;13638:2:13;5720:111:4;;;13620:21:13;13677:2;13657:18;;;13650:30;13716:34;13696:18;;;13689:62;-1:-1:-1;;;13767:18:13;;;13760:40;13817:19;;5720:111:4;13436:406:13;4108:223:5;4241:12;4272:52;4294:6;4302:4;4308:1;4311:12;4272:21;:52::i;:::-;4265:59;4108:223;-1:-1:-1;;;;4108:223:5:o;5165:446::-;5330:12;5387:5;5362:21;:30;;5354:81;;;;-1:-1:-1;;;5354:81:5;;14049:2:13;5354:81:5;;;14031:21:13;14088:2;14068:18;;;14061:30;14127:34;14107:18;;;14100:62;-1:-1:-1;;;14178:18:13;;;14171:36;14224:19;;5354:81:5;13847:402:13;5354:81:5;5446:12;5460:23;5487:6;-1:-1:-1;;;;;5487:11:5;5506:5;5513:4;5487:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5445:73;;;;5535:69;5562:6;5570:7;5579:10;5591:12;5535:26;:69::i;:::-;5528:76;5165:446;-1:-1:-1;;;;;;;5165:446:5:o;7671:628::-;7851:12;7879:7;7875:418;;;7906:10;:17;7927:1;7906:22;7902:286;;-1:-1:-1;;;;;1702:19:5;;;8113:60;;;;-1:-1:-1;;;8113:60:5;;14998:2:13;8113:60:5;;;14980:21:13;15037:2;15017:18;;;15010:30;15076:31;15056:18;;;15049:59;15125:18;;8113:60:5;14796:353:13;8113:60:5;-1:-1:-1;8208:10:5;8201:17;;7875:418;8249:33;8257:10;8269:12;8980:17;;:21;8976:379;;9208:10;9202:17;9264:15;9251:10;9247:2;9243:19;9236:44;8976:379;9331:12;9324:20;;-1:-1:-1;;;9324:20:5;;;;;;;;:::i;404:131:13:-;-1:-1:-1;;;;;479:31:13;;469:42;;459:70;;525:1;522;515:12;540:247;599:6;652:2;640:9;631:7;627:23;623:32;620:52;;;668:1;665;658:12;620:52;707:9;694:23;726:31;751:5;726:31;:::i;984:180::-;1043:6;1096:2;1084:9;1075:7;1071:23;1067:32;1064:52;;;1112:1;1109;1102:12;1064:52;-1:-1:-1;1135:23:13;;984:180;-1:-1:-1;984:180:13:o;1394:367::-;1457:8;1467:6;1521:3;1514:4;1506:6;1502:17;1498:27;1488:55;;1539:1;1536;1529:12;1488:55;-1:-1:-1;1562:20:13;;1605:18;1594:30;;1591:50;;;1637:1;1634;1627:12;1591:50;1674:4;1666:6;1662:17;1650:29;;1734:3;1727:4;1717:6;1714:1;1710:14;1702:6;1698:27;1694:38;1691:47;1688:67;;;1751:1;1748;1741:12;1688:67;1394:367;;;;;:::o;1766:437::-;1852:6;1860;1913:2;1901:9;1892:7;1888:23;1884:32;1881:52;;;1929:1;1926;1919:12;1881:52;1969:9;1956:23;2002:18;1994:6;1991:30;1988:50;;;2034:1;2031;2024:12;1988:50;2073:70;2135:7;2126:6;2115:9;2111:22;2073:70;:::i;:::-;2162:8;;2047:96;;-1:-1:-1;1766:437:13;-1:-1:-1;;;;1766:437:13:o;2208:1088::-;2366:6;2374;2382;2390;2398;2406;2459:2;2447:9;2438:7;2434:23;2430:32;2427:52;;;2475:1;2472;2465:12;2427:52;2515:9;2502:23;2544:18;2585:2;2577:6;2574:14;2571:34;;;2601:1;2598;2591:12;2571:34;2640:70;2702:7;2693:6;2682:9;2678:22;2640:70;:::i;:::-;2729:8;;-1:-1:-1;2614:96:13;-1:-1:-1;2817:2:13;2802:18;;2789:32;;-1:-1:-1;2833:16:13;;;2830:36;;;2862:1;2859;2852:12;2830:36;2901:72;2965:7;2954:8;2943:9;2939:24;2901:72;:::i;:::-;2992:8;;-1:-1:-1;2875:98:13;-1:-1:-1;3080:2:13;3065:18;;3052:32;;-1:-1:-1;3096:16:13;;;3093:36;;;3125:1;3122;3115:12;3093:36;;3164:72;3228:7;3217:8;3206:9;3202:24;3164:72;:::i;:::-;2208:1088;;;;-1:-1:-1;2208:1088:13;;-1:-1:-1;2208:1088:13;;3255:8;;2208:1088;-1:-1:-1;;;2208:1088:13:o;3301:388::-;3369:6;3377;3430:2;3418:9;3409:7;3405:23;3401:32;3398:52;;;3446:1;3443;3436:12;3398:52;3485:9;3472:23;3504:31;3529:5;3504:31;:::i;:::-;3554:5;-1:-1:-1;3611:2:13;3596:18;;3583:32;3624:33;3583:32;3624:33;:::i;:::-;3676:7;3666:17;;;3301:388;;;;;:::o;3928:315::-;3996:6;4004;4057:2;4045:9;4036:7;4032:23;4028:32;4025:52;;;4073:1;4070;4063:12;4025:52;4109:9;4096:23;4086:33;;4169:2;4158:9;4154:18;4141:32;4182:31;4207:5;4182:31;:::i;4248:251::-;4318:6;4371:2;4359:9;4350:7;4346:23;4342:32;4339:52;;;4387:1;4384;4377:12;4339:52;4419:9;4413:16;4438:31;4463:5;4438:31;:::i;4504:127::-;4565:10;4560:3;4556:20;4553:1;4546:31;4596:4;4593:1;4586:15;4620:4;4617:1;4610:15;4636:184;4706:6;4759:2;4747:9;4738:7;4734:23;4730:32;4727:52;;;4775:1;4772;4765:12;4727:52;-1:-1:-1;4798:16:13;;4636:184;-1:-1:-1;4636:184:13:o;5104:277::-;5171:6;5224:2;5212:9;5203:7;5199:23;5195:32;5192:52;;;5240:1;5237;5230:12;5192:52;5272:9;5266:16;5325:5;5318:13;5311:21;5304:5;5301:32;5291:60;;5347:1;5344;5337:12;5386:127;5447:10;5442:3;5438:20;5435:1;5428:31;5478:4;5475:1;5468:15;5502:4;5499:1;5492:15;5518:135;5557:3;5578:17;;;5575:43;;5598:18;;:::i;:::-;-1:-1:-1;5645:1:13;5634:13;;5518:135::o;7451:245::-;7530:6;7538;7591:2;7579:9;7570:7;7566:23;7562:32;7559:52;;;7607:1;7604;7597:12;7559:52;-1:-1:-1;;7630:16:13;;7686:2;7671:18;;;7665:25;7630:16;;7665:25;;-1:-1:-1;7451:245:13:o;8315:342::-;8517:2;8499:21;;;8556:2;8536:18;;;8529:30;-1:-1:-1;;;8590:2:13;8575:18;;8568:48;8648:2;8633:18;;8315:342::o;10557:128::-;10597:3;10628:1;10624:6;10621:1;10618:13;10615:39;;;10634:18;;:::i;:::-;-1:-1:-1;10670:9:13;;10557:128::o;11720:125::-;11760:4;11788:1;11785;11782:8;11779:34;;;11793:18;;:::i;:::-;-1:-1:-1;11830:9:13;;11720:125::o;12274:168::-;12314:7;12380:1;12376;12372:6;12368:14;12365:1;12362:21;12357:1;12350:9;12343:17;12339:45;12336:71;;;12387:18;;:::i;:::-;-1:-1:-1;12427:9:13;;12274:168::o;12447:217::-;12487:1;12513;12503:132;;12557:10;12552:3;12548:20;12545:1;12538:31;12592:4;12589:1;12582:15;12620:4;12617:1;12610:15;12503:132;-1:-1:-1;12649:9:13;;12447:217::o;14254:258::-;14326:1;14336:113;14350:6;14347:1;14344:13;14336:113;;;14426:11;;;14420:18;14407:11;;;14400:39;14372:2;14365:10;14336:113;;;14467:6;14464:1;14461:13;14458:48;;;-1:-1:-1;;14502:1:13;14484:16;;14477:27;14254:258::o;14517:274::-;14646:3;14684:6;14678:13;14700:53;14746:6;14741:3;14734:4;14726:6;14722:17;14700:53;:::i;:::-;14769:16;;;;;14517:274;-1:-1:-1;;14517:274:13:o;15154:383::-;15303:2;15292:9;15285:21;15266:4;15335:6;15329:13;15378:6;15373:2;15362:9;15358:18;15351:34;15394:66;15453:6;15448:2;15437:9;15433:18;15428:2;15420:6;15416:15;15394:66;:::i;:::-;15521:2;15500:15;-1:-1:-1;;15496:29:13;15481:45;;;;15528:2;15477:54;;15154:383;-1:-1:-1;;15154:383:13:o

ipfs://52c944636c8381c23ceea4b209de2f165a4da16129dfc4f9981eb90347ecc07b