Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Address
•    - function isContract(address account)
• interface IExchange
•    - function swap(
•    - function buy(
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
• interface ITokenTransferProxy
•    - function transferFrom(
•    - function freeGSTTokens(uint256 tokens ...
• library Utils
•    - function ethAddress()
•    - function maxUint()
•    - function approve(
•    - function transferTokens(
•    - function tokenBalance(
•    - function refundGas(address tokenProxy ...
•    - function freeGasTokens(address tokenP ...
• interface IUniswapRouter
•    - function swapExactTokensForTokens(
•    - function swapExactETHForTokens(
•    - function swapExactTokensForETH(
•    - function swapETHForExactTokens(
•    - function swapTokensForExactETH(
•    - function swapTokensForExactTokens(
•  contract Ownable
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract TokenFetcher is Ownable
•    - function transferTokens(
•  contract UniswapV2 is IExchange, T ... *
•    - function()
•    - function swap(
•    - function buy(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-06-09
*/

// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see `ERC20Detailed`.
 */
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.
     *
     * > 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-solidity/contracts/utils/Address.sol

pragma solidity ^0.5.0;

/**
 * @dev Collection of functions related to the address type,
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * > It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in 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;
    }
}

// File: original_contracts/lib/IExchange.sol

pragma solidity 0.5.11;



/**
* @dev This interface should be implemented by all exchanges which needs to integrate with the paraswap protocol
*/
interface IExchange {

    /**
   * @dev The function which performs the swap on an exchange.
   * Exchange needs to implement this method in order to support swapping of tokens through it
   * @param fromToken Address of the source token
   * @param toToken Address of the destination token
   * @param fromAmount Amount of source tokens to be swapped
   * @param toAmount Minimum destination token amount expected out of this swap
   * @param exchange Internal exchange or factory contract address for the exchange. For example Registry address for the Uniswap
   * @param payload Any exchange specific data which is required can be passed in this argument in encoded format which
   * will be decoded by the exchange. Each exchange will publish it's own decoding/encoding mechanism
   */
    function swap(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        address exchange,
        bytes calldata payload) external payable returns (uint256);

/**
   * @dev The function which performs the swap on an exchange.
   * Exchange needs to implement this method in order to support swapping of tokens through it
   * @param fromToken Address of the source token
   * @param toToken Address of the destination token
   * @param fromAmount Max Amount of source tokens to be swapped
   * @param toAmount Destination token amount expected out of this swap
   * @param exchange Internal exchange or factory contract address for the exchange. For example Registry address for the Uniswap
   * @param payload Any exchange specific data which is required can be passed in this argument in encoded format which
   * will be decoded by the exchange. Each exchange will publish it's own decoding/encoding mechanism
   */
    function buy(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        address exchange,
        bytes calldata payload) external payable returns (uint256);
}

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.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, 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");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.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 ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // 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);
        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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

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

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

// File: original_contracts/ITokenTransferProxy.sol

pragma solidity 0.5.11;


interface ITokenTransferProxy {

    function transferFrom(
        address token,
        address from,
        address to,
        uint256 amount
    )
        external;

    function freeGSTTokens(uint256 tokensToFree) external;
}

// File: original_contracts/lib/Utils.sol

pragma solidity 0.5.11;







library Utils {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address constant ETH_ADDRESS = address(
        0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
    );

    uint256 constant MAX_UINT = 2 ** 256 - 1;

    struct Route {
        address payable exchange;
        address targetExchange;
        uint percent;
        bytes payload;
        uint256 networkFee;
    }

    struct Path {
        address to;
        uint256 totalNetworkFee;
        Route[] routes;
    }

    struct BuyRoute {
        address payable exchange;
        address targetExchange;
        uint256 fromAmount;
        uint256 toAmount;
        bytes payload;
        uint256 networkFee;
    }

    function ethAddress() internal pure returns (address) {return ETH_ADDRESS;}

    function maxUint() internal pure returns (uint256) {return MAX_UINT;}

    function approve(
        address addressToApprove,
        address token
    ) internal {
        if (token != ETH_ADDRESS) {
            IERC20 _token = IERC20(token);

            uint allowance = _token.allowance(address(this), addressToApprove);

            if (allowance < MAX_UINT / 10) {
                _token.safeApprove(addressToApprove, MAX_UINT);
            }
        }
    }

    function transferTokens(
        address token,
        address payable destination,
        uint256 amount
    )
    internal
    {
        if (token == ETH_ADDRESS) {
            destination.transfer(amount);
        }
        else {
            IERC20(token).safeTransfer(destination, amount);
        }
    }

    function tokenBalance(
        address token,
        address account
    )
    internal
    view
    returns (uint256)
    {
        if (token == ETH_ADDRESS) {
            return account.balance;
        } else {
            return IERC20(token).balanceOf(account);
        }
    }

    /**
    * @dev Helper method to refund gas using gas tokens
    */
    function refundGas(address tokenProxy, uint256 initialGas, uint256 mintPrice) internal {

        uint256 mintBase = 32254;
        uint256 mintToken = 36543;
        uint256 freeBase = 14154;
        uint256 freeToken = 6870;
        uint256 reimburse = 24000;

        uint256 tokens = initialGas.sub(
            gasleft()).add(freeBase).div(reimburse.mul(2).sub(freeToken)
        );

        uint256 mintCost = mintBase.add(tokens.mul(mintToken));
        uint256 freeCost = freeBase.add(tokens.mul(freeToken));
        uint256 maxreimburse = tokens.mul(reimburse);

        uint256 efficiency = maxreimburse.mul(tx.gasprice).mul(100).div(
            mintCost.mul(mintPrice).add(freeCost.mul(tx.gasprice))
        );

        if (efficiency > 100) {
            freeGasTokens(tokenProxy, tokens);
        }
    }

    /**
    * @dev Helper method to free gas tokens
    */
    function freeGasTokens(address tokenProxy, uint256 tokens) internal {

        uint256 tokensToFree = tokens;
        uint256 safeNumTokens = 0;
        uint256 gas = gasleft();

        if (gas >= 27710) {
            safeNumTokens = gas.sub(27710).div(1148 + 5722 + 150);
        }

        if (tokensToFree > safeNumTokens) {
            tokensToFree = safeNumTokens;
        }

        ITokenTransferProxy(tokenProxy).freeGSTTokens(tokensToFree);

    }
}

// File: original_contracts/lib/uniswapv2/IUniswapRouter.sol

pragma solidity 0.5.11;


interface IUniswapRouter {

    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        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 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 swapTokensForExactETH(
        uint256 amountOut,
        uint amountInMax,
        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);

}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity ^0.5.0;

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

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

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

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

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

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: original_contracts/lib/TokenFetcher.sol

pragma solidity 0.5.11;




contract TokenFetcher is Ownable {

    /**
    * @dev Allows owner of the contract to transfer tokens any tokens which are assigned to the contract
    * This method is for saftey if by any chance tokens or ETHs are assigned to the contract by mistake
    * @dev token Address of the token to be transferred
    * @dev destination Recepient of the token
    * @dev amount Amount of tokens to be transferred
    */
    function transferTokens(
        address token,
        address payable destination,
        uint256 amount
    )
        external
        onlyOwner
    {
        Utils.transferTokens(token, destination, amount);
    }
}

// File: original_contracts/lib/uniswapv2/UniswapV2.sol

pragma solidity 0.5.11;
pragma experimental ABIEncoderV2;








contract UniswapV2 is IExchange, TokenFetcher {
    using SafeMath for uint256;
    using Address for address;

    struct UniswapV2Data {
        address[] path;
    }

    address public weth;

    constructor(address _weth) public {
        weth = _weth;
    }

    /**
    * @dev Fallback method to allow exchanges to transfer back ethers for a particular swap
    * It will only allow contracts to send funds to it
    */
    function() external payable {
        address account = msg.sender;
        require(
            account.isContract(),
            "Sender is not a contract"
        );
    }

    function swap(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        address exchange,
        bytes calldata payload) external payable returns (uint256) {

        UniswapV2Data memory data = abi.decode(payload, (UniswapV2Data));

        Utils.approve(address(exchange), address(fromToken));

        if (address(fromToken) == Utils.ethAddress()) {
            require(
                data.path[0] == weth,
                "First element in path must be WETH"
            );

            require(
                data.path[data.path.length - 1] == address(toToken),
                "last element in path must be toToken"
            );

            IUniswapRouter(exchange).swapExactETHForTokens.value(fromAmount)(
                toAmount,
                data.path,
                address(this),
                now
            );
        }
        else if (address(toToken) == Utils.ethAddress()) {
            require(
                data.path[0] == address(fromToken),
                "First element in path must be fromToken"
            );

            require(
                data.path[data.path.length - 1] == weth,
                "last element in path must be weth"
            );
            IUniswapRouter(exchange).swapExactTokensForETH(
                fromAmount,
                toAmount,
                data.path,
                address(this),
                now
            );
        }
        else {
            require(
                data.path[0] == address(fromToken),
                "First element in path must be fromToken"
            );

            require(
                data.path[data.path.length - 1] == address(toToken),
                "last element in path must be toToken"
            );
            IUniswapRouter(exchange).swapExactTokensForTokens(
                fromAmount,
                toAmount,
                data.path,
                address(this),
                now
            );
        }

        uint256 receivedAmount = Utils.tokenBalance(
          address(toToken),
          address(this)
        );

        Utils.transferTokens(address(toToken), msg.sender, receivedAmount);

        return receivedAmount;
    }

    function buy(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 toAmount,
        address exchange,
        bytes calldata payload) external payable returns (uint256) {

        UniswapV2Data memory data = abi.decode(payload, (UniswapV2Data));

        Utils.approve(address(exchange), address(fromToken));

        if (address(fromToken) == Utils.ethAddress()) {
            require(
                data.path[0] == weth,
                "First element in path must be WETH"
            );

            require(
                data.path[data.path.length - 1] == address(toToken),
                "last element in path must be toToken"
            );

            IUniswapRouter(exchange).swapETHForExactTokens.value(fromAmount)(
                toAmount,
                data.path,
                address(this),
                now
            );
        }
        else if (address(toToken) == Utils.ethAddress()) {
            require(
                data.path[0] == address(fromToken),
                "First element in path must be fromToken"
            );

            require(
                data.path[data.path.length - 1] == weth,
                "last element in path must be weth"
            );
            IUniswapRouter(exchange).swapTokensForExactETH(
                toAmount,
                fromAmount,
                data.path,
                address(this),
                now
            );
        }
        else {
            require(
                data.path[0] == address(fromToken),
                "First element in path must be fromToken"
            );

            require(
                data.path[data.path.length - 1] == address(toToken),
                "last element in path must be toToken"
            );
            IUniswapRouter(exchange).swapTokensForExactTokens(
                toAmount,
                fromAmount,
                data.path,
                address(this),
                now
            );
        }

        uint256 remainingAmount = Utils.tokenBalance(
          address(fromToken),
          address(this)
        );
        uint256 receivedAmount = Utils.tokenBalance(
          address(toToken),
          address(this)
        );

        Utils.transferTokens(address(toToken), msg.sender, receivedAmount);
        Utils.transferTokens(address(fromToken), msg.sender, remainingAmount);

        return receivedAmount;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"fromToken","type":"address"},{"internalType":"contract IERC20","name":"toToken","type":"address"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"toAmount","type":"uint256"},{"internalType":"address","name":"exchange","type":"address"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"buy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"fromToken","type":"address"},{"internalType":"contract IERC20","name":"toToken","type":"address"},{"internalType":"uint256","name":"fromAmount","type":"uint256"},{"internalType":"uint256","name":"toAmount","type":"uint256"},{"internalType":"address","name":"exchange","type":"address"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"swap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_weth","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

22316:5492:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22822:10;22865:20;22822:10;22865:18;:20::i;:::-;22843:94;;;;-1:-1:-1;;;22843:94:0;;;;;;;;;;;;;;;;;22765:180;22316:5492;22498:19;;8:9:-1;5:2;;;30:1;27;20:12;5:2;22498:19:0;;;:::i;:::-;;;;;;;;;;;;;;;;25282:2523;;;;;;;;;:::i;:::-;;;;;;;;20688:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20688:140:0;;;:::i;:::-;;19877:79;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19877:79:0;;;:::i;20243:92::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20243:92:0;;;:::i;:::-;;;;;;;;21947:227;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;21947:227:0;;;;;;;;:::i;22953:2321::-;;;;;;;;;:::i;20983:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;20983:109:0;;;;;;;;:::i;3499:422::-;3866:20;3905:8;;;3499:422::o;22498:19::-;;;-1:-1:-1;;;;;22498:19:0;;:::o;25282:2523::-;25490:7;25512:25;;:::i;:::-;25540:36;;;;25551:7;25540:36;;;25512:64;;25589:52;25611:8;25630:9;25589:13;:52::i;:::-;25680:18;:16;:18::i;:::-;-1:-1:-1;;;;;25658:40:0;25666:9;-1:-1:-1;;;;;25658:40:0;;25654:1706;;;25757:4;;25741:9;;:12;;-1:-1:-1;;;;;25757:4:0;;;;;;25741:12;;;;;;;;;;-1:-1:-1;;;;;25741:20:0;;25715:116;;;;-1:-1:-1;;;25715:116:0;;;;;;;;;25874:9;;25884:16;;-1:-1:-1;;;;;25874:51:0;;;:9;-1:-1:-1;;25884:20:0;;;25874:31;;;;;;;;;;;;-1:-1:-1;;;;;25874:51:0;;25848:149;;;;-1:-1:-1;;;25848:149:0;;;;;;;;;26124:9;;26014:188;;-1:-1:-1;;;26014:188:0;;-1:-1:-1;;;;;26014:46:0;;;;;26067:10;;26014:188;;26097:8;;26124:9;26160:4;;26184:3;;26014:188;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;26014:188:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26014:188:0;;;;;;;39:16:-1;36:1;17:17;2:54;101:4;26014:188:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;26014:188:0;;;;;;;;;;25654:1706;;;26253:18;:16;:18::i;:::-;-1:-1:-1;;;;;26233:38:0;26241:7;-1:-1:-1;;;;;26233:38:0;;26229:1131;;;26338:9;-1:-1:-1;;;;;26314:34:0;:4;:9;;;26324:1;26314:12;;;;;;;;;;;;;;-1:-1:-1;;;;;26314:34:0;;26288:135;;;;-1:-1:-1;;;26288:135:0;;;;;;;;;26501:4;;26466:9;;26476:16;;-1:-1:-1;;;;;26501:4:0;;;;-1:-1:-1;;26476:20:0;;;26466:31;;;;;;;;;;;;-1:-1:-1;;;;;26466:39:0;;26440:134;;;;-1:-1:-1;;;26440:134:0;;;;;;;;;26710:9;;26589:199;;-1:-1:-1;;;26589:199:0;;-1:-1:-1;;;;;26589:46:0;;;;;:199;;26654:8;;26681:10;;26710:9;26746:4;;26770:3;;26589:199;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;26589:199:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26589:199:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;26589:199:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;26589:199:0;;;;;;;;26229:1131;26880:9;-1:-1:-1;;;;;26856:34:0;:4;:9;;;26866:1;26856:12;;;;;;;;;;;;;;-1:-1:-1;;;;;26856:34:0;;26830:135;;;;-1:-1:-1;;;26830:135:0;;;;;;;;;27008:9;;27018:16;;-1:-1:-1;;;;;27008:51:0;;;:9;-1:-1:-1;;27018:20:0;;;27008:31;;;;;;;;;;;;-1:-1:-1;;;;;27008:51:0;;26982:149;;;;-1:-1:-1;;;26982:149:0;;;;;;;;;27270:9;;27146:202;;-1:-1:-1;;;27146:202:0;;-1:-1:-1;;;;;27146:49:0;;;;;:202;;27214:8;;27241:10;;27270:9;27306:4;;27330:3;;27146:202;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27146:202:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;27146:202:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;27146:202:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;27146:202:0;;;;;;;;;;26229:1131;27372:23;27398:86;27437:9;27468:4;27398:18;:86::i;:::-;27372:112;;27495:22;27520:84;27559:7;27588:4;27520:18;:84::i;:::-;27495:109;;27617:66;27646:7;27656:10;27668:14;27617:20;:66::i;:::-;27694:69;27723:9;27735:10;27747:15;27694:20;:69::i;:::-;27783:14;25282:2523;-1:-1:-1;;;;;;;;;;25282:2523:0:o;20688:140::-;20089:9;:7;:9::i;:::-;20081:54;;;;-1:-1:-1;;;20081:54:0;;;;;;;;;20787:1;20771:6;;20750:40;;-1:-1:-1;;;;;20771:6:0;;;;20750:40;;20787:1;;20750:40;20818:1;20801:19;;-1:-1:-1;;;;;;20801:19:0;;;20688:140::o;19877:79::-;19915:7;19942:6;-1:-1:-1;;;;;19942:6:0;19877:79;:::o;20243:92::-;20283:4;20321:6;-1:-1:-1;;;;;20321:6:0;20307:10;:20;;20243:92::o;21947:227::-;20089:9;:7;:9::i;:::-;20081:54;;;;-1:-1:-1;;;20081:54:0;;;;;;;;;22118:48;22139:5;22146:11;22159:6;22118:20;:48::i;:::-;21947:227;;;:::o;22953:2321::-;23162:7;23184:25;;:::i;:::-;23212:36;;;;23223:7;23212:36;;;23184:64;;23261:52;23283:8;23302:9;23261:13;:52::i;:::-;23352:18;:16;:18::i;:::-;-1:-1:-1;;;;;23330:40:0;23338:9;-1:-1:-1;;;;;23330:40:0;;23326:1706;;;23429:4;;23413:9;;:12;;-1:-1:-1;;;;;23429:4:0;;;;;;23413:12;;;;;;;;;;-1:-1:-1;;;;;23413:20:0;;23387:116;;;;-1:-1:-1;;;23387:116:0;;;;;;;;;23546:9;;23556:16;;-1:-1:-1;;;;;23546:51:0;;;:9;-1:-1:-1;;23556:20:0;;;23546:31;;;;;;;;;;;;-1:-1:-1;;;;;23546:51:0;;23520:149;;;;-1:-1:-1;;;23520:149:0;;;;;;;;;23796:9;;23686:188;;-1:-1:-1;;;23686:188:0;;-1:-1:-1;;;;;23686:46:0;;;;;23739:10;;23686:188;;23769:8;;23796:9;23832:4;;23856:3;;23686:188;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23686:188:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23686:188:0;;;;;;;39:16:-1;36:1;17:17;2:54;101:4;23686:188:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;23686:188:0;;;;;;;;;;23326:1706;;;23925:18;:16;:18::i;:::-;-1:-1:-1;;;;;23905:38:0;23913:7;-1:-1:-1;;;;;23905:38:0;;23901:1131;;;24010:9;-1:-1:-1;;;;;23986:34:0;:4;:9;;;23996:1;23986:12;;;;;;;;;;;;;;-1:-1:-1;;;;;23986:34:0;;23960:135;;;;-1:-1:-1;;;23960:135:0;;;;;;;;;24173:4;;24138:9;;24148:16;;-1:-1:-1;;;;;24173:4:0;;;;-1:-1:-1;;24148:20:0;;;24138:31;;;;;;;;;;;;-1:-1:-1;;;;;24138:39:0;;24112:134;;;;-1:-1:-1;;;24112:134:0;;;;;;;;;24382:9;;24261:199;;-1:-1:-1;;;24261:199:0;;-1:-1:-1;;;;;24261:46:0;;;;;:199;;24326:10;;24355:8;;24382:9;24418:4;;24442:3;;24261:199;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24261:199:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24261:199:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;24261:199:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;24261:199:0;;;;;;;;23901:1131;24552:9;-1:-1:-1;;;;;24528:34:0;:4;:9;;;24538:1;24528:12;;;;;;;;;;;;;;-1:-1:-1;;;;;24528:34:0;;24502:135;;;;-1:-1:-1;;;24502:135:0;;;;;;;;;24680:9;;24690:16;;-1:-1:-1;;;;;24680:51:0;;;:9;-1:-1:-1;;24690:20:0;;;24680:31;;;;;;;;;;;;-1:-1:-1;;;;;24680:51:0;;24654:149;;;;-1:-1:-1;;;24654:149:0;;;;;;;;;24942:9;;24818:202;;-1:-1:-1;;;24818:202:0;;-1:-1:-1;;;;;24818:49:0;;;;;:202;;24886:10;;24915:8;;24942:9;24978:4;;25002:3;;24818:202;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24818:202:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24818:202:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;24818:202:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;24818:202:0;;;;;;;;;;23901:1131;25044:22;25069:84;25108:7;25137:4;25069:18;:84::i;:::-;25044:109;;25166:66;25195:7;25205:10;25217:14;25166:20;:66::i;:::-;25252:14;22953:2321;-1:-1:-1;;;;;;;;;22953:2321:0:o;20983:109::-;20089:9;:7;:9::i;:::-;20081:54;;;;-1:-1:-1;;;20081:54:0;;;;;;;;;21056:28;21075:8;21056:18;:28::i;:::-;20983:109;:::o;14946:403::-;-1:-1:-1;;;;;15053:20:0;;14189:42;15053:20;15049:293;;15153:49;;-1:-1:-1;;;15153:49:0;;15113:5;;15090:13;;-1:-1:-1;;;;;15153:16:0;;;;;:49;;15178:4;;15185:16;;15153:49;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15153:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15153:49:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;15153:49:0;;;;;;;;;15136:66;-1:-1:-1;15235:13:0;15223:25;;15219:112;;;15269:46;-1:-1:-1;;;;;15269:18:0;;15288:16;-1:-1:-1;;15269:46:0;:18;:46;:::i;:::-;15049:293;;;14946:403;;:::o;14786:75::-;14189:42;14786:75;:::o;15690:296::-;15807:7;-1:-1:-1;;;;;15836:20:0;;14189:42;15836:20;15832:147;;;-1:-1:-1;;;;;;15880:15:0;;;15873:22;;15832:147;15935:32;;-1:-1:-1;;;15935:32:0;;-1:-1:-1;;;;;15935:23:0;;;;;:32;;15959:7;;15935:32;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15935:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15935:32:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;15935:32:0;;;;;;;;;15928:39;;15832:147;15690:296;;;;:::o;15357:325::-;-1:-1:-1;;;;;15509:20:0;;14189:42;15509:20;15505:170;;;15546:28;;-1:-1:-1;;;;;15546:20:0;;;:28;;;;;15567:6;;15546:28;;;;15567:6;15546:20;:28;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15546:28:0;15505:170;;;15616:47;-1:-1:-1;;;;;15616:26:0;;15643:11;15656:6;15616:47;:26;:47;:::i;21198:229::-;-1:-1:-1;;;;;21272:22:0;;21264:73;;;;-1:-1:-1;;;21264:73:0;;;;;;;;;21374:6;;;21353:38;;-1:-1:-1;;;;;21353:38:0;;;;21374:6;;;21353:38;;;21402:6;:17;;-1:-1:-1;;;;;;21402:17:0;-1:-1:-1;;;;;21402:17:0;;;;;;;;;;21198:229::o;10916:621::-;11286:10;;;11285:62;;-1:-1:-1;11302:39:0;;-1:-1:-1;;;11302:39:0;;-1:-1:-1;;;;;11302:15:0;;;;;:39;;11326:4;;11333:7;;11302:39;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11302:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;11302:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;11302:39:0;;;;;;;;;:44;11285:62;11277:152;;;;-1:-1:-1;;;11277:152:0;;;;;;;;;11466:62;;11440:89;;11459:5;;-1:-1:-1;;;11489:22:0;11466:62;;11513:7;;11522:5;;11466:62;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;11466:62:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;11466:62:0;;;179:29:-1;;;;160:49;;;11440:18:0;:89::i;10520:176::-;10629:58;;10603:85;;10622:5;;-1:-1:-1;;;10652:23:0;10629:58;;10677:2;;10681:5;;10629:58;;;;12514:1114;13118:27;13126:5;-1:-1:-1;;;;;13118:25:0;;:27::i;:::-;13110:71;;;;-1:-1:-1;;;13110:71:0;;;;;;;;;13255:12;13269:23;13304:5;-1:-1:-1;;;;;13296:19:0;13316:4;13296:25;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;13254:67:0;;;;13340:7;13332:52;;;;-1:-1:-1;;;13332:52:0;;;;;;;;;13401:17;;:21;13397:224;;13543:10;13532:30;;;;;;;;;;;;;;13524:85;;;;-1:-1:-1;;;13524:85:0;;;;;;;;22316:5492;;;;;;;;;;;;;;:::o;5:130:-1:-;72:20;;97:33;72:20;97:33;;313:699;;426:3;419:4;411:6;407:17;403:27;393:2;;444:1;441;434:12;393:2;481:6;468:20;503:76;518:60;571:6;518:60;;;503:76;;;494:85;;596:5;621:6;614:5;607:21;651:4;643:6;639:17;629:27;;673:4;668:3;664:14;657:21;;726:6;773:3;765:4;757:6;753:17;748:3;744:27;741:36;738:2;;;790:1;787;780:12;738:2;815:1;800:206;825:6;822:1;819:13;800:206;;;883:3;905:37;938:3;926:10;905:37;;;893:50;;-1:-1;966:4;957:14;;;;985;;;;;847:1;840:9;800:206;;;804:14;386:626;;;;;;;;1038:722;;1166:3;1159:4;1151:6;1147:17;1143:27;1133:2;;1184:1;1181;1174:12;1133:2;1214:6;1208:13;1236:80;1251:64;1308:6;1251:64;;1236:80;1227:89;;1333:5;1358:6;1351:5;1344:21;1388:4;1380:6;1376:17;1366:27;;1410:4;1405:3;1401:14;1394:21;;1463:6;1510:3;1502:4;1494:6;1490:17;1485:3;1481:27;1478:36;1475:2;;;1527:1;1524;1517:12;1475:2;1552:1;1537:217;1562:6;1559:1;1556:13;1537:217;;;1620:3;1642:48;1686:3;1674:10;1642:48;;;1630:61;;-1:-1;1714:4;1705:14;;;;1733;;;;;1584:1;1577:9;1537:217;;1768:128;1843:13;;1861:30;1843:13;1861:30;;1917:335;;;2031:3;2024:4;2016:6;2012:17;2008:27;1998:2;;2049:1;2046;2039:12;1998:2;-1:-1;2069:20;;2109:18;2098:30;;2095:2;;;2141:1;2138;2131:12;2095:2;2175:4;2167:6;2163:17;2151:29;;2225:3;2218;2210:6;2206:16;2196:8;2192:31;2189:40;2186:2;;;2242:1;2239;2232:12;2186:2;1991:261;;;;;;2260:156;2340:20;;2365:46;2340:20;2365:46;;2460:431;;2576:4;2564:9;2559:3;2555:19;2551:30;2548:2;;;2594:1;2591;2584:12;2548:2;2612:20;2627:4;2612:20;;;2603:29;-1:-1;2682:31;;2733:18;2722:30;;2719:2;;;2765:1;2762;2755:12;2719:2;2799:70;2865:3;2856:6;2845:9;2841:22;2799:70;;;2775:95;;-1:-1;2786:5;2542:349;-1:-1;;2542:349;2898:130;2965:20;;2990:33;2965:20;2990:33;;3035:134;3113:13;;3131:33;3113:13;3131:33;;3176:241;;3280:2;3268:9;3259:7;3255:23;3251:32;3248:2;;;3296:1;3293;3286:12;3248:2;3331:1;3348:53;3393:7;3373:9;3348:53;;;3338:63;3242:175;-1:-1;;;;3242:175;3424:507;;;;3570:2;3558:9;3549:7;3545:23;3541:32;3538:2;;;3586:1;3583;3576:12;3538:2;3621:1;3638:53;3683:7;3663:9;3638:53;;;3628:63;;3600:97;3728:2;3746:61;3799:7;3790:6;3779:9;3775:22;3746:61;;;3736:71;;3707:106;3844:2;3862:53;3907:7;3898:6;3887:9;3883:22;3862:53;;;3852:63;;3823:98;3532:399;;;;;;3938:392;;4078:2;4066:9;4057:7;4053:23;4049:32;4046:2;;;4094:1;4091;4084:12;4046:2;4129:24;;4173:18;4162:30;;4159:2;;;4205:1;4202;4195:12;4159:2;4225:89;4306:7;4297:6;4286:9;4282:22;4225:89;;4337:257;;4449:2;4437:9;4428:7;4424:23;4420:32;4417:2;;;4465:1;4462;4455:12;4417:2;4500:1;4517:61;4570:7;4550:9;4517:61;;4601:1045;;;;;;;;4835:3;4823:9;4814:7;4810:23;4806:33;4803:2;;;4852:1;4849;4842:12;4803:2;4887:1;4904:66;4962:7;4942:9;4904:66;;;4894:76;;4866:110;5007:2;5025:66;5083:7;5074:6;5063:9;5059:22;5025:66;;;5015:76;;4986:111;5128:2;5146:53;5191:7;5182:6;5171:9;5167:22;5146:53;;;5136:63;;5107:98;5236:2;5254:53;5299:7;5290:6;5279:9;5275:22;5254:53;;;5244:63;;5215:98;5344:3;5363:53;5408:7;5399:6;5388:9;5384:22;5363:53;;;5353:63;;5323:99;5481:3;5470:9;5466:19;5453:33;5506:18;5498:6;5495:30;5492:2;;;5538:1;5535;5528:12;5492:2;5566:64;5622:7;5613:6;5602:9;5598:22;5566:64;;;5556:74;;;;5432:204;4797:849;;;;;;;;;;;5653:381;;5784:2;5772:9;5763:7;5759:23;5755:32;5752:2;;;5800:1;5797;5790:12;5752:2;5835:31;;5886:18;5875:30;;5872:2;;;5918:1;5915;5908:12;5872:2;5938:80;6010:7;6001:6;5990:9;5986:22;5938:80;;6041:263;;6156:2;6144:9;6135:7;6131:23;6127:32;6124:2;;;6172:1;6169;6162:12;6124:2;6207:1;6224:64;6280:7;6260:9;6224:64;;6312:173;;6399:46;6441:3;6433:6;6399:46;;;-1:-1;;6474:4;6465:14;;6392:93;6493:142;6584:45;6623:5;6584:45;;;6579:3;6572:58;6566:69;;;6642:103;6715:24;6733:5;6715:24;;6903:674;;7044:50;7088:5;7044:50;;;7107:86;7186:6;7181:3;7107:86;;;7100:93;;7214:52;7260:5;7214:52;;;7286:7;7314:1;7299:256;7324:6;7321:1;7318:13;7299:256;;;7391:6;7385:13;7412:63;7471:3;7456:13;7412:63;;;7405:70;;7492:56;7541:6;7492:56;;;7482:66;-1:-1;;7346:1;7339:9;7299:256;;;-1:-1;7568:3;;7023:554;-1:-1;;;;;7023:554;7585:104;7662:21;7677:5;7662:21;;7696:356;;7824:38;7856:5;7824:38;;;7874:88;7955:6;7950:3;7874:88;;;7867:95;;7967:52;8012:6;8007:3;8000:4;7993:5;7989:16;7967:52;;;8031:16;;;;;7804:248;-1:-1;;7804:248;8060:465;;8220:67;8284:2;8279:3;8220:67;;;8320:66;8300:87;;-1:-1;;;8416:2;8407:12;;8400:88;8516:2;8507:12;;8206:319;-1:-1;;8206:319;8534:465;;8694:67;8758:2;8753:3;8694:67;;;8794:66;8774:87;;-1:-1;;;8890:2;8881:12;;8874:88;8990:2;8981:12;;8680:319;-1:-1;;8680:319;9008:364;;9168:67;9232:2;9227:3;9168:67;;;9268:66;9248:87;;9363:2;9354:12;;9154:218;-1:-1;;9154:218;9381:364;;9541:67;9605:2;9600:3;9541:67;;;9641:66;9621:87;;9736:2;9727:12;;9527:218;-1:-1;;9527:218;9754:465;;9914:67;9978:2;9973:3;9914:67;;;10014:66;9994:87;;-1:-1;;;10110:2;10101:12;;10094:88;10210:2;10201:12;;9900:319;-1:-1;;9900:319;10228:364;;10388:67;10452:2;10447:3;10388:67;;;10488:66;10468:87;;10583:2;10574:12;;10374:218;-1:-1;;10374:218;10601:465;;10761:67;10825:2;10820:3;10761:67;;;10861:66;10841:87;;-1:-1;;;10957:2;10948:12;;10941:88;11057:2;11048:12;;10747:319;-1:-1;;10747:319;11075:465;;11235:67;11299:2;11294:3;11235:67;;;11335:66;11315:87;;-1:-1;;;11431:2;11422:12;;11415:88;11531:2;11522:12;;11221:319;-1:-1;;11221:319;11549:465;;11709:67;11773:2;11768:3;11709:67;;;11809:66;11789:87;;-1:-1;;;11905:2;11896:12;;11889:88;12005:2;11996:12;;11695:319;-1:-1;;11695:319;12023:465;;12183:67;12247:2;12242:3;12183:67;;;12283:66;12263:87;;-1:-1;;;12379:2;12370:12;;12363:88;12479:2;12470:12;;12169:319;-1:-1;;12169:319;12497:364;;12657:67;12721:2;12716:3;12657:67;;;12757:66;12737:87;;12852:2;12843:12;;12643:218;-1:-1;;12643:218;12869:113;12952:24;12970:5;12952:24;;12989:262;;13133:93;13222:3;13213:6;13133:93;;;13126:100;13114:137;-1:-1;;;13114:137;13258:213;13376:2;13361:18;;13390:71;13365:9;13434:6;13390:71;;13478:324;13624:2;13609:18;;13638:71;13613:9;13682:6;13638:71;;;13720:72;13788:2;13777:9;13773:18;13764:6;13720:72;;13809:324;13955:2;13940:18;;13969:71;13944:9;14013:6;13969:71;;;14051:72;14119:2;14108:9;14104:18;14095:6;14051:72;;14140:201;14252:2;14237:18;;14266:65;14241:9;14304:6;14266:65;;14348:407;14539:2;14553:47;;;14524:18;;14614:131;14524:18;14614:131;;14762:407;14953:2;14967:47;;;14938:18;;15028:131;14938:18;15028:131;;15176:407;15367:2;15381:47;;;15352:18;;15442:131;15352:18;15442:131;;15590:407;15781:2;15795:47;;;15766:18;;15856:131;15766:18;15856:131;;16004:407;16195:2;16209:47;;;16180:18;;16270:131;16180:18;16270:131;;16418:407;16609:2;16623:47;;;16594:18;;16684:131;16594:18;16684:131;;16832:407;17023:2;17037:47;;;17008:18;;17098:131;17008:18;17098:131;;17246:407;17437:2;17451:47;;;17422:18;;17512:131;17422:18;17512:131;;17660:407;17851:2;17865:47;;;17836:18;;17926:131;17836:18;17926:131;;18074:407;18265:2;18279:47;;;18250:18;;18340:131;18250:18;18340:131;;18488:407;18679:2;18693:47;;;18664:18;;18754:131;18664:18;18754:131;;18902:213;19020:2;19005:18;;19034:71;19009:9;19078:6;19034:71;;19122:703;19378:3;19363:19;;19393:71;19367:9;19437:6;19393:71;;;19512:9;19506:4;19502:20;19497:2;19486:9;19482:18;19475:48;19537:104;19636:4;19627:6;19537:104;;;19529:112;;19652:80;19728:2;19717:9;19713:18;19704:6;19652:80;;;19743:72;19811:2;19800:9;19796:18;19787:6;19743:72;;;19349:476;;;;;;;;19832:815;20116:3;20101:19;;20131:71;20105:9;20175:6;20131:71;;;20213:72;20281:2;20270:9;20266:18;20257:6;20213:72;;;20333:9;20327:4;20323:20;20318:2;20307:9;20303:18;20296:48;20358:104;20457:4;20448:6;20358:104;;;20350:112;;20473:80;20549:2;20538:9;20534:18;20525:6;20473:80;;;20564:73;20632:3;20621:9;20617:19;20608:6;20564:73;;;20087:560;;;;;;;;;20654:256;20716:2;20710:9;20742:17;;;20817:18;20802:34;;20838:22;;;20799:62;20796:2;;;20874:1;20871;20864:12;20796:2;20890;20883:22;20694:216;;-1:-1;20694:216;20917:300;;21072:18;21064:6;21061:30;21058:2;;;21104:1;21101;21094:12;21058:2;-1:-1;21139:4;21127:17;;;21192:15;;20995:222;21535:147;21655:4;21646:14;;21603:79;21689:133;21788:12;;21759:63;22069:178;22187:19;;;22236:4;22227:14;;22180:67;22256:144;22391:3;22369:31;-1:-1;22369:31;22580:91;;22642:24;22660:5;22642:24;;22784:85;22850:13;22843:21;;22826:43;22876:104;;22951:24;22969:5;22951:24;;22987:121;-1:-1;;;;;23049:54;;23032:76;23115:72;23177:5;23160:27;23194:129;;23281:37;23312:5;23281:37;;23574:268;23639:1;23646:101;23660:6;23657:1;23654:13;23646:101;;;23727:11;;;23721:18;23708:11;;;23701:39;23682:2;23675:10;23646:101;;;23762:6;23759:1;23756:13;23753:2;;;-1:-1;;23827:1;23809:16;;23802:27;23623:219;23850:117;23919:24;23937:5;23919:24;;;23912:5;23909:35;23899:2;;23958:1;23955;23948:12;24114:111;24180:21;24195:5;24180:21;;24232:143;24314:37;24345:5;24314:37;;24382:117;24451:24;24469:5;24451:24;

bzzr://04c402ef81b52d8b286fbf9a3423ba1036c1a6326255436e1744c95935378e5f