Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•  contract ReentrancyGuard
• 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, ...
• interface IUniswapV2Factory
•    - function feeTo()
•    - function feeToSetter()
•    - function getPair(address tokenA, addr ...
•    - function allPairs(uint)
•    - function allPairsLength()
•    - function createPair(address tokenA, a ...
•    - function setFeeTo(address)
•    - function setFeeToSetter(address)
• interface IUniswapV2Router01
•    - function factory()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityWithPermit(
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokens(
•    - function swapTokensForExactTokens(
•    - function swapExactETHForTokens(uint a ...
•    - function swapTokensForExactETH(uint a ...
•    - function swapExactTokensForETH(uint a ...
•    - function swapETHForExactTokens(uint a ...
•    - function quote(uint amountA, uint res ...
•    - function getAmountOut(uint amountIn, ...
•    - function getAmountIn(uint amountOut, ...
•    - function getAmountsOut(uint amountIn, ...
•    - function getAmountsIn(uint amountOut, ...
• interface IUniswapV2Router02 is IUnis ...
•    - function removeLiquidityETHSupporting ...
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokensSupp ...
•    - function swapExactETHForTokensSupport ...
•    - function swapExactTokensForETHSupport ...
• library TransferHelper
•    - function safeApprove(address token, a ...
•    - function safeTransfer(address token, ...
•    - function safeTransferFrom(address tok ...
•    - function safeTransferETH(address to, ...
• interface IUniTradeStaker
•    - function deposit()
•  contract UniTradeIncinerator
•    - function burn()
•  contract UniTradeOrderBook is Owna ...
•    - function placeOrder(
•    - function updateOrder(
•    - function cancelOrder(uint256 orderId)
•    - function executeOrder(uint256 orderId ...
•    - function registerOrder(
•    - function proceedOrder(uint256 orderId ...
•    - function getPair(address tokenA, addr ...
•    - function getOrder(uint256 orderId)
•    - function updateStaker(IUniTradeStaker ...
•    - function updateFee(uint16 _feeMul, ui ...
•    - function updateSplit(uint16 _splitMul ...
•    - function createPair(address tokenA, a ...
•    - function getActiveOrdersLength()
•    - function getActiveOrderId(uint256 ind ...
•    - function getOrdersForAddressLength(ad ...
•    - function getOrderIdForAddress(address ...
•  contract UniTradeMarketOrders is O ... *
•    - function executeOrder(
•    - function stakeAndBurn()
•    - function createPair(address tokenA, a ...
•    - function getPair(address tokenA, addr ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-01-04
*/

// Dependency file: @openzeppelin/contracts/math/SafeMath.sol

// SPDX-License-Identifier: MIT

// pragma solidity ^0.6.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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

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

        return c;
    }

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

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


// Dependency file: @openzeppelin/contracts/GSN/Context.sol


// pragma solidity ^0.6.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 GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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


// Dependency file: @openzeppelin/contracts/access/Ownable.sol


// pragma solidity ^0.6.0;

// import "@openzeppelin/contracts/GSN/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.
 */
contract Ownable is Context {
    address private _owner;

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

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

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

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

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

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


// Dependency file: @openzeppelin/contracts/utils/ReentrancyGuard.sol


// pragma solidity ^0.6.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].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

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

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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


// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol


// pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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


// Dependency file: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol

// 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;
}


// Dependency file: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol

// pragma solidity >=0.6.2;

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

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

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


// Dependency file: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol

// pragma solidity >=0.6.2;

// import '/home/cmarcelo/git/unitrade/unitrade-contracts/node_modules/@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}


// Dependency file: @uniswap/lib/contracts/libraries/TransferHelper.sol

// pragma solidity >=0.6.0;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

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


// Dependency file: contracts/IUniTradeStaker.sol

// pragma solidity ^0.6.6;

interface IUniTradeStaker
{
    function deposit() external payable;
}


// Dependency file: contracts/UniTradeIncinerator.sol

// pragma solidity ^0.6.6;

// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
// import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

contract UniTradeIncinerator {
    using SafeMath for uint256;

    uint256 constant UINT256_MAX = ~uint256(0);
    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable unitrade;
    uint256 lastIncinerated;

    event UniTradeToBurn(uint256 etherIn);
    event UniTradeBurned(uint256 etherIn, uint256 tokensBurned);

    constructor(IUniswapV2Router02 _uniswapV2Router, address _unitrade) public {
        uniswapV2Router = _uniswapV2Router;
        unitrade = _unitrade;
        lastIncinerated = block.timestamp;
    }

    function burn() external payable returns (bool) {
        require(msg.value > 0, "Nothing to burn");

        emit UniTradeToBurn(msg.value);

        if (block.timestamp < lastIncinerated + 1 days) {
            return true;
        }

        lastIncinerated = block.timestamp;

        address[] memory _tokenPair = new address[](2);
        _tokenPair[0] = uniswapV2Router.WETH();
        _tokenPair[1] = unitrade;

        uint256[] memory _swapResult = uniswapV2Router.swapExactETHForTokens{
            value: address(this).balance
        }(
            0, // take any
            _tokenPair,
            address(this),
            UINT256_MAX
        );

        emit UniTradeBurned(_swapResult[0], _swapResult[1]);

        return true;
    }
}


// Dependency file: contracts/UniTradeOrderBook.sol

// pragma solidity ^0.6.6;

// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
// import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
// import "@uniswap/lib/contracts/libraries/TransferHelper.sol";
// import "contracts/UniTradeIncinerator.sol";
// import "contracts/IUniTradeStaker.sol";

contract UniTradeOrderBook is Ownable, ReentrancyGuard {
    using SafeMath for uint256;

    uint256 constant UINT256_MAX = ~uint256(0);
    IUniswapV2Router02 public immutable uniswapV2Router;
    IUniswapV2Factory public immutable uniswapV2Factory;
    UniTradeIncinerator public immutable incinerator;
    IUniTradeStaker public staker;
    uint16 public feeMul;
    uint16 public feeDiv;
    uint16 public splitMul;
    uint16 public splitDiv;

    enum OrderType {TokensForTokens, EthForTokens, TokensForEth}
    enum OrderState {Placed, Cancelled, Executed}

    struct Order {
        OrderType orderType;
        address payable maker;
        address tokenIn;
        address tokenOut;
        uint256 amountInOffered;
        uint256 amountOutExpected;
        uint256 executorFee;
        uint256 totalEthDeposited;
        uint256 activeOrderIndex;
        OrderState orderState;
        bool deflationary;
    }

    uint256 private orderNumber;
    uint256[] private activeOrders;
    mapping(uint256 => Order) private orders;
    mapping(address => uint256[]) private ordersForAddress;

    event OrderPlaced(
        uint256 indexed orderId,
        OrderType orderType,
        address payable indexed maker,
        address tokenIn,
        address tokenOut,
        uint256 amountInOffered,
        uint256 amountOutExpected,
        uint256 executorFee,
        uint256 totalEthDeposited
    );
    event OrderUpdated(
        uint256 indexed orderId,
        uint256 amountInOffered,
        uint256 amountOutExpected,
        uint256 executorFee
    );
    event OrderCancelled(uint256 indexed orderId);
    event OrderExecuted(
        uint256 indexed orderId,
        address indexed executor,
        uint256[] amounts,
        uint256 unitradeFee
    );
    event StakerUpdated(address newStaker);

    modifier exists(uint256 orderId) {
        require(orders[orderId].maker != address(0), "Order not found");
        _;
    }

    constructor(
        IUniswapV2Router02 _uniswapV2Router,
        UniTradeIncinerator _incinerator,
        IUniTradeStaker _staker,
        uint16 _feeMul,
        uint16 _feeDiv,
        uint16 _splitMul,
        uint16 _splitDiv
    ) public {
        uniswapV2Router = _uniswapV2Router;
        uniswapV2Factory = IUniswapV2Factory(_uniswapV2Router.factory());
        incinerator = _incinerator;
        staker = _staker;
        feeMul = _feeMul;
        feeDiv = _feeDiv;
        splitMul = _splitMul;
        splitDiv = _splitDiv;
    }

    function placeOrder(
        OrderType orderType,
        address tokenIn,
        address tokenOut,
        uint256 amountInOffered,
        uint256 amountOutExpected,
        uint256 executorFee
    ) external payable nonReentrant returns (uint256) {
        require(amountInOffered > 0, "Invalid offered amount");
        require(amountOutExpected > 0, "Invalid expected amount");
        require(executorFee > 0, "Invalid executor fee");

        address _wethAddress = uniswapV2Router.WETH();
        bool deflationary = false;

        if (orderType != OrderType.EthForTokens) {
            require(
                msg.value == executorFee,
                "Transaction value must match executor fee"
            );
            if (orderType == OrderType.TokensForEth) {
                require(tokenOut == _wethAddress, "Token out must be WETH");
            } else {
                getPair(tokenIn, _wethAddress);
            }
            uint256 beforeBalance = IERC20(tokenIn).balanceOf(address(this));
            // transfer tokenIn funds in necessary for order execution
            TransferHelper.safeTransferFrom(
                tokenIn,
                msg.sender,
                address(this),
                amountInOffered
            );
            uint256 afterBalance = IERC20(tokenIn).balanceOf(address(this));
            if (afterBalance.sub(beforeBalance) != amountInOffered) {
                amountInOffered = afterBalance.sub(beforeBalance);
                deflationary = true;
            }
            require(amountInOffered > 0, "Invalid final offered amount");
        } else {
            require(tokenIn == _wethAddress, "Token in must be WETH");
            require(
                msg.value == amountInOffered.add(executorFee),
                "Transaction value must match offer and fee"
            );
        }

        // get canonical uniswap pair address
        address _pairAddress = getPair(tokenIn, tokenOut);

        (uint256 _orderId, Order memory _order) = registerOrder(
            orderType,
            msg.sender,
            tokenIn,
            tokenOut,
            _pairAddress,
            amountInOffered,
            amountOutExpected,
            executorFee,
            msg.value,
            deflationary
        );

        emit OrderPlaced(
            _orderId,
            _order.orderType,
            _order.maker,
            _order.tokenIn,
            _order.tokenOut,
            _order.amountInOffered,
            _order.amountOutExpected,
            _order.executorFee,
            _order.totalEthDeposited
        );

        return _orderId;
    }

    function updateOrder(
        uint256 orderId,
        uint256 amountInOffered,
        uint256 amountOutExpected,
        uint256 executorFee
    ) external payable exists(orderId) nonReentrant returns (bool) {
        Order memory _updatingOrder = orders[orderId];
        require(msg.sender == _updatingOrder.maker, "Permission denied");
        require(
            _updatingOrder.orderState == OrderState.Placed,
            "Cannot update order"
        );
        require(amountInOffered > 0, "Invalid offered amount");
        require(amountOutExpected > 0, "Invalid expected amount");
        require(executorFee > 0, "Invalid executor fee");

        if (_updatingOrder.orderType == OrderType.EthForTokens) {
            uint256 newTotal = amountInOffered.add(executorFee);
            if (newTotal > _updatingOrder.totalEthDeposited) {
                require(
                    msg.value == newTotal.sub(_updatingOrder.totalEthDeposited),
                    "Additional deposit must match"
                );
            } else if (newTotal < _updatingOrder.totalEthDeposited) {
                TransferHelper.safeTransferETH(
                    _updatingOrder.maker,
                    _updatingOrder.totalEthDeposited.sub(newTotal)
                );
            }
            _updatingOrder.totalEthDeposited = newTotal;
        } else {
            if (executorFee > _updatingOrder.executorFee) {
                require(
                    msg.value == executorFee.sub(_updatingOrder.executorFee),
                    "Additional fee must match"
                );
            } else if (executorFee < _updatingOrder.executorFee) {
                TransferHelper.safeTransferETH(
                    _updatingOrder.maker,
                    _updatingOrder.executorFee.sub(executorFee)
                );
            }
            _updatingOrder.totalEthDeposited = executorFee;
            if (amountInOffered > _updatingOrder.amountInOffered) {
                uint256 beforeBalance = IERC20(_updatingOrder.tokenIn)
                    .balanceOf(address(this));
                TransferHelper.safeTransferFrom(
                    _updatingOrder.tokenIn,
                    msg.sender,
                    address(this),
                    amountInOffered.sub(_updatingOrder.amountInOffered)
                );
                uint256 afterBalance = IERC20(_updatingOrder.tokenIn).balanceOf(
                    address(this)
                );
                amountInOffered = _updatingOrder.amountInOffered.add(
                    afterBalance.sub(beforeBalance)
                );
            } else if (amountInOffered < _updatingOrder.amountInOffered) {
                TransferHelper.safeTransfer(
                    _updatingOrder.tokenIn,
                    _updatingOrder.maker,
                    _updatingOrder.amountInOffered.sub(amountInOffered)
                );
            }
        }

        // update order record
        _updatingOrder.amountInOffered = amountInOffered;
        _updatingOrder.amountOutExpected = amountOutExpected;
        _updatingOrder.executorFee = executorFee;
        orders[orderId] = _updatingOrder;

        emit OrderUpdated(
            orderId,
            amountInOffered,
            amountOutExpected,
            executorFee
        );

        return true;
    }

    function cancelOrder(uint256 orderId)
        external
        exists(orderId)
        nonReentrant
        returns (bool)
    {
        Order memory _cancellingOrder = orders[orderId];
        require(msg.sender == _cancellingOrder.maker, "Permission denied");
        require(
            _cancellingOrder.orderState == OrderState.Placed,
            "Cannot cancel order"
        );

        proceedOrder(orderId, OrderState.Cancelled);

        // Revert token allocation, funds, and fees
        if (_cancellingOrder.orderType != OrderType.EthForTokens) {
            TransferHelper.safeTransfer(
                _cancellingOrder.tokenIn,
                _cancellingOrder.maker,
                _cancellingOrder.amountInOffered
            );
        }

        TransferHelper.safeTransferETH(
            _cancellingOrder.maker,
            _cancellingOrder.totalEthDeposited
        );

        emit OrderCancelled(orderId);
        return true;
    }

    function executeOrder(uint256 orderId)
        external
        exists(orderId)
        nonReentrant
        returns (uint256[] memory amounts)
    {
        Order memory _executingOrder = orders[orderId];
        require(
            _executingOrder.orderState == OrderState.Placed,
            "Cannot execute order"
        );

        proceedOrder(orderId, OrderState.Executed);

        address[] memory _addressPair = createPair(
            _executingOrder.tokenIn,
            _executingOrder.tokenOut
        );
        uint256 unitradeFee = 0;

        if (_executingOrder.orderType == OrderType.TokensForTokens) {
            TransferHelper.safeApprove(
                _executingOrder.tokenIn,
                address(uniswapV2Router),
                _executingOrder.amountInOffered
            );
            uint256 _tokenFee = _executingOrder.amountInOffered.mul(feeMul).div(
                feeDiv
            );
            if (_executingOrder.deflationary) {
                uint256 beforeBalance = IERC20(_executingOrder.tokenOut)
                    .balanceOf(_executingOrder.maker);
                uniswapV2Router
                    .swapExactTokensForTokensSupportingFeeOnTransferTokens(
                    _executingOrder.amountInOffered.sub(_tokenFee),
                    _executingOrder.amountOutExpected,
                    _addressPair,
                    _executingOrder.maker,
                    UINT256_MAX
                );
                uint256 afterBalance = IERC20(_executingOrder.tokenOut)
                    .balanceOf(_executingOrder.maker);
                amounts = new uint256[](2);
                amounts[0] = _executingOrder.amountInOffered.sub(_tokenFee);
                amounts[1] = afterBalance.sub(beforeBalance);
            } else {
                amounts = uniswapV2Router.swapExactTokensForTokens(
                    _executingOrder.amountInOffered.sub(_tokenFee),
                    _executingOrder.amountOutExpected,
                    _addressPair,
                    _executingOrder.maker,
                    UINT256_MAX
                );
            }

            if (_tokenFee > 0) {
                // Convert x% of tokens to ETH as fee
                address[] memory _wethPair = createPair(
                    _executingOrder.tokenIn,
                    uniswapV2Router.WETH()
                );
                if (_executingOrder.deflationary) {
                    uint256 beforeBalance = IERC20(uniswapV2Router.WETH())
                        .balanceOf(address(this));
                    uniswapV2Router
                        .swapExactTokensForETHSupportingFeeOnTransferTokens(
                        _tokenFee,
                        0, //take any
                        _wethPair,
                        address(this),
                        UINT256_MAX
                    );
                    uint256 afterBalance = IERC20(uniswapV2Router.WETH())
                        .balanceOf(address(this));
                    unitradeFee = afterBalance.sub(beforeBalance);
                } else {
                    uint256[] memory _ethSwapResult = uniswapV2Router
                        .swapExactTokensForETH(
                        _tokenFee,
                        0, //take any
                        _wethPair,
                        address(this),
                        UINT256_MAX
                    );
                    unitradeFee = _ethSwapResult[1];
                }
            }
        } else if (_executingOrder.orderType == OrderType.TokensForEth) {
            TransferHelper.safeApprove(
                _executingOrder.tokenIn,
                address(uniswapV2Router),
                _executingOrder.amountInOffered
            );
            if (_executingOrder.deflationary) {
                uint256 beforeBalance = address(this).balance;
                uniswapV2Router
                    .swapExactTokensForETHSupportingFeeOnTransferTokens(
                    _executingOrder.amountInOffered,
                    _executingOrder.amountOutExpected,
                    _addressPair,
                    address(this),
                    UINT256_MAX
                );
                uint256 afterBalance = address(this).balance;
                amounts = new uint256[](2);
                amounts[0] = _executingOrder.amountInOffered;
                amounts[1] = afterBalance.sub(beforeBalance);
            } else {
                amounts = uniswapV2Router.swapExactTokensForETH(
                    _executingOrder.amountInOffered,
                    _executingOrder.amountOutExpected,
                    _addressPair,
                    address(this),
                    UINT256_MAX
                );
            }

            unitradeFee = amounts[1].mul(feeMul).div(feeDiv);
            if (amounts[1].sub(unitradeFee) > 0) {
                // Transfer to maker after post swap fee split
                TransferHelper.safeTransferETH(
                    _executingOrder.maker,
                    amounts[1].sub(unitradeFee)
                );
            }
        } else if (_executingOrder.orderType == OrderType.EthForTokens) {
            // Subtract fee from initial swap
            uint256 amountEthOffered = _executingOrder.totalEthDeposited.sub(
                _executingOrder.executorFee
            );
            unitradeFee = amountEthOffered.mul(feeMul).div(feeDiv);

            uint256 beforeBalance = IERC20(_executingOrder.tokenOut).balanceOf(
                _executingOrder.maker
            );
            uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{
                value: amountEthOffered.sub(unitradeFee)
            }(
                _executingOrder.amountOutExpected,
                _addressPair,
                _executingOrder.maker,
                UINT256_MAX
            );
            uint256 afterBalance = IERC20(_executingOrder.tokenOut).balanceOf(
                _executingOrder.maker
            );
            amounts = new uint256[](2);
            amounts[0] = amountEthOffered.sub(unitradeFee);
            amounts[1] = afterBalance.sub(beforeBalance);
        }

        // Transfer fee to incinerator/staker
        if (unitradeFee > 0) {
            uint256 burnAmount = unitradeFee.mul(splitMul).div(splitDiv);
            if (burnAmount > 0) {
                incinerator.burn{value: burnAmount}(); //no require
            }
            staker.deposit{value: unitradeFee.sub(burnAmount)}(); //no require
        }

        // transfer fee to executor
        TransferHelper.safeTransferETH(msg.sender, _executingOrder.executorFee);

        emit OrderExecuted(orderId, msg.sender, amounts, unitradeFee);
    }

    function registerOrder(
        OrderType orderType,
        address payable maker,
        address tokenIn,
        address tokenOut,
        address pairAddress,
        uint256 amountInOffered,
        uint256 amountOutExpected,
        uint256 executorFee,
        uint256 totalEthDeposited,
        bool deflationary
    ) internal returns (uint256 orderId, Order memory) {
        uint256 _orderId = orderNumber;
        orderNumber++;

        // create order entries
        Order memory _order = Order({
            orderType: orderType,
            maker: maker,
            tokenIn: tokenIn,
            tokenOut: tokenOut,
            amountInOffered: amountInOffered,
            amountOutExpected: amountOutExpected,
            executorFee: executorFee,
            totalEthDeposited: totalEthDeposited,
            activeOrderIndex: activeOrders.length,
            orderState: OrderState.Placed,
            deflationary: deflationary
        });

        activeOrders.push(_orderId);
        orders[_orderId] = _order;
        ordersForAddress[maker].push(_orderId);
        ordersForAddress[pairAddress].push(_orderId);

        return (_orderId, _order);
    }

    function proceedOrder(uint256 orderId, OrderState nextState)
        internal
        returns (bool)
    {
        Order memory _proceedingOrder = orders[orderId];
        require(
            _proceedingOrder.orderState == OrderState.Placed,
            "Cannot proceed order"
        );

        if (activeOrders.length > 1) {
            uint256 _availableIndex = _proceedingOrder.activeOrderIndex;
            uint256 _lastOrderId = activeOrders[activeOrders.length - 1];
            Order memory _lastOrder = orders[_lastOrderId];
            _lastOrder.activeOrderIndex = _availableIndex;
            orders[_lastOrderId] = _lastOrder;
            activeOrders[_availableIndex] = _lastOrderId;
        }

        activeOrders.pop();
        _proceedingOrder.orderState = nextState;
        _proceedingOrder.activeOrderIndex = UINT256_MAX; // indicate that it's not active
        orders[orderId] = _proceedingOrder;

        return true;
    }

    function getPair(address tokenA, address tokenB)
        internal
        view
        returns (address)
    {
        address _pairAddress = uniswapV2Factory.getPair(tokenA, tokenB);
        require(_pairAddress != address(0), "Unavailable pair address");
        return _pairAddress;
    }

    function getOrder(uint256 orderId)
        external
        view
        exists(orderId)
        returns (
            OrderType orderType,
            address payable maker,
            address tokenIn,
            address tokenOut,
            uint256 amountInOffered,
            uint256 amountOutExpected,
            uint256 executorFee,
            uint256 totalEthDeposited,
            OrderState orderState,
            bool deflationary
        )
    {
        Order memory _order = orders[orderId];
        return (
            _order.orderType,
            _order.maker,
            _order.tokenIn,
            _order.tokenOut,
            _order.amountInOffered,
            _order.amountOutExpected,
            _order.executorFee,
            _order.totalEthDeposited,
            _order.orderState,
            _order.deflationary
        );
    }

    function updateStaker(IUniTradeStaker newStaker) external onlyOwner {
        staker = newStaker;
        emit StakerUpdated(address(newStaker));
    }

    function updateFee(uint16 _feeMul, uint16 _feeDiv) external onlyOwner {
        require(_feeMul < _feeDiv, "!fee");
        feeMul = _feeMul;
        feeDiv = _feeDiv;
    }

    function updateSplit(uint16 _splitMul, uint16 _splitDiv)
        external
        onlyOwner
    {
        require(_splitMul < _splitDiv, "!split");
        splitMul = _splitMul;
        splitDiv = _splitDiv;
    }

    function createPair(address tokenA, address tokenB)
        internal
        pure
        returns (address[] memory)
    {
        address[] memory _addressPair = new address[](2);
        _addressPair[0] = tokenA;
        _addressPair[1] = tokenB;
        return _addressPair;
    }

    function getActiveOrdersLength() external view returns (uint256) {
        return activeOrders.length;
    }

    function getActiveOrderId(uint256 index) external view returns (uint256) {
        return activeOrders[index];
    }

    function getOrdersForAddressLength(address _address)
        external
        view
        returns (uint256)
    {
        return ordersForAddress[_address].length;
    }

    function getOrderIdForAddress(address _address, uint256 index)
        external
        view
        returns (uint256)
    {
        return ordersForAddress[_address][index];
    }

    receive() external payable {} // to receive ETH from Uniswap
}


// Root file: contracts/UniTradeMarketOrders.sol

pragma solidity ^0.6.6;

// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";
// import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
// import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
// import "@uniswap/lib/contracts/libraries/TransferHelper.sol";
// import "contracts/IUniTradeStaker.sol";
// import "contracts/UniTradeOrderBook.sol";


contract UniTradeMarketOrders is Ownable, ReentrancyGuard {
    using SafeMath for uint256;

    uint256 constant UINT256_MAX = ~uint256(0);
    IUniswapV2Router02 public immutable uniswapV2Router;
    IUniswapV2Factory public immutable uniswapV2Factory;
    UniTradeOrderBook public immutable orderBook;

    enum OrderType {TokensForTokens, EthForTokens, TokensForEth}

    event OrderExecuted(
        address indexed taker,
        address tokenIn,
        address tokenOut,
        uint256[] amounts,
        uint256 unitradeFee
    );

    constructor(
        UniTradeOrderBook _orderBook
    ) public {
        uniswapV2Router = _orderBook.uniswapV2Router();
        uniswapV2Factory = _orderBook.uniswapV2Factory();
        orderBook = _orderBook;
    }

    receive() external payable {} // to receive ETH from Uniswap

    function executeOrder(
        OrderType orderType,
        address tokenIn,
        address tokenOut,
        uint256 amountInOffered,
        uint256 amountOutExpected
    )
        external
        payable
        nonReentrant
        returns (uint256[] memory amounts)
    {       
        address _taker = msg.sender;
        address _wethAddress = uniswapV2Router.WETH();

        if (orderType != OrderType.EthForTokens) {
            if (orderType == OrderType.TokensForEth) {
                require(tokenOut == _wethAddress, "Token out must be WETH");
            } else {
                // check if pair exists
                getPair(tokenIn, _wethAddress);
            }
            uint256 beforeBalance = IERC20(tokenIn).balanceOf(address(this));
            // transfer tokenIn funds in necessary for order execution
            TransferHelper.safeTransferFrom(
                tokenIn,
                msg.sender,
                address(this),
                amountInOffered
            );
            uint256 afterBalance = IERC20(tokenIn).balanceOf(address(this));
            if (afterBalance.sub(beforeBalance) != amountInOffered) {
                amountInOffered = afterBalance.sub(beforeBalance);
            }
            require(amountInOffered > 0, "Invalid final offered amount");
        } else {
            require(tokenIn == _wethAddress, "Token in must be WETH");
        }
        
        address[] memory _addressPair = createPair(tokenIn, tokenOut);
        uint256 unitradeFee = 0;

        if (orderType != OrderType.EthForTokens) {
            TransferHelper.safeApprove(
                tokenIn,
                address(uniswapV2Router),
                amountInOffered
            );
        }

        if (orderType == OrderType.TokensForTokens) {
            // Note: Collects fee from input token then swap for ETH
            uint256 _tokenFee = amountInOffered.mul(orderBook.feeMul()).div(orderBook.feeDiv());

            uint256 beforeBalance = IERC20(tokenOut).balanceOf(_taker);
            uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
                amountInOffered.sub(_tokenFee),
                amountOutExpected,
                _addressPair,
                _taker,
                UINT256_MAX
            );
            uint256 afterBalance = IERC20(tokenOut).balanceOf(_taker);
            amounts = new uint256[](2);
            amounts[0] = amountInOffered.sub(_tokenFee);
            amounts[1] = afterBalance.sub(beforeBalance);

            if (_tokenFee > 0) {
                address[] memory _wethPair = createPair(tokenIn, uniswapV2Router.WETH());

                uint256 beforeBalance = IERC20(uniswapV2Router.WETH()).balanceOf(address(this));
                uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
                    _tokenFee,
                    0, // take any
                    _wethPair,
                    address(this),
                    UINT256_MAX
                );
                uint256 afterBalance = IERC20(uniswapV2Router.WETH()).balanceOf(address(this));
                unitradeFee = afterBalance.sub(beforeBalance);
            }
        } else if (orderType == OrderType.TokensForEth) {
            uint256 beforeBalance = address(this).balance;
            uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
                amountInOffered,
                amountOutExpected,
                _addressPair,
                address(this),
                UINT256_MAX
            );
            uint256 afterBalance = address(this).balance;
            amounts = new uint256[](2);
            amounts[0] = amountInOffered;
            amounts[1] = afterBalance.sub(beforeBalance);

            // Note: Collects ETH fee from output
            unitradeFee = amounts[1].mul(orderBook.feeMul()).div(orderBook.feeDiv());

            if (amounts[1].sub(unitradeFee) > 0) {
                // Transfer `output - fee` to the taker
                TransferHelper.safeTransferETH(
                    _taker,
                    amounts[1].sub(unitradeFee)
                );
            }
        } else if (orderType == OrderType.EthForTokens) {
            uint256 totalEthDeposited = msg.value;

            // Note: Collects ETH fee from input
            unitradeFee = totalEthDeposited.mul(orderBook.feeMul()).div(orderBook.feeDiv());

            uint256 beforeBalance = IERC20(tokenOut).balanceOf(_taker);
            uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{
                value: totalEthDeposited.sub(unitradeFee)
            }(
                amountOutExpected,
                _addressPair,
                _taker,
                UINT256_MAX
            );
            uint256 afterBalance = IERC20(tokenOut).balanceOf(_taker);
            amounts = new uint256[](2);
            amounts[0] = totalEthDeposited.sub(unitradeFee);
            amounts[1] = afterBalance.sub(beforeBalance);
        }

        emit OrderExecuted(_taker, tokenIn, tokenOut, amounts, unitradeFee);
    }

    function stakeAndBurn() external {
        // Transfer fee to incinerator/staker
        uint256 unitradeFee = address(this).balance;

        if (unitradeFee > 0) {
            uint256 burnAmount = unitradeFee.mul(orderBook.splitMul()).div(orderBook.splitDiv());
            if (burnAmount > 0) {
                orderBook.incinerator().burn{value: burnAmount}(); //no require
            }
            uint256 stakeAmount = unitradeFee.sub(burnAmount);
            if(stakeAmount > 0) {
                orderBook.staker().deposit{value: stakeAmount}(); //no require
            }
        }
    }

    function createPair(address tokenA, address tokenB)
        internal
        pure
        returns (address[] memory)
    {
        address[] memory _addressPair = new address[](2);
        _addressPair[0] = tokenA;
        _addressPair[1] = tokenB;
        return _addressPair;
    }

    function getPair(address tokenA, address tokenB)
        internal
        view
        returns (address)
    {
        address _pairAddress = uniswapV2Factory.getPair(tokenA, tokenB);
        require(_pairAddress != address(0), "Unavailable pair address");
        return _pairAddress;
    }   
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract UniTradeOrderBook","name":"_orderBook","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"taker","type":"address"},{"indexed":false,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"unitradeFee","type":"uint256"}],"name":"OrderExecuted","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"},{"inputs":[{"internalType":"enum UniTradeMarketOrders.OrderType","name":"orderType","type":"uint8"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountInOffered","type":"uint256"},{"internalType":"uint256","name":"amountOutExpected","type":"uint256"}],"name":"executeOrder","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"orderBook","outputs":[{"internalType":"contract UniTradeOrderBook","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakeAndBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Factory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x60806040526004361061007f5760003560e01c80638da5cb5b1161004e5780638da5cb5b146100fd578063a4401bd314610112578063e8b0d7bf146101a7578063f2fde38b146101bc57610086565b80631694505e1461008b57806359d0f713146100bc578063715018a6146100d1578063776af5ba146100e857610086565b3661008657005b600080fd5b34801561009757600080fd5b506100a06101ef565b604080516001600160a01b039092168252519081900360200190f35b3480156100c857600080fd5b506100a0610213565b3480156100dd57600080fd5b506100e6610237565b005b3480156100f457600080fd5b506100a06102eb565b34801561010957600080fd5b506100a061030f565b610157600480360360a081101561012857600080fd5b5060ff813516906001600160a01b0360208201358116916040810135909116906060810135906080013561031e565b60408051602080825283518183015283519192839290830191858101910280838360005b8381101561019357818101518382015260200161017b565b505050509050019250505060405180910390f35b3480156101b357600080fd5b506100e6611543565b3480156101c857600080fd5b506100e6600480360360208110156101df57600080fd5b50356001600160a01b0316611873565b7f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d81565b7f0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f81565b61023f61197d565b6000546001600160a01b039081169116146102a1576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b7f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc682881565b6000546001600160a01b031690565b606060026001541415610378576040805162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015290519081900360640190fd5b6002600181905550600033905060007f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b815260040160206040518083038186803b1580156103e057600080fd5b505afa1580156103f4573d6000803e3d6000fd5b505050506040513d602081101561040a57600080fd5b50519050600188600281111561041c57fe5b1461062457600288600281111561042f57fe5b141561049957806001600160a01b0316866001600160a01b031614610494576040805162461bcd60e51b81526020600482015260166024820152750a8ded6cadc40deeae840daeae6e840c4ca40ae8aa8960531b604482015290519081900360640190fd5b6104a5565b6104a38782611981565b505b6000876001600160a01b03166370a08231306040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b1580156104f457600080fd5b505afa158015610508573d6000803e3d6000fd5b505050506040513d602081101561051e57600080fd5b5051905061052e88333089611a94565b6000886001600160a01b03166370a08231306040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b15801561057d57600080fd5b505afa158015610591573d6000803e3d6000fd5b505050506040513d60208110156105a757600080fd5b50519050866105b68284611bf1565b146105c8576105c58183611bf1565b96505b6000871161061d576040805162461bcd60e51b815260206004820152601c60248201527f496e76616c69642066696e616c206f66666572656420616d6f756e7400000000604482015290519081900360640190fd5b5050610682565b806001600160a01b0316876001600160a01b031614610682576040805162461bcd60e51b81526020600482015260156024820152740a8ded6cadc40d2dc40daeae6e840c4ca40ae8aa89605b1b604482015290519081900360640190fd5b606061068e8888611c33565b9050600060018a60028111156106a057fe5b146106d0576106d0897f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d89611cb3565b60008a60028111156106de57fe5b1415610df85760006108177f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68286001600160a01b03166389a447e06040518163ffffffff1660e01b815260040160206040518083038186803b15801561074257600080fd5b505afa158015610756573d6000803e3d6000fd5b505050506040513d602081101561076c57600080fd5b50516040805163029f0d3d60e51b8152905161ffff90921691610811916001600160a01b037f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc682816916353e1a7a091600480820192602092909190829003018186803b1580156107da57600080fd5b505afa1580156107ee573d6000803e3d6000fd5b505050506040513d602081101561080457600080fd5b50518b9061ffff16611e1d565b90611e76565b90506000896001600160a01b03166370a08231876040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b15801561086857600080fd5b505afa15801561087c573d6000803e3d6000fd5b505050506040513d602081101561089257600080fd5b505190506001600160a01b037f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d16635c11d7956108cf8b85611bf1565b8a878a6000196040518663ffffffff1660e01b81526004018086815260200185815260200180602001846001600160a01b03168152602001838152602001828103825285818151815260200191508051906020019060200280838360005b8381101561094557818101518382015260200161092d565b505050509050019650505050505050600060405180830381600087803b15801561096e57600080fd5b505af1158015610982573d6000803e3d6000fd5b5050505060008a6001600160a01b03166370a08231886040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b1580156109d557600080fd5b505afa1580156109e9573d6000803e3d6000fd5b505050506040513d60208110156109ff57600080fd5b50516040805160028082526060820183529293509190602083019080368337019050509750610a2e8a84611bf1565b88600081518110610a3b57fe5b6020908102919091010152610a508183611bf1565b88600181518110610a5d57fe5b60209081029190910101528215610df0576060610afe8d7f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b815260040160206040518083038186803b158015610acd57600080fd5b505afa158015610ae1573d6000803e3d6000fd5b505050506040513d6020811015610af757600080fd5b5051611c33565b905060007f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b815260040160206040518083038186803b158015610b5b57600080fd5b505afa158015610b6f573d6000803e3d6000fd5b505050506040513d6020811015610b8557600080fd5b5051604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b158015610bcf57600080fd5b505afa158015610be3573d6000803e3d6000fd5b505050506040513d6020811015610bf957600080fd5b505160405163791ac94760e01b81526004810187815260006024830181905230606484018190526000196084850181905260a060448601908152885160a487015288519697506001600160a01b037f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d169663791ac947968d968b9594939092909160c40190602087810191028083838b5b83811015610ca2578181015183820152602001610c8a565b505050509050019650505050505050600060405180830381600087803b158015610ccb57600080fd5b505af1158015610cdf573d6000803e3d6000fd5b5050505060007f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663ad5c46486040518163ffffffff1660e01b815260040160206040518083038186803b158015610d3e57600080fd5b505afa158015610d52573d6000803e3d6000fd5b505050506040513d6020811015610d6857600080fd5b5051604080516370a0823160e01b815230600482015290516001600160a01b03909216916370a0823191602480820192602092909190829003018186803b158015610db257600080fd5b505afa158015610dc6573d6000803e3d6000fd5b505050506040513d6020811015610ddc57600080fd5b50519050610dea8183611bf1565b96505050505b505050611488565b60028a6002811115610e0657fe5b14156110f55760004790507f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d6001600160a01b031663791ac947898986306000196040518663ffffffff1660e01b81526004018086815260200185815260200180602001846001600160a01b03168152602001838152602001828103825285818151815260200191508051906020019060200280838360005b83811015610eb7578181015183820152602001610e9f565b505050509050019650505050505050600060405180830381600087803b158015610ee057600080fd5b505af1158015610ef4573d6000803e3d6000fd5b5050604080516002808252606082018352479450909250906020830190803683370190505096508887600081518110610f2957fe5b6020908102919091010152610f3e8183611bf1565b87600181518110610f4b57fe5b6020026020010181815250506110a37f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68286001600160a01b03166389a447e06040518163ffffffff1660e01b815260040160206040518083038186803b158015610fb357600080fd5b505afa158015610fc7573d6000803e3d6000fd5b505050506040513d6020811015610fdd57600080fd5b50516040805163029f0d3d60e51b8152905161ffff90921691610811916001600160a01b037f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc682816916353e1a7a091600480820192602092909190829003018186803b15801561104b57600080fd5b505afa15801561105f573d6000803e3d6000fd5b505050506040513d602081101561107557600080fd5b50518a5161ffff909116908b90600190811061108d57fe5b6020026020010151611e1d90919063ffffffff16565b925060006110ce84896001815181106110b857fe5b6020026020010151611bf190919063ffffffff16565b11156110ee576110ee866110e9858a6001815181106110b857fe5b611eb8565b5050611488565b60018a600281111561110357fe5b14156114885760003490506112397f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68286001600160a01b03166389a447e06040518163ffffffff1660e01b815260040160206040518083038186803b15801561116a57600080fd5b505afa15801561117e573d6000803e3d6000fd5b505050506040513d602081101561119457600080fd5b50516040805163029f0d3d60e51b8152905161ffff90921691610811916001600160a01b037f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc682816916353e1a7a091600480820192602092909190829003018186803b15801561120257600080fd5b505afa158015611216573d6000803e3d6000fd5b505050506040513d602081101561122c57600080fd5b5051849061ffff16611e1d565b91506000896001600160a01b03166370a08231876040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b15801561128a57600080fd5b505afa15801561129e573d6000803e3d6000fd5b505050506040513d60208110156112b457600080fd5b505190506001600160a01b037f0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d1663b6f9de956112f18486611bf1565b8a878a6000196040518663ffffffff1660e01b81526004018085815260200180602001846001600160a01b03168152602001838152602001828103825285818151815260200191508051906020019060200280838360005b83811015611361578181015183820152602001611349565b50505050905001955050505050506000604051808303818588803b15801561138857600080fd5b505af115801561139c573d6000803e3d6000fd5b505050505060008a6001600160a01b03166370a08231886040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b1580156113f057600080fd5b505afa158015611404573d6000803e3d6000fd5b505050506040513d602081101561141a57600080fd5b505160408051600280825260608201835292935091906020830190803683370190505097506114498385611bf1565b8860008151811061145657fe5b602090810291909101015261146b8183611bf1565b8860018151811061147857fe5b6020026020010181815250505050505b836001600160a01b03167fb33c77ce52bc04bda9ef3e22004ef86600dd72b92972a2a67d8c7016b1d67a4b8a8a888560405180856001600160a01b03168152602001846001600160a01b0316815260200180602001838152602001828103825284818151815260200191508051906020019060200280838360005b8381101561151b578181015183820152602001611503565b505050509050019550505050505060405180910390a250506001805550909695505050505050565b4780156118705760006116777f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68286001600160a01b0316637e5a71876040518163ffffffff1660e01b815260040160206040518083038186803b1580156115a857600080fd5b505afa1580156115bc573d6000803e3d6000fd5b505050506040513d60208110156115d257600080fd5b50516040805163225df8e560e21b8152905161ffff90921691610811916001600160a01b037f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68281691638977e39491600480820192602092909190829003018186803b15801561164057600080fd5b505afa158015611654573d6000803e3d6000fd5b505050506040513d602081101561166a57600080fd5b5051859061ffff16611e1d565b90508015611776577f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68286001600160a01b0316631d44810d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156116d857600080fd5b505afa1580156116ec573d6000803e3d6000fd5b505050506040513d602081101561170257600080fd5b50516040805163044df8e760e41b815290516001600160a01b03909216916344df8e70918491600480830192602092919082900301818588803b15801561174857600080fd5b505af115801561175c573d6000803e3d6000fd5b50505050506040513d602081101561177357600080fd5b50505b60006117828383611bf1565b9050801561186d577f000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc68286001600160a01b0316635ebaf1db6040518163ffffffff1660e01b815260040160206040518083038186803b1580156117e357600080fd5b505afa1580156117f7573d6000803e3d6000fd5b505050506040513d602081101561180d57600080fd5b505160408051630d0e30db60e41b815290516001600160a01b039092169163d0e30db0918491600480830192600092919082900301818588803b15801561185357600080fd5b505af1158015611867573d6000803e3d6000fd5b50505050505b50505b50565b61187b61197d565b6000546001600160a01b039081169116146118dd576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6001600160a01b0381166119225760405162461bcd60e51b81526004018080602001828103825260268152602001806120a86026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b3390565b6000807f0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f6001600160a01b031663e6a4390585856040518363ffffffff1660e01b815260040180836001600160a01b03168152602001826001600160a01b031681526020019250505060206040518083038186803b158015611a0257600080fd5b505afa158015611a16573d6000803e3d6000fd5b505050506040513d6020811015611a2c57600080fd5b505190506001600160a01b038116611a8b576040805162461bcd60e51b815260206004820152601860248201527f556e617661696c61626c65207061697220616464726573730000000000000000604482015290519081900360640190fd5b90505b92915050565b604080516001600160a01b0385811660248301528481166044830152606480830185905283518084039091018152608490920183526020820180516001600160e01b03166323b872dd60e01b17815292518251600094606094938a169392918291908083835b60208310611b195780518252601f199092019160209182019101611afa565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114611b7b576040519150601f19603f3d011682016040523d82523d6000602084013e611b80565b606091505b5091509150818015611bae575080511580611bae5750808060200190516020811015611bab57600080fd5b50515b611be95760405162461bcd60e51b81526004018080602001828103825260248152602001806121126024913960400191505060405180910390fd5b505050505050565b6000611a8b83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611fab565b6040805160028082526060808301845292839291906020830190803683370190505090508381600081518110611c6557fe5b60200260200101906001600160a01b031690816001600160a01b0316815250508281600181518110611c9357fe5b6001600160a01b0390921660209283029190910190910152905092915050565b604080516001600160a01b038481166024830152604480830185905283518084039091018152606490920183526020820180516001600160e01b031663095ea7b360e01b178152925182516000946060949389169392918291908083835b60208310611d305780518252601f199092019160209182019101611d11565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114611d92576040519150601f19603f3d011682016040523d82523d6000602084013e611d97565b606091505b5091509150818015611dc5575080511580611dc55750808060200190516020811015611dc257600080fd5b50515b611e16576040805162461bcd60e51b815260206004820152601e60248201527f5472616e7366657248656c7065723a20415050524f56455f4641494c45440000604482015290519081900360640190fd5b5050505050565b600082611e2c57506000611a8e565b82820282848281611e3957fe5b0414611a8b5760405162461bcd60e51b81526004018080602001828103825260218152602001806120ce6021913960400191505060405180910390fd5b6000611a8b83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612042565b604080516000808252602082019092526001600160a01b0384169083906040518082805190602001908083835b60208310611f045780518252601f199092019160209182019101611ee5565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d8060008114611f66576040519150601f19603f3d011682016040523d82523d6000602084013e611f6b565b606091505b505090508061186d5760405162461bcd60e51b81526004018080602001828103825260238152602001806120ef6023913960400191505060405180910390fd5b6000818484111561203a5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015611fff578181015183820152602001611fe7565b50505050905090810190601f16801561202c5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600081836120915760405162461bcd60e51b8152602060048201818152835160248401528351909283926044909101919085019080838360008315611fff578181015183820152602001611fe7565b50600083858161209d57fe5b049594505050505056fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f775472616e7366657248656c7065723a204554485f5452414e534645525f4641494c45445472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641494c4544a26469706673582212208c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b464736f6c634300060c0033

000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc6828

-----Decoded View---------------
Arg [0] : _orderBook (address): 0xC1bF1B4929DA9303773eCEa5E251fDEc22cC6828

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000c1bf1b4929da9303773ecea5e251fdec22cc6828

46657:7307:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46806:51;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;46806:51:0;;;;;;;;;;;;;;46864;;;;;;;;;;;;;:::i;8228:148::-;;;;;;;;;;;;;:::i;:::-;;46922:44;;;;;;;;;;;;;:::i;7586:79::-;;;;;;;;;;;;;:::i;47519:5213::-;;;;;;;;;;;;;;;;-1:-1:-1;47519:5213:0;;;;;-1:-1:-1;;;;;47519:5213:0;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52740:611;;;;;;;;;;;;;:::i;8531:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8531:244:0;-1:-1:-1;;;;;8531:244:0;;:::i;46806:51::-;;;:::o;46864:::-;;;:::o;8228:148::-;7808:12;:10;:12::i;:::-;7798:6;;-1:-1:-1;;;;;7798:6:0;;;:22;;;7790:67;;;;;-1:-1:-1;;;7790:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8335:1:::1;8319:6:::0;;8298:40:::1;::::0;-1:-1:-1;;;;;8319:6:0;;::::1;::::0;8298:40:::1;::::0;8335:1;;8298:40:::1;8366:1;8349:19:::0;;-1:-1:-1;;;;;;8349:19:0::1;::::0;;8228:148::o;46922:44::-;;;:::o;7586:79::-;7624:7;7651:6;-1:-1:-1;;;;;7651:6:0;7586:79;:::o;47519:5213::-;47776:24;10531:1;11137:7;;:19;;11129:63;;;;;-1:-1:-1;;;11129:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;10531:1;11270:7;:18;;;;47825:14:::1;47842:10;47825:27;;47863:20;47886:15;-1:-1:-1::0;;;;;47886:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;47886:22:0;;-1:-1:-1;47938:22:0::1;47925:9;:35;;;;;;;;;47921:1044;;47994:22;47981:9;:35;;;;;;;;;47977:247;;;48057:12;-1:-1:-1::0;;;;;48045:24:0::1;:8;-1:-1:-1::0;;;;;48045:24:0::1;;48037:59;;;::::0;;-1:-1:-1;;;48037:59:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;48037:59:0;;;;;;;;;;;;;::::1;;47977:247;;;48178:30;48186:7;48195:12;48178:7;:30::i;:::-;;47977:247;48238:21;48269:7;-1:-1:-1::0;;;;;48262:25:0::1;;48296:4;48262:40;;;;;;;;;;;;;-1:-1:-1::0;;;;;48262:40:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;48262:40:0;;-1:-1:-1;48389:167:0::1;48439:7:::0;48465:10:::1;48502:4;48526:15:::0;48389:31:::1;:167::i;:::-;48571:20;48601:7;-1:-1:-1::0;;;;;48594:25:0::1;;48628:4;48594:40;;;;;;;;;;;;;-1:-1:-1::0;;;;;48594:40:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;48594:40:0;;-1:-1:-1;48688:15:0;48653:31:::1;48594:40:::0;48670:13;48653:16:::1;:31::i;:::-;:50;48649:140;;48742:31;:12:::0;48759:13;48742:16:::1;:31::i;:::-;48724:49;;48649:140;48829:1;48811:15;:19;48803:60;;;::::0;;-1:-1:-1;;;48803:60:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;47921:1044;;;;;48915:12;-1:-1:-1::0;;;;;48904:23:0::1;:7;-1:-1:-1::0;;;;;48904:23:0::1;;48896:57;;;::::0;;-1:-1:-1;;;48896:57:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;48896:57:0;;;;;;;;;;;;;::::1;;48985:29;49017;49028:7;49037:8;49017:10;:29::i;:::-;48985:61:::0;-1:-1:-1;49057:19:0::1;49110:22;49097:9;:35;;;;;;;;;49093:212;;49149:144;49194:7;49228:15;49263;49149:26;:144::i;:::-;49334:25;49321:9;:38;;;;;;;;;49317:3328;;;49446:17;49466:63;49510:9;-1:-1:-1::0;;;;;49510:16:0::1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;49510:18:0;49486::::1;::::0;;-1:-1:-1;;;49486:18:0;;;;49466:63:::1;::::0;;::::1;::::0;:39:::1;::::0;-1:-1:-1;;;;;49486:9:0::1;:16;::::0;::::1;::::0;:18:::1;::::0;;::::1;::::0;49510::::1;::::0;49486;;;;;;;;:16;:18;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;49486:18:0;49466:15;;:39:::1;;:19;:39::i;:::-;:43:::0;::::1;:63::i;:::-;49446:83;;49546:21;49577:8;-1:-1:-1::0;;;;;49570:26:0::1;;49597:6;49570:34;;;;;;;;;;;;;-1:-1:-1::0;;;;;49570:34:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;49570:34:0;;-1:-1:-1;;;;;;49619:15:0::1;:69;;49707:30;:15:::0;49727:9;49707:19:::1;:30::i;:::-;49756:17;49792:12;49823:6;46797:1;46788:11;49619:255;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;49619:255:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49889:20;49919:8;-1:-1:-1::0;;;;;49912:26:0::1;;49939:6;49912:34;;;;;;;;;;;;;-1:-1:-1::0;;;;;49912:34:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;49912:34:0;49971:16:::1;::::0;;49985:1:::1;49971:16:::0;;;;;::::1;::::0;;49912:34;;-1:-1:-1;49971:16:0;49985:1;49971:16:::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;;49961:26:0;-1:-1:-1;50015:30:0::1;:15:::0;50035:9;50015:19:::1;:30::i;:::-;50002:7;50010:1;50002:10;;;;;;;;;::::0;;::::1;::::0;;;;;:43;50073:31:::1;:12:::0;50090:13;50073:16:::1;:31::i;:::-;50060:7;50068:1;50060:10;;;;;;;;;::::0;;::::1;::::0;;;;;:44;50125:13;;50121:661:::1;;50159:26;50188:43;50199:7;50208:15;-1:-1:-1::0;;;;;50208:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;50208:22:0;50188:10:::1;:43::i;:::-;50159:72;;50252:21;50283:15;-1:-1:-1::0;;;;;50283:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;50283:22:0;50276:55:::1;::::0;;-1:-1:-1;;;50276:55:0;;50325:4:::1;50276:55;::::0;::::1;::::0;;;-1:-1:-1;;;;;50276:40:0;;::::1;::::0;::::1;::::0;:55;;;;;50283:22:::1;::::0;50276:55;;;;;;;;:40;:55;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;50276:55:0;50350:255:::1;::::0;-1:-1:-1;;;50350:255:0;;::::1;::::0;::::1;::::0;;;50471:1:::1;50350:255:::0;;;;;;50547:4:::1;50350:255:::0;;;;;;-1:-1:-1;;50350:255:0;;;;;;;;;;;;;;;;;;;;;50276:55;;-1:-1:-1;;;;;;50350:15:0::1;:66;::::0;::::1;::::0;50439:9;;50507;;50547:4;46788:11;50350:255;;;;;;;50276:55:::1;50350:255:::0;;::::1;::::0;::::1;::::0;;;50471:1;50350:255:::1;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;50624:20;50654:15;-1:-1:-1::0;;;;;50654:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;50654:22:0;50647:55:::1;::::0;;-1:-1:-1;;;50647:55:0;;50696:4:::1;50647:55;::::0;::::1;::::0;;;-1:-1:-1;;;;;50647:40:0;;::::1;::::0;::::1;::::0;:55;;;;;50654:22:::1;::::0;50647:55;;;;;;;;:40;:55;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;50647:55:0;;-1:-1:-1;50735:31:0::1;50647:55:::0;50752:13;50735:16:::1;:31::i;:::-;50721:45;;50121:661;;;;49317:3328;;;;;;50816:22;50803:9;:35;;;;;;;;;50799:1846;;;50855:21;50879;50855:45;;50915:15;-1:-1:-1::0;;;;;50915:66:0::1;;51000:15;51034:17;51070:12;51109:4;46797:1;46788:11;50915:244;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;50915:244:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;51243:16:0::1;::::0;;51257:1:::1;51243:16:::0;;;;;::::1;::::0;;51197:21:::1;::::0;-1:-1:-1;51243:16:0;;-1:-1:-1;51257:1:0;51243:16:::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;51243:16:0::1;51233:26;;51287:15;51274:7;51282:1;51274:10;;;;;;;;;::::0;;::::1;::::0;;;;;:28;51330:31:::1;:12:::0;51347:13;51330:16:::1;:31::i;:::-;51317:7;51325:1;51317:10;;;;;;;;;;;;;:44;;;::::0;::::1;51443:58;51482:9;-1:-1:-1::0;;;;;51482:16:0::1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;51482:18:0;51458::::1;::::0;;-1:-1:-1;;;51458:18:0;;;;51443:58:::1;::::0;;::::1;::::0;:34:::1;::::0;-1:-1:-1;;;;;51458:9:0::1;:16;::::0;::::1;::::0;:18:::1;::::0;;::::1;::::0;51482::::1;::::0;51458;;;;;;;;:16;:18;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;51458:18:0;51443:10;;:34:::1;::::0;;::::1;::::0;:7;;51451:1:::1;::::0;51443:10;::::1;;;;;;;;;;;:14;;:34;;;;:::i;:58::-;51429:72;;51552:1;51522:27;51537:11;51522:7;51530:1;51522:10;;;;;;;;;;;;;;:14;;:27;;;;:::i;:::-;:31;51518:257;;;51631:128;51684:6;51713:27;51728:11;51713:7;51721:1;51713:10;;;;;;;:27;51631:30;:128::i;:::-;50799:1846;;;;;51809:22;51796:9;:35;;;;;;;;;51792:853;;;51848:25;51876:9;51848:37;;51966:65;52012:9;-1:-1:-1::0;;;;;52012:16:0::1;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;52012:18:0;51988::::1;::::0;;-1:-1:-1;;;51988:18:0;;;;51966:65:::1;::::0;;::::1;::::0;:41:::1;::::0;-1:-1:-1;;;;;51988:9:0::1;:16;::::0;::::1;::::0;:18:::1;::::0;;::::1;::::0;52012::::1;::::0;51988;;;;;;;;:16;:18;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;51988:18:0;51966:17;;:41:::1;;:21;:41::i;:65::-;51952:79;;52048:21;52079:8;-1:-1:-1::0;;;;;52072:26:0::1;;52099:6;52072:34;;;;;;;;;;;;;-1:-1:-1::0;;;;;52072:34:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;52072:34:0;;-1:-1:-1;;;;;;52121:15:0::1;:66;;52213:34;:17:::0;52235:11;52213:21:::1;:34::i;:::-;52281:17;52317:12;52348:6;46797:1;46788:11;52121:278;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;52121:278:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;52414:20;52444:8;-1:-1:-1::0;;;;;52437:26:0::1;;52464:6;52437:34;;;;;;;;;;;;;-1:-1:-1::0;;;;;52437:34:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;52437:34:0;52496:16:::1;::::0;;52510:1:::1;52496:16:::0;;;;;::::1;::::0;;52437:34;;-1:-1:-1;52496:16:0;52510:1;52496:16:::1;::::0;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;;52486:26:0;-1:-1:-1;52540:34:0::1;:17:::0;52562:11;52540:21:::1;:34::i;:::-;52527:7;52535:1;52527:10;;;;;;;;;::::0;;::::1;::::0;;;;;:47;52602:31:::1;:12:::0;52619:13;52602:16:::1;:31::i;:::-;52589:7;52597:1;52589:10;;;;;;;;;;;;;:44;;;::::0;::::1;51792:853;;;;52676:6;-1:-1:-1::0;;;;;52662:62:0::1;;52684:7;52693:8;52703:7;52712:11;52662:62;;;;-1:-1:-1::0;;;;;52662:62:0::1;;;;;;-1:-1:-1::0;;;;;52662:62:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;10487:1:0;11449:22;;-1:-1:-1;47519:5213:0;;;-1:-1:-1;;;;;;47519:5213:0:o;52740:611::-;52853:21;52891:15;;52887:457;;52923:18;52944:63;52986:9;-1:-1:-1;;;;;52986:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52986:20:0;52960;;;-1:-1:-1;;;52960:20:0;;;;52944:63;;;;;:37;;-1:-1:-1;;;;;52960:9:0;:18;;;;:20;;;;;52986;;52960;;;;;;;;:18;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52960:20:0;52944:11;;:37;;:15;:37::i;:63::-;52923:84;-1:-1:-1;53026:14:0;;53022:117;;53061:9;-1:-1:-1;;;;;53061:21:0;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53061:23:0;:49;;;-1:-1:-1;;;53061:49:0;;;;-1:-1:-1;;;;;53061:28:0;;;;;;53097:10;;53061:49;;;;;:23;;:49;;;;;;;53097:10;53061:28;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53022:117:0;53153:19;53175:27;:11;53191:10;53175:15;:27::i;:::-;53153:49;-1:-1:-1;53220:15:0;;53217:116;;53256:9;-1:-1:-1;;;;;53256:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53256:18:0;:48;;;-1:-1:-1;;;53256:48:0;;;;-1:-1:-1;;;;;53256:26:0;;;;;;53290:11;;53256:48;;;;;;;;;;;;;;53290:11;53256:26;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53217:116;52887:457;;;52740:611;:::o;8531:244::-;7808:12;:10;:12::i;:::-;7798:6;;-1:-1:-1;;;;;7798:6:0;;;:22;;;7790:67;;;;;-1:-1:-1;;;7790:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8620:22:0;::::1;8612:73;;;;-1:-1:-1::0;;;8612:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8722:6;::::0;;8701:38:::1;::::0;-1:-1:-1;;;;;8701:38:0;;::::1;::::0;8722:6;::::1;::::0;8701:38:::1;::::0;::::1;8750:6;:17:::0;;-1:-1:-1;;;;;;8750:17:0::1;-1:-1:-1::0;;;;;8750:17:0;;;::::1;::::0;;;::::1;::::0;;8531:244::o;6070:106::-;6158:10;6070:106;:::o;53659:299::-;53758:7;53783:20;53806:16;-1:-1:-1;;;;;53806:24:0;;53831:6;53839;53806:40;;;;;;;;;;;;;-1:-1:-1;;;;;53806:40:0;;;;;;-1:-1:-1;;;;;53806:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53806:40:0;;-1:-1:-1;;;;;;53865:26:0;;53857:63;;;;;-1:-1:-1;;;53857:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53938:12;-1:-1:-1;53659:299:0;;;;;:::o;21306:402::-;21531:51;;;-1:-1:-1;;;;;21531:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21531:51:0;-1:-1:-1;;;21531:51:0;;;21520:63;;;;21485:12;;21499:17;;21520:10;;;;21531:51;21520:63;;;21531:51;21520:63;;21531:51;21520:63;;;;;;;;;;-1:-1:-1;;21520:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21484:99;;;;21602:7;:57;;;;-1:-1:-1;21614:11:0;;:16;;:44;;;21645:4;21634:24;;;;;;;;;;;;;;;-1:-1:-1;21634:24:0;21614:44;21594:106;;;;-1:-1:-1;;;21594:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21306:402;;;;;;:::o;1434:136::-;1492:7;1519:43;1523:1;1526;1519:43;;;;;;;;;;;;;;;;;:3;:43::i;53359:292::-;53527:16;;;53541:1;53527:16;;;53461;53527;;;;;53461;;;53527;53541:1;53527:16;;;;;;;;;;-1:-1:-1;53527:16:0;53495:48;;53572:6;53554:12;53567:1;53554:15;;;;;;;;;;;;;:24;-1:-1:-1;;;;;53554:24:0;;;-1:-1:-1;;;;;53554:24:0;;;;;53607:6;53589:12;53602:1;53589:15;;;;;;;;-1:-1:-1;;;;;53589:24:0;;;:15;;;;;;;;;;;:24;53631:12;-1:-1:-1;53359:292:0;;;;:::o;20571:358::-;20764:45;;;-1:-1:-1;;;;;20764:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20764:45:0;-1:-1:-1;;;20764:45:0;;;20753:57;;;;20718:12;;20732:17;;20753:10;;;;20764:45;20753:57;;;20764:45;20753:57;;20764:45;20753:57;;;;;;;;;;-1:-1:-1;;20753:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20717:93;;;;20829:7;:57;;;;-1:-1:-1;20841:11:0;;:16;;:44;;;20872:4;20861:24;;;;;;;;;;;;;;;-1:-1:-1;20861:24:0;20841:44;20821:100;;;;;-1:-1:-1;;;20821:100:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;20571:358;;;;;:::o;2324:471::-;2382:7;2627:6;2623:47;;-1:-1:-1;2657:1:0;2650:8;;2623:47;2694:5;;;2698:1;2694;:5;:1;2718:5;;;;;:10;2710:56;;;;-1:-1:-1;;;2710:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3271:132;3329:7;3356:39;3360:1;3363;3356:39;;;;;;;;;;;;;;;;;:3;:39::i;21716:195::-;21824:12;;;21786;21824;;;;;;;;;-1:-1:-1;;;;;21803:7:0;;;21817:5;;21803:34;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21803:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21785:52;;;21856:7;21848:55;;;;-1:-1:-1;;;21848:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1873:192;1959:7;1995:12;1987:6;;;;1979:29;;;;-1:-1:-1;;;1979:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2031:5:0;;;1873:192::o;3899:278::-;3985:7;4020:12;4013:5;4005:28;;;;-1:-1:-1;;;4005:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4044:9;4060:1;4056;:5;;;;;;;3899:278;-1:-1:-1;;;;;3899:278:0:o

ipfs://8c475e1f184b9dfb77e3dc81e3dfa5930ac305b1d97e4341ccf595952d9ae6b4