Token

SHARE-IDOL-ETH (share)

ERC-20

Overview

Max Total Supply

11,222.39543461 share

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 8 Decimals)

0x767696e13ff990d09954c7a36a49e2c4a1c804bd

Filtered by Token Holder

0x7aA13d2cC22936538283050Ffb62BdA7Bd27911d

tokyo24.eth

Balance

362.84605753 share

Value

$0.00

0x7aA13d2cC22936538283050Ffb62BdA7Bd27911d

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

IDOLvsETHBoxExchange

Compiler Version

v0.6.6+commit.6c089d02

Optimization Enabled:

Yes with 200 runs

Other Settings:

constantinople EvmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-08-31
*/

// File: @openzeppelin/contracts/GSN/Context.sol

// SPDX-License-Identifier: MIT

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

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

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

// File: @openzeppelin/contracts/utils/Address.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// File: @openzeppelin/contracts/utils/SafeCast.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;


/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such 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.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        require(value < 2**255, "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// File: contracts/Interfaces/PriceCalculatorInterface.sol

pragma solidity >=0.6.6;

interface PriceCalculatorInterface {
    function calculatePrice(
        uint256 buyAmount,
        uint256 buyAmountLimit,
        uint256 sellAmount,
        uint256 sellAmountLimit,
        uint256 baseTokenPool,
        uint256 settlementTokenPool
    ) external view returns (uint256[5] memory);
}

// File: contracts/Libraries/Enums.sol

pragma solidity >=0.6.6;

enum Token {TOKEN0, TOKEN1}

// FLEX_0_1 => Swap TOKEN0 to TOKEN1, slippage is tolerate to 5%
// FLEX_1_0 => Swap TOKEN1 to TOKEN0, slippage is tolerate to 5%
// STRICT_0_1 => Swap TOKEN0 to TOKEN1, slippage is limited in 0.1%
// STRICT_1_0 => Swap TOKEN1 to TOKEN0, slippage is limited in 0.1%
enum OrderType {FLEX_0_1, FLEX_1_0, STRICT_0_1, STRICT_1_0}

library TokenLibrary {
    function another(Token self) internal pure returns (Token) {
        if (self == Token.TOKEN0) {
            return Token.TOKEN1;
        } else {
            return Token.TOKEN0;
        }
    }
}

library OrderTypeLibrary {
    function inToken(OrderType self) internal pure returns (Token) {
        if (self == OrderType.FLEX_0_1 || self == OrderType.STRICT_0_1) {
            return Token.TOKEN0;
        } else {
            return Token.TOKEN1;
        }
    }

    function isFlex(OrderType self) internal pure returns (bool) {
        return self == OrderType.FLEX_0_1 || self == OrderType.FLEX_1_0;
    }

    function isStrict(OrderType self) internal pure returns (bool) {
        return !isFlex(self);
    }

    function next(OrderType self) internal pure returns (OrderType) {
        return OrderType((uint256(self) + 1) % 4);
    }

    function isBuy(OrderType self) internal pure returns (bool) {
        return (self == OrderType.FLEX_0_1 || self == OrderType.STRICT_0_1);
    }
}

// File: contracts/Libraries/RateMath.sol

pragma solidity >=0.6.6;


library RateMath {
    using SafeMath for uint256;
    uint256 public constant RATE_POINT_MULTIPLIER = 1000000000000000000; // 10^18

    function getRate(uint256 a, uint256 b) internal pure returns (uint256) {
        return a.mul(RATE_POINT_MULTIPLIER).div(b);
    }

    function divByRate(uint256 self, uint256 rate)
        internal
        pure
        returns (uint256)
    {
        return self.mul(RATE_POINT_MULTIPLIER).div(rate);
    }

    function mulByRate(uint256 self, uint256 rate)
        internal
        pure
        returns (uint256)
    {
        return self.mul(rate).div(RATE_POINT_MULTIPLIER);
    }
}

// File: contracts/Libraries/ExecutionStatus.sol

pragma solidity >=0.6.6;



struct BoxExecutionStatus {
    OrderType partiallyRefundOrderType;
    uint64 partiallyRefundRate; // refundAmount/inAmount
    uint128 rate; // Token0/Token1
    uint32 boxNumber;
    bool onGoing;
}

struct BookExecutionStatus {
    OrderType executingOrderType;
    uint256 nextIndex;
}

library BoxExecutionStatusLibrary {
    using OrderTypeLibrary for OrderType;

    function refundRate(BoxExecutionStatus memory self, OrderType orderType)
        internal
        pure
        returns (uint256)
    {
        // inToken is different from refundOrderType
        if (self.partiallyRefundOrderType.inToken() != orderType.inToken()) {
            return 0;
        }

        // inToken is the same as refundOrderType
        // refund all of strict order and some of flex order
        if (self.partiallyRefundOrderType.isFlex()) {
            // orderType is flex
            if (orderType.isFlex()) {
                return self.partiallyRefundRate;
            }
            // orderType is strict
            return RateMath.RATE_POINT_MULTIPLIER;
        }

        // refund some of strict order
        if (orderType.isStrict()) {
            return self.partiallyRefundRate;
        }
        return 0;
    }
}

// File: contracts/Libraries/OrderBox.sol

pragma solidity >=0.6.6;




struct OrderBox {
    mapping(OrderType => OrderBook) orderBooks;
    uint128 spreadRate;
    uint128 expireAt;
}

struct OrderBook {
    mapping(address => uint256) inAmounts;
    address[] recipients;
    uint256 totalInAmount;
}

library OrderBoxLibrary {
    using RateMath for uint256;
    using SafeMath for uint256;
    using TokenLibrary for Token;

    function newOrderBox(uint128 spreadRate, uint128 expireAt)
        internal
        pure
        returns (OrderBox memory)
    {
        return OrderBox({spreadRate: spreadRate, expireAt: expireAt});
    }

    function addOrder(
        OrderBox storage self,
        OrderType orderType,
        uint256 inAmount,
        address recipient
    ) internal {
        OrderBook storage orderBook = self.orderBooks[orderType];
        if (orderBook.inAmounts[recipient] == 0) {
            orderBook.recipients.push(recipient);
        }
        orderBook.inAmounts[recipient] = orderBook.inAmounts[recipient].add(
            inAmount
        );
        orderBook.totalInAmount = orderBook.totalInAmount.add(inAmount);
    }
}

library OrderBookLibrary {
    function numOfOrder(OrderBook memory self) internal pure returns (uint256) {
        return self.recipients.length;
    }
}

// File: contracts/BoxExchange/BoxExchange.sol

pragma solidity ^0.6.6;

abstract contract BoxExchange is ERC20 {
    using BoxExecutionStatusLibrary for BoxExecutionStatus;
    using OrderBoxLibrary for OrderBox;
    using OrderBookLibrary for OrderBook;
    using OrderTypeLibrary for OrderType;
    using TokenLibrary for Token;
    using RateMath for uint256;
    using SafeMath for uint256;
    using SafeCast for uint256;

    uint256 internal constant MARKET_FEE_RATE = 200000000000000000; // market fee taker takes 20% of spread

    address internal immutable factory;

    address internal immutable marketFeeTaker; // Address that receives market fee (i.e. Lien Token)
    uint128 public marketFeePool0; // Total market fee in TOKEN0
    uint128 public marketFeePool1; // Total market fee in TOKEN1

    uint128 internal reserve0; // Total Liquidity of TOKEN0
    uint128 internal reserve1; // Total Liquidity of TOKEN1
    OrderBox[] internal orderBoxes; // Array of OrderBox
    PriceCalculatorInterface internal immutable priceCalc; // Price Calculator
    BoxExecutionStatus internal boxExecutionStatus; // Struct that has information about execution of current executing OrderBox
    BookExecutionStatus internal bookExecutionStatus; // Struct that has information about execution of current executing OrderBook

    event AcceptOrders(
        address indexed recipient,
        bool indexed isBuy, // if true, this order is exchange from TOKEN0 to TOKEN1
        uint32 indexed boxNumber,
        bool isLimit, // if true, this order is STRICT order
        uint256 tokenIn
    );

    event MoveLiquidity(
        address indexed liquidityProvider,
        bool indexed isAdd, // if true, this order is addtion of liquidity
        uint256 movedToken0Amount,
        uint256 movedToken1Amount,
        uint256 sharesMoved // Amount of share that is minted or burned
    );

    event Execution(
        bool indexed isBuy, // if true, this order is exchange from TOKEN0 to TOKEN1
        uint32 indexed boxNumber,
        address indexed recipient,
        uint256 orderAmount, // Amount of token that is transferred when this order is added
        uint256 refundAmount, // In the same token as orderAmount
        uint256 outAmount // In the other token than orderAmount
    );

    event UpdateReserve(uint128 reserve0, uint128 reserve1, uint256 totalShare);

    event PayMarketFee(uint256 amount0, uint256 amount1);

    event ExecutionSummary(
        uint32 indexed boxNumber,
        uint8 partiallyRefundOrderType,
        uint256 rate,
        uint256 partiallyRefundRate,
        uint256 totalInAmountFLEX_0_1,
        uint256 totalInAmountFLEX_1_0,
        uint256 totalInAmountSTRICT_0_1,
        uint256 totalInAmountSTRICT_1_0
    );

    modifier isAmountSafe(uint256 amount) {
        require(amount != 0, "Amount should be bigger than 0");
        _;
    }

    modifier isInTime(uint256 timeout) {
        require(timeout > _currentOpenBoxId(), "Time out");
        _;
    }

    constructor(
        PriceCalculatorInterface _priceCalc,
        address _marketFeeTaker,
        string memory _name
    ) public ERC20(_name, "share") {
        factory = msg.sender;
        priceCalc = _priceCalc;
        marketFeeTaker = _marketFeeTaker;
        _setupDecimals(8); // Decimal of share token is the same as iDOL, LBT, and Lien Token
    }

    /**
     * @notice Shows how many boxes and orders exist before the specific order
     * @dev If this order does not exist, return (false, 0, 0)
     * @dev If this order is already executed, return (true, 0, 0)
     * @param recipient Recipient of this order
     * @param boxNumber Box ID where the order exists
     * @param isExecuted If true, the order is already executed
     * @param boxCount Counter of boxes before this order. If current executing box number is the same as boxNumber, return 1 (i.e. indexing starts from 1)
     * @param orderCount Counter of orders before this order. If this order is on n-th top of the queue, return n (i.e. indexing starts from 1)
     **/
    function whenToExecute(
        address recipient,
        uint256 boxNumber,
        bool isBuy,
        bool isLimit
    )
        external
        view
        returns (
            bool isExecuted,
            uint256 boxCount,
            uint256 orderCount
        )
    {
        return
            _whenToExecute(recipient, _getOrderType(isBuy, isLimit), boxNumber);
    }

    /**
     * @notice Returns summary of current exchange status
     * @param boxNumber Current open box ID
     * @param _reserve0 Current reserve of TOKEN0
     * @param _reserve1 Current reserve of TOKEN1
     * @param totalShare Total Supply of share token
     * @param latestSpreadRate Spread Rate in latest OrderBox
     * @param token0PerShareE18 Amount of TOKEN0 per 1 share token and has 18 decimal
     * @param token1PerShareE18 Amount of TOKEN1 per 1 share token and has 18 decimal
     **/
    function getExchangeData()
        external
        virtual
        view
        returns (
            uint256 boxNumber,
            uint256 _reserve0,
            uint256 _reserve1,
            uint256 totalShare,
            uint256 latestSpreadRate,
            uint256 token0PerShareE18,
            uint256 token1PerShareE18
        )
    {
        boxNumber = _currentOpenBoxId();
        (_reserve0, _reserve1) = _getReserves();
        latestSpreadRate = orderBoxes[boxNumber].spreadRate;
        totalShare = totalSupply();
        token0PerShareE18 = RateMath.getRate(_reserve0, totalShare);
        token1PerShareE18 = RateMath.getRate(_reserve1, totalShare);
    }

    /**
     * @notice Gets summary of Current box information (Total order amount of each OrderTypes)
     * @param executionStatusNumber Status of execution of this box
     * @param boxNumber ID of target box.
     **/
    function getBoxSummary(uint256 boxNumber)
        public
        view
        returns (
            uint256 executionStatusNumber,
            uint256 flexToken0InAmount,
            uint256 strictToken0InAmount,
            uint256 flexToken1InAmount,
            uint256 strictToken1InAmount
        )
    {
        // `executionStatusNumber`
        // 0 => This box has not been executed
        // 1 => This box is currently executing. (Reserves and market fee pools have already been updated)
        // 2 => This box has already been executed
        uint256 nextExecutingBoxId = boxExecutionStatus.boxNumber;
        flexToken0InAmount = orderBoxes[boxNumber].orderBooks[OrderType
            .FLEX_0_1]
            .totalInAmount;
        strictToken0InAmount = orderBoxes[boxNumber].orderBooks[OrderType
            .STRICT_0_1]
            .totalInAmount;
        flexToken1InAmount = orderBoxes[boxNumber].orderBooks[OrderType
            .FLEX_1_0]
            .totalInAmount;
        strictToken1InAmount = orderBoxes[boxNumber].orderBooks[OrderType
            .STRICT_1_0]
            .totalInAmount;
        if (boxNumber < nextExecutingBoxId) {
            executionStatusNumber = 2;
        } else if (
            boxNumber == nextExecutingBoxId && boxExecutionStatus.onGoing
        ) {
            executionStatusNumber = 1;
        }
    }

    /**
     * @notice Gets amount of order in current open box
     * @param account Target Address
     * @param orderType OrderType of target order
     * @return Amount of target order
     **/
    function getOrderAmount(address account, OrderType orderType)
        public
        view
        returns (uint256)
    {
        return
            orderBoxes[_currentOpenBoxId()].orderBooks[orderType]
                .inAmounts[account];
    }

    // abstract functions
    function _feeRate() internal virtual returns (uint128);

    function _receiveTokens(
        Token token,
        address from,
        uint256 amount
    ) internal virtual;

    function _sendTokens(
        Token token,
        address to,
        uint256 amount
    ) internal virtual;

    function _payForOrderExecution(
        Token token,
        address to,
        uint256 amount
    ) internal virtual;

    function _payMarketFee(
        address _marketFeeTaker,
        uint256 amount0,
        uint256 amount1
    ) internal virtual;

    function _isCurrentOpenBoxExpired() internal virtual view returns (bool) {}

    /**
     * @notice User can determine the amount of share token to mint.
     * @dev This function can be executed only by factory
     * @param amount0 The amount of TOKEN0 to invest
     * @param amount1 The amount of TOKEN1 to invest
     * @param initialShare The amount of share token to mint. This defines approximate value of share token.
     **/
    function _init(
        uint128 amount0,
        uint128 amount1,
        uint256 initialShare
    ) internal virtual {
        require(totalSupply() == 0, "Already initialized");
        require(msg.sender == factory);
        _updateReserve(amount0, amount1);
        _mint(msg.sender, initialShare);
        _receiveTokens(Token.TOKEN0, msg.sender, amount0);
        _receiveTokens(Token.TOKEN1, msg.sender, amount1);
        _openNewBox();
    }

    /**
     * @dev Amount of share to mint is determined by `amount`
     * @param tokenType Type of token which the amount of share the LP get is calculated based on `amount`
     * @param amount The amount of token type of `tokenType`
     **/
    function _addLiquidity(
        uint256 _reserve0,
        uint256 _reserve1,
        uint256 amount,
        uint256 minShare,
        Token tokenType
    ) internal virtual {
        (uint256 amount0, uint256 amount1, uint256 share) = _calculateAmounts(
            amount,
            _reserve0,
            _reserve1,
            tokenType
        );
        require(share >= minShare, "You can't receive enough shares");
        _receiveTokens(Token.TOKEN0, msg.sender, amount0);
        _receiveTokens(Token.TOKEN1, msg.sender, amount1);
        _updateReserve(
            _reserve0.add(amount0).toUint128(),
            _reserve1.add(amount1).toUint128()
        );
        _mint(msg.sender, share);
        emit MoveLiquidity(msg.sender, true, amount0, amount1, share);
    }

    /**
     * @dev Amount of TOKEN0 and TOKEN1 is determined by amount of share to be burned
     * @param minAmount0 Minimum amount of TOKEN0 to return. If returned TOKEN0 is less than this value, revert transaction
     * @param minAmount1 Minimum amount of TOKEN1 to return. If returned TOKEN1 is less than this value, revert transaction
     * @param share Amount of share token to be burned
     **/
    function _removeLiquidity(
        uint256 minAmount0,
        uint256 minAmount1,
        uint256 share
    ) internal virtual {
        (uint256 _reserve0, uint256 _reserve1) = _getReserves(); // gas savings
        uint256 _totalSupply = totalSupply();
        uint256 amount0 = _reserve0.mul(share).div(_totalSupply);
        uint256 amount1 = _reserve1.mul(share).div(_totalSupply);
        require(
            amount0 >= minAmount0 && amount1 >= minAmount1,
            "You can't receive enough tokens"
        );
        _updateReserve(
            _reserve0.sub(amount0).toUint128(),
            _reserve1.sub(amount1).toUint128()
        );
        _burn(msg.sender, share);
        _sendTokens(Token.TOKEN0, msg.sender, amount0);
        _sendTokens(Token.TOKEN1, msg.sender, amount1);
        emit MoveLiquidity(msg.sender, false, amount0, amount1, share);
    }

    /**
     * @dev If there is some OrderBox to be executed, try execute 5 orders
     * @dev If currentBox has expired, open new box
     * @param orderType Type of order
     * @param inAmount Amount of token to be exchanged
     * @param recipient Recipient of swapped token. If this value is address(0), msg.sender is the recipient
     **/
    function _addOrder(
        OrderType orderType,
        uint256 inAmount,
        address recipient
    ) internal virtual {
        _rotateBox();
        uint256 _currentOpenBoxId = _currentOpenBoxId();
        _executeOrders(5, _currentOpenBoxId);
        if (recipient == address(0)) {
            recipient = msg.sender;
        }
        _receiveTokens(orderType.inToken(), msg.sender, inAmount);
        orderBoxes[_currentOpenBoxId].addOrder(orderType, inAmount, recipient);
        emit AcceptOrders(
            recipient,
            orderType.isBuy(),
            uint32(_currentOpenBoxId),
            orderType.isStrict(),
            inAmount
        );
    }

    /**
     * @dev Triggers executeOrders()
     * @param maxOrderNum Number of orders to execute (if no order is left, stop execution)
     **/
    function _triggerExecuteOrders(uint8 maxOrderNum) internal virtual {
        _executeOrders(maxOrderNum, _currentOpenBoxId());
    }

    /**
     * @dev Triggers PayMarketFee() and update marketFeePool to 0
     **/
    function _triggerPayMarketFee() internal virtual {
        (
            uint256 _marketFeePool0,
            uint256 _marketFeePool1
        ) = _getMarketFeePools();
        _updateMarketFeePool(0, 0);

        emit PayMarketFee(_marketFeePool0, _marketFeePool1);
        _payMarketFee(marketFeeTaker, _marketFeePool0, _marketFeePool1);
    }

    // When open new box, creates new OrderBox with spreadRate and block number of expiretion, then pushes it to orderBoxes
    function _openNewBox() internal virtual {
        orderBoxes.push(
            OrderBoxLibrary.newOrderBox(
                _feeRate(),
                (block.number + 2).toUint32()
            )
        );
    }

    function _rotateBox() private {
        // if current open box has expired
        if (_isCurrentOpenBoxExpired()) {
            _openNewBox();
        }
    }

    /**
     * @param maxOrderNum Number of orders to execute (if no order is left, stoppes execution)
     * @param _currentOpenBoxId Current box ID (_currentOpenBoxID() is already run in _addOrder() or _triggerExecuteOrders()
     **/
    function _executeOrders(uint256 maxOrderNum, uint256 _currentOpenBoxId)
        private
    {
        BoxExecutionStatus memory _boxExecutionStatus = boxExecutionStatus;
        BookExecutionStatus memory _bookExecutionStatus = bookExecutionStatus;
        // if _boxExecutionStatus.boxNumber is current open and not expired box, won't execute.
        // if _boxExecutionStatus.boxNumber is more than currentOpenBoxId, the newest box is already executed.
        if (
            _boxExecutionStatus.boxNumber >= _currentOpenBoxId &&
            (!_isCurrentOpenBoxExpired() ||
                _boxExecutionStatus.boxNumber > _currentOpenBoxId)
        ) {
            return;
        }
        if (!_boxExecutionStatus.onGoing) {
            // get rates and start new box execution
            // before start new box execution, updates reserves.
            {
                (
                    OrderType partiallyRefundOrderType,
                    uint256 partiallyRefundRate,
                    uint256 rate
                ) = _getExecutionRatesAndUpdateReserve(
                    _boxExecutionStatus.boxNumber
                );
                _boxExecutionStatus
                    .partiallyRefundOrderType = partiallyRefundOrderType;
                _boxExecutionStatus.partiallyRefundRate = partiallyRefundRate
                    .toUint64();
                _boxExecutionStatus.rate = rate.toUint128();
                _boxExecutionStatus.onGoing = true;
                _bookExecutionStatus.executingOrderType = OrderType(0);
                _bookExecutionStatus.nextIndex = 0;
            }
        }
        // execute orders in one book
        // reducing maxOrderNum to avoid stack to deep
        while (maxOrderNum != 0) {
            OrderBook storage executionBook = orderBoxes[_boxExecutionStatus
                .boxNumber]
                .orderBooks[_bookExecutionStatus.executingOrderType];
            (
                bool isBookFinished,
                uint256 nextIndex,
                uint256 executedOrderNum
            ) = _executeOrdersInBook(
                executionBook,
                _bookExecutionStatus.executingOrderType.inToken(),
                _bookExecutionStatus.nextIndex,
                _boxExecutionStatus.refundRate(
                    _bookExecutionStatus.executingOrderType
                ),
                _boxExecutionStatus.rate,
                orderBoxes[_boxExecutionStatus.boxNumber].spreadRate,
                maxOrderNum
            );
            if (isBookFinished) {
                bool isBoxFinished = _isBoxFinished(
                    orderBoxes[_boxExecutionStatus.boxNumber],
                    _bookExecutionStatus.executingOrderType
                );
                delete orderBoxes[_boxExecutionStatus.boxNumber]
                    .orderBooks[_bookExecutionStatus.executingOrderType];

                // update book execution status and box execution status
                if (isBoxFinished) {
                    _boxExecutionStatus.boxNumber += 1;
                    _boxExecutionStatus.onGoing = false;
                    boxExecutionStatus = _boxExecutionStatus;

                    return; // no need to update bookExecutionStatus;
                }
                _bookExecutionStatus.executingOrderType = _bookExecutionStatus
                    .executingOrderType
                    .next();
            }
            _bookExecutionStatus.nextIndex = nextIndex.toUint32();
            maxOrderNum -= executedOrderNum;
        }
        boxExecutionStatus = _boxExecutionStatus;
        bookExecutionStatus = _bookExecutionStatus;
    }

    /**
     * @notice Executes each OrderBook
     * @param orderBook Target OrderBook
     * @param rate Rate of swap
     * @param refundRate Refund rate in this OrderType
     * @param maxOrderNum Max number of orders to execute in this book
     * @return If execution is finished, return true
     * @return Next index to execute. If execution is finished, return 0
     * @return Number of orders executed
     **/
    function _executeOrdersInBook(
        OrderBook storage orderBook,
        Token inToken,
        uint256 initialIndex,
        uint256 refundRate,
        uint256 rate,
        uint256 spreadRate,
        uint256 maxOrderNum
    )
        private
        returns (
            bool,
            uint256,
            uint256
        )
    {
        uint256 index;
        uint256 numOfOrder = orderBook.numOfOrder();
        for (
            index = initialIndex;
            index - initialIndex < maxOrderNum;
            index++
        ) {
            if (index >= numOfOrder) {
                return (true, 0, index - initialIndex);
            }
            address recipient = orderBook.recipients[index];
            _executeOrder(
                inToken,
                recipient,
                orderBook.inAmounts[recipient],
                refundRate,
                rate,
                spreadRate
            );
        }
        if (index >= numOfOrder) {
            return (true, 0, index - initialIndex);
        }
        return (false, index, index - initialIndex);
    }

    /**
     * @dev Executes each order
     * @param inToken type of token
     * @param recipient Recipient of Token
     * @param inAmount Amount of token
     * @param refundRate Refund rate in this OrderType
     * @param rate Rate of swap
     * @param spreadRate Spread rate in this box
     **/
    function _executeOrder(
        Token inToken,
        address recipient,
        uint256 inAmount,
        uint256 refundRate,
        uint256 rate,
        uint256 spreadRate
    ) internal {
        Token outToken = inToken.another();
        // refundAmount = inAmount * refundRate
        uint256 refundAmount = inAmount.mulByRate(refundRate);
        // executingInAmountWithoutSpread = (inAmount - refundAmount) / (1+spreadRate)
        uint256 executingInAmountWithoutSpread = inAmount
            .sub(refundAmount)
            .divByRate(RateMath.RATE_POINT_MULTIPLIER.add(spreadRate));
        // spread = executingInAmountWithoutSpread * spreadRate
        // = (inAmount - refundAmount ) * ( 1 - 1 /( 1 + spreadRate))
        uint256 outAmount = _otherAmountBasedOnRate(
            inToken,
            executingInAmountWithoutSpread,
            rate
        );
        _payForOrderExecution(inToken, recipient, refundAmount);
        _payForOrderExecution(outToken, recipient, outAmount);
        emit Execution(
            (inToken == Token.TOKEN0),
            uint32(_currentOpenBoxId()),
            recipient,
            inAmount,
            refundAmount,
            outAmount
        );
    }

    /**
     * @notice Updates reserves and market fee pools
     * @param spreadRate Spread rate in the box
     * @param executingAmount0WithoutSpread Executed amount of TOKEN0 in this box
     * @param executingAmount1WithoutSpread Executed amount of TOKEN1 in this box
     * @param rate Rate of swap
     **/
    function _updateReservesAndMarketFeePoolByExecution(
        uint256 spreadRate,
        uint256 executingAmount0WithoutSpread,
        uint256 executingAmount1WithoutSpread,
        uint256 rate
    ) internal virtual {
        uint256 newReserve0;
        uint256 newReserve1;
        uint256 newMarketFeePool0;
        uint256 newMarketFeePool1;
        {
            (
                uint256 differenceOfReserve,
                uint256 differenceOfMarketFee
            ) = _calculateNewReserveAndMarketFeePool(
                spreadRate,
                executingAmount0WithoutSpread,
                executingAmount1WithoutSpread,
                rate,
                Token.TOKEN0
            );
            newReserve0 = reserve0 + differenceOfReserve;
            newMarketFeePool0 = marketFeePool0 + differenceOfMarketFee;
        }
        {
            (
                uint256 differenceOfReserve,
                uint256 differenceOfMarketFee
            ) = _calculateNewReserveAndMarketFeePool(
                spreadRate,
                executingAmount1WithoutSpread,
                executingAmount0WithoutSpread,
                rate,
                Token.TOKEN1
            );
            newReserve1 = reserve1 + differenceOfReserve;
            newMarketFeePool1 = marketFeePool1 + differenceOfMarketFee;
        }
        _updateReserve(newReserve0.toUint128(), newReserve1.toUint128());
        _updateMarketFeePool(
            newMarketFeePool0.toUint128(),
            newMarketFeePool1.toUint128()
        );
    }

    function _whenToExecute(
        address recipient,
        uint256 orderTypeCount,
        uint256 boxNumber
    )
        internal
        view
        returns (
            bool isExecuted,
            uint256 boxCount,
            uint256 orderCount
        )
    {
        if (boxNumber > _currentOpenBoxId()) {
            return (false, 0, 0);
        }
        OrderBox storage yourOrderBox = orderBoxes[boxNumber];
        address[] memory recipients = yourOrderBox.orderBooks[OrderType(
            orderTypeCount
        )]
            .recipients;
        uint256 nextExecutingBoxId = boxExecutionStatus.boxNumber;
        uint256 nextIndex = bookExecutionStatus.nextIndex;
        uint256 nextType = uint256(bookExecutionStatus.executingOrderType);
        bool onGoing = boxExecutionStatus.onGoing;
        bool isExist;
        uint256 place;
        for (uint256 j = 0; j != recipients.length; j++) {
            if (recipients[j] == recipient) {
                isExist = true;
                place = j;
                break;
            }
        }

        // If current box number exceeds boxNumber, the target box has already been executed
        // If current box number is equal to boxNumber, and OrderType or index exceeds that of the target order, the target box has already been executed
        if (
            (boxNumber < nextExecutingBoxId) ||
            ((onGoing && (boxNumber == nextExecutingBoxId)) &&
                ((orderTypeCount < nextType) ||
                    ((orderTypeCount == nextType) && (place < nextIndex))))
        ) {
            return (true, 0, 0);
        }

        if (!isExist) {
            return (false, 0, 0);
        }

        // Total number of orders before the target OrderType
        uint256 counts;
        if (boxNumber == nextExecutingBoxId && onGoing) {
            for (uint256 i = nextType; i < orderTypeCount; i++) {
                counts += yourOrderBox.orderBooks[OrderType(i)].numOfOrder();
            }
            boxCount = 1;
            orderCount = counts.add(place).sub(nextIndex) + 1;
        } else {
            for (uint256 i = 0; i != orderTypeCount; i++) {
                counts += yourOrderBox.orderBooks[OrderType(i)].numOfOrder();
            }
            boxCount = boxNumber.sub(nextExecutingBoxId) + 1;
            orderCount = counts.add(place) + 1;
        }
    }

    function _getReserves()
        internal
        view
        returns (uint256 _reserve0, uint256 _reserve1)
    {
        _reserve0 = reserve0;
        _reserve1 = reserve1;
    }

    function _getMarketFeePools()
        internal
        view
        returns (uint256 _marketFeePool0, uint256 _marketFeePool1)
    {
        _marketFeePool0 = marketFeePool0;
        _marketFeePool1 = marketFeePool1;
    }

    function _updateReserve(uint128 newReserve0, uint128 newReserve1) internal {
        reserve0 = newReserve0;
        reserve1 = newReserve1;
        emit UpdateReserve(newReserve0, newReserve1, totalSupply());
    }

    function _calculatePriceWrapper(
        uint256 flexToken0InWithoutSpread,
        uint256 strictToken0InWithoutSpread,
        uint256 flexToken1InWithoutSpread,
        uint256 strictToken1InWithoutSpread,
        uint256 _reserve0,
        uint256 _reserve1
    )
        internal
        view
        returns (
            uint256 rate,
            uint256 refundStatus,
            uint256 partiallyRefundRate,
            uint256 executingAmount0,
            uint256 executingAmount1
        )
    {
        uint256[5] memory data = priceCalc.calculatePrice(
            flexToken0InWithoutSpread,
            strictToken0InWithoutSpread,
            flexToken1InWithoutSpread,
            strictToken1InWithoutSpread,
            _reserve0,
            _reserve1
        );
        return (data[0], data[1], data[2], data[3], data[4]);
    }

    /**
     * @param rate0Per1 Token0 / Token1 * RATE_POINT_MULTIPLIER
     */
    function _otherAmountBasedOnRate(
        Token token,
        uint256 amount,
        uint256 rate0Per1
    ) internal pure returns (uint256) {
        if (token == Token.TOKEN0) {
            return amount.mulByRate(rate0Per1);
        } else {
            return amount.divByRate(rate0Per1);
        }
    }

    function _currentOpenBoxId() internal view returns (uint256) {
        return orderBoxes.length - 1;
    }

    /**
     * @notice Gets OrderType in uint
     **/
    function _getOrderType(bool isBuy, bool isLimit)
        internal
        pure
        returns (uint256 orderTypeCount)
    {
        if (isBuy && isLimit) {
            orderTypeCount = 2;
        } else if (!isBuy) {
            if (isLimit) {
                orderTypeCount = 3;
            } else {
                orderTypeCount = 1;
            }
        }
    }

    function _updateMarketFeePool(
        uint128 newMarketFeePool0,
        uint128 newMarketFeePool1
    ) private {
        marketFeePool0 = newMarketFeePool0;
        marketFeePool1 = newMarketFeePool1;
    }

    function _calculateAmounts(
        uint256 amount,
        uint256 _reserve0,
        uint256 _reserve1,
        Token tokenType
    )
        private
        view
        returns (
            uint256,
            uint256,
            uint256
        )
    {
        if (tokenType == Token.TOKEN0) {
            return (
                amount,
                amount.mul(_reserve1).div(_reserve0),
                amount.mul(totalSupply()).div(_reserve0)
            );
        } else {
            return (
                amount.mul(_reserve0).div(_reserve1),
                amount,
                amount.mul(totalSupply()).div(_reserve1)
            );
        }
    }

    function _priceCalculateRates(
        OrderBox storage orderBox,
        uint256 totalInAmountFLEX_0_1,
        uint256 totalInAmountFLEX_1_0,
        uint256 totalInAmountSTRICT_0_1,
        uint256 totalInAmountSTRICT_1_0
    )
        private
        view
        returns (
            uint256 rate,
            uint256 refundStatus,
            uint256 partiallyRefundRate,
            uint256 executingAmount0,
            uint256 executingAmount1
        )
    {
        uint256 withoutSpreadRate = RateMath.RATE_POINT_MULTIPLIER +
            orderBox.spreadRate;
        return
            _calculatePriceWrapper(
                totalInAmountFLEX_0_1.divByRate(withoutSpreadRate),
                totalInAmountSTRICT_0_1.divByRate(withoutSpreadRate),
                totalInAmountFLEX_1_0.divByRate(withoutSpreadRate),
                totalInAmountSTRICT_1_0.divByRate(withoutSpreadRate),
                reserve0,
                reserve1
            );
    }

    function _getExecutionRatesAndUpdateReserve(uint32 boxNumber)
        private
        returns (
            OrderType partiallyRefundOrderType,
            uint256 partiallyRefundRate,
            uint256 rate
        )
    {
        OrderBox storage orderBox = orderBoxes[boxNumber];
        // `refundStatus`
        // 0 => no_refund
        // 1 => refund some of strictToken0
        // 2 => refund all strictToken0 and some of flexToken0
        // 3 => refund some of strictToken1
        // 4 => refund all strictToken1 and some of flexToken1
        uint256 refundStatus;
        uint256 executingAmount0WithoutSpread;
        uint256 executingAmount1WithoutSpread;
        uint256 totalInAmountFLEX_0_1 = orderBox.orderBooks[OrderType.FLEX_0_1]
            .totalInAmount;
        uint256 totalInAmountFLEX_1_0 = orderBox.orderBooks[OrderType.FLEX_1_0]
            .totalInAmount;
        uint256 totalInAmountSTRICT_0_1 = orderBox.orderBooks[OrderType
            .STRICT_0_1]
            .totalInAmount;
        uint256 totalInAmountSTRICT_1_0 = orderBox.orderBooks[OrderType
            .STRICT_1_0]
            .totalInAmount;
        (
            rate,
            refundStatus,
            partiallyRefundRate,
            executingAmount0WithoutSpread,
            executingAmount1WithoutSpread
        ) = _priceCalculateRates(
            orderBox,
            totalInAmountFLEX_0_1,
            totalInAmountFLEX_1_0,
            totalInAmountSTRICT_0_1,
            totalInAmountSTRICT_1_0
        );

        {
            if (refundStatus == 0) {
                partiallyRefundOrderType = OrderType.STRICT_0_1;
                //refundRate = 0;
            } else if (refundStatus == 1) {
                partiallyRefundOrderType = OrderType.STRICT_0_1;
            } else if (refundStatus == 2) {
                partiallyRefundOrderType = OrderType.FLEX_0_1;
            } else if (refundStatus == 3) {
                partiallyRefundOrderType = OrderType.STRICT_1_0;
            } else if (refundStatus == 4) {
                partiallyRefundOrderType = OrderType.FLEX_1_0;
            }
        }
        emit ExecutionSummary(
            boxNumber,
            uint8(partiallyRefundOrderType),
            rate,
            partiallyRefundRate,
            totalInAmountFLEX_0_1,
            totalInAmountFLEX_1_0,
            totalInAmountSTRICT_0_1,
            totalInAmountSTRICT_1_0
        );
        _updateReservesAndMarketFeePoolByExecution(
            orderBox.spreadRate,
            executingAmount0WithoutSpread,
            executingAmount1WithoutSpread,
            rate
        );
    }

    /**
     * @notice Detects if this OrderBox is finished
     * @param orders Target OrderBox
     * @param lastFinishedOrderType Latest OrderType which is executed
     **/
    function _isBoxFinished(
        OrderBox storage orders,
        OrderType lastFinishedOrderType
    ) private view returns (bool) {
        // If orderType is STRICT_1_0, no book is left
        if (lastFinishedOrderType == OrderType.STRICT_1_0) {
            return true;
        }
        for (uint256 i = uint256(lastFinishedOrderType.next()); i != 4; i++) {
            OrderBook memory book = orders.orderBooks[OrderType(i)];
            // If OrderBook has some order return false
            if (book.numOfOrder() != 0) {
                return false;
            }
        }
        return true;
    }

    function _calculateNewReserveAndMarketFeePool(
        uint256 spreadRate,
        uint256 executingAmountWithoutSpread,
        uint256 anotherExecutingAmountWithoutSpread,
        uint256 rate,
        Token tokenType
    ) internal returns (uint256, uint256) {
        uint256 totalSpread = executingAmountWithoutSpread.mulByRate(
            spreadRate
        );
        uint256 marketFee = totalSpread.mulByRate(MARKET_FEE_RATE);
        uint256 newReserve = executingAmountWithoutSpread +
            (totalSpread - marketFee) -
            _otherAmountBasedOnRate(
                tokenType.another(),
                anotherExecutingAmountWithoutSpread,
                rate
            );
        return (newReserve, marketFee);
    }

    function _getTokenType(bool isBuy, bool isStrict)
        internal
        pure
        returns (OrderType)
    {
        if (isBuy) {
            if (isStrict) {
                return OrderType.STRICT_0_1;
            } else {
                return OrderType.FLEX_0_1;
            }
        } else {
            if (isStrict) {
                return OrderType.STRICT_1_0;
            } else {
                return OrderType.FLEX_1_0;
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

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

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: contracts/Interfaces/ERC20Interface.sol

pragma solidity >=0.6.6;


interface ERC20Interface is IERC20 {
    function name() external view returns (string memory);
}

// File: contracts/Interfaces/OracleInterface.sol

pragma solidity >=0.6.6;

interface OracleInterface {
    function latestPrice() external returns (uint256);

    function getVolatility() external returns (uint256);

    function latestId() external returns (uint256);
}

// File: contracts/Interfaces/SpreadCalculatorInterface.sol

pragma solidity >=0.6.6;


interface SpreadCalculatorInterface {
    function calculateCurrentSpread(
        uint256 _maturity,
        uint256 _strikePrice,
        OracleInterface oracle
    ) external returns (uint128);

    function calculateSpreadByAssetVolatility(OracleInterface oracle)
        external
        returns (uint128);
}

// File: contracts/BoxExchange/ETHBoxExchange/ETHBoxExchange.sol

pragma solidity >=0.6.6;






abstract contract ETHBoxExchange is BoxExchange {
    using SafeERC20 for ERC20Interface;

    ERC20Interface public immutable token; // token0
    // ETH is token1
    SpreadCalculatorInterface internal immutable spreadCalc;
    OracleInterface internal immutable oracle;

    mapping(address => uint256) internal ethBalances; // This balance increased by execution or refund

    event SpreadRate(uint128 indexed boxNumber, uint128 spreadRate);

    /**
     * @param _token ERC20 contract
     * @param _priceCalc Price Calculator contract
     * @param _marketFeeTaker Address of market fee taker (i.e. Lien Token)
     * @param _spreadCalc Spread Calculator contract
     * @param _oracle Oracle contract of token/ETH
     * @param _name Name of share token
     **/

    constructor(
        ERC20Interface _token,
        PriceCalculatorInterface _priceCalc,
        address _marketFeeTaker,
        SpreadCalculatorInterface _spreadCalc,
        OracleInterface _oracle,
        string memory _name
    ) public BoxExchange(_priceCalc, _marketFeeTaker, _name) {
        token = _token;
        spreadCalc = _spreadCalc;
        oracle = _oracle;
    }

    /**
     * @notice User can decide first supply of Share token
     **/
    function initializeExchange(uint256 tokenAmount, uint256 initialShare)
        external
        payable
    {
        _init(uint128(tokenAmount), uint128(msg.value), initialShare);
    }

    /**
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param recipient Recipient of swapped token. If recipient == address(0), recipient is msg.sender
     * @param isLimit Whether the order restricts a large slippage.
     * @dev if isLimit is true and reserve0/reserve1 * 0.999 < rate, the order will be executed, otherwise ETH will be refunded
     * @dev if isLimit is false and reserve0/reserve1 * 0.95 < rate, the order will be executed, otherwise ETH will be refunded
     **/
    function orderEthToToken(
        uint256 timeout,
        address recipient,
        bool isLimit
    ) external payable isAmountSafe(msg.value) isInTime(timeout) {
        OrderType orderType = _getTokenType(false, isLimit);
        _addOrder(orderType, msg.value, recipient);
    }

    /**
     * @param timeout Revert if nextBoxNumber exceeds timeout
     * @param recipient Recipient of swapped token. If recipient == address(0), recipient is msg.sender
     * @param tokenAmount Amount of token that should be approved before executing this function
     * @param isLimit Whether the order restricts a large slippage.
     * @dev if isLimit is true and reserve0/reserve1 * 1.001 >  `rate`, the order will be executed, otherwise token will be refunded
     * @dev if isLimit is false and reserve0/reserve1 * 1.05 > `rate`, the order will be executed, otherwise token will be refunded
     **/
    function orderTokenToEth(
        uint256 timeout,
        address recipient,
        uint256 tokenAmount,
        bool isLimit
    ) external isAmountSafe(tokenAmount) isInTime(timeout) {
        OrderType orderType = _getTokenType(true, isLimit);
        _addOrder(orderType, tokenAmount, recipient);
    }

    /**
     * @notice LP provides liquidity and receives share token.
     * @notice iDOL required is calculated based on msg.value
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param _minShares Minimum amount of share token LP will receive. If amount of share token is less than  `_minShares`, revert the transaction
     **/
    function addLiquidity(uint256 timeout, uint256 _minShares)
        external
        payable
        isAmountSafe(msg.value)
        isInTime(timeout)
    {
        (uint256 _reserve0, uint256 _reserve1) = _getReserves(); // gas savings
        _addLiquidity(
            _reserve0,
            _reserve1,
            msg.value,
            _minShares,
            Token.TOKEN1
        );
    }

    /**
     * @notice LP burns share token and receives ERC20 token and ETH.
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param minEth Minimum amount of ETH LP will receive. If amount of ERC20 token is less than `minEth`, revert the transaction
     * @param minTokens Minimum amount of ERC20 token  LP will receive. If amount of LBT is less than `minTokens`, revert the transaction
     * @param sharesBurned Amount of share token to be burned
     **/
    function removeLiquidity(
        uint256 timeout,
        uint256 minEth,
        uint256 minTokens,
        uint256 sharesBurned
    ) external isInTime(timeout) {
        _removeLiquidity(minTokens, minEth, sharesBurned);
    }

    /**
     * @notice Executes orders that are unexecuted
     * @param maxOrderNum Max number of orders to be executed
     **/
    function executeUnexecutedBox(uint8 maxOrderNum) external {
        _triggerExecuteOrders(maxOrderNum);
    }

    /**
     * @notice Sends market fee to Lien Token
     **/
    function sendMarketFeeToLien() external {
        _triggerPayMarketFee();
    }

    // definitions of unique functions
    /**
     * @notice Withdraws ETH in ethBalances and set ethBalance of msg.sender to 0
     **/
    function withdrawETH() external {
        uint256 ethBalance = ethBalances[msg.sender];
        ethBalances[msg.sender] = 0;
        _transferEth(msg.sender, ethBalance);
    }

    /**
     * @notice Gets ethBalance of `recipient`
     * @param recipient Target address
     **/
    function getETHBalance(address recipient) external view returns (uint256) {
        return ethBalances[recipient];
    }

    // definition of abstract functions
    function _feeRate() internal override returns (uint128) {
        return spreadCalc.calculateSpreadByAssetVolatility(oracle);
    }

    function _receiveTokens(
        Token tokenType,
        address from,
        uint256 amount
    ) internal override {
        if (tokenType == Token.TOKEN0) {
            token.safeTransferFrom(from, address(this), amount);
        } else {
            require(msg.value == amount, "Incorrect ETH amount");
        }
    }

    function _sendTokens(
        Token tokenType,
        address to,
        uint256 amount
    ) internal override {
        if (tokenType == Token.TOKEN0) {
            token.safeTransfer(to, amount);
        } else {
            _transferEth(to, amount);
        }
    }

    function _payMarketFee(
        address _marketFeeTaker,
        uint256 amount0,
        uint256 amount1
    ) internal override {
        if (amount0 != 0) {
            token.safeTransfer(_marketFeeTaker, amount0);
        }
        if (amount1 != 0) {
            _transferEth(_marketFeeTaker, amount1);
        }
    }

    function _payForOrderExecution(
        Token tokenType,
        address to,
        uint256 amount
    ) internal override {
        if (tokenType == Token.TOKEN0) {
            token.safeTransfer(to, amount);
        } else {
            ethBalances[to] += amount;
        }
    }

    function _isCurrentOpenBoxExpired() internal override view returns (bool) {
        return block.number >= orderBoxes[_currentOpenBoxId()].expireAt;
    }

    function _openNewBox() internal override {
        super._openNewBox();
        uint256 _boxNumber = _currentOpenBoxId();
        emit SpreadRate(
            _boxNumber.toUint128(),
            orderBoxes[_boxNumber].spreadRate
        );
    }

    function _transferEth(address to, uint256 amount) internal {
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, ) = to.call{value: amount}("");
        require(success, "Transfer failed.");
    }
}

// File: contracts/BoxExchange/ETHBoxExchange/IDOLvsETH/IDOLvsETHBoxExchange.sol

pragma solidity >=0.6.6;


contract IDOLvsETHBoxExchange is ETHBoxExchange {
    /**
     * @param _token ERC20 token contract
     * @param _priceCalc Price Calculator contract
     * @param _marketFeeTaker Address of market fee taker (i.e. Lien Token)
     * @param _spreadCalc Spread Calculator contract
     * @param _oracle Oracle contract of ETH/USD
     * @param _name Name of share token
     **/
    constructor(
        ERC20Interface _token,
        PriceCalculatorInterface _priceCalc,
        address _marketFeeTaker,
        SpreadCalculatorInterface _spreadCalc,
        OracleInterface _oracle,
        string memory _name
    )
        public
        ETHBoxExchange(
            _token,
            _priceCalc,
            _marketFeeTaker,
            _spreadCalc,
            _oracle,
            _name
        )
    {}
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"contract ERC20Interface","name":"_token","type":"address"},{"internalType":"contract PriceCalculatorInterface","name":"_priceCalc","type":"address"},{"internalType":"address","name":"_marketFeeTaker","type":"address"},{"internalType":"contract SpreadCalculatorInterface","name":"_spreadCalc","type":"address"},{"internalType":"contract OracleInterface","name":"_oracle","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"bool","name":"isBuy","type":"bool"},{"indexed":true,"internalType":"uint32","name":"boxNumber","type":"uint32"},{"indexed":false,"internalType":"bool","name":"isLimit","type":"bool"},{"indexed":false,"internalType":"uint256","name":"tokenIn","type":"uint256"}],"name":"AcceptOrders","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bool","name":"isBuy","type":"bool"},{"indexed":true,"internalType":"uint32","name":"boxNumber","type":"uint32"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"orderAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"refundAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"outAmount","type":"uint256"}],"name":"Execution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"boxNumber","type":"uint32"},{"indexed":false,"internalType":"uint8","name":"partiallyRefundOrderType","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"rate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"partiallyRefundRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalInAmountFLEX_0_1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalInAmountFLEX_1_0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalInAmountSTRICT_0_1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalInAmountSTRICT_1_0","type":"uint256"}],"name":"ExecutionSummary","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidityProvider","type":"address"},{"indexed":true,"internalType":"bool","name":"isAdd","type":"bool"},{"indexed":false,"internalType":"uint256","name":"movedToken0Amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"movedToken1Amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sharesMoved","type":"uint256"}],"name":"MoveLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"PayMarketFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint128","name":"boxNumber","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"spreadRate","type":"uint128"}],"name":"SpreadRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint128","name":"reserve0","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"reserve1","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"totalShare","type":"uint256"}],"name":"UpdateReserve","type":"event"},{"inputs":[{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"uint256","name":"_minShares","type":"uint256"}],"name":"addLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"maxOrderNum","type":"uint8"}],"name":"executeUnexecutedBox","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"boxNumber","type":"uint256"}],"name":"getBoxSummary","outputs":[{"internalType":"uint256","name":"executionStatusNumber","type":"uint256"},{"internalType":"uint256","name":"flexToken0InAmount","type":"uint256"},{"internalType":"uint256","name":"strictToken0InAmount","type":"uint256"},{"internalType":"uint256","name":"flexToken1InAmount","type":"uint256"},{"internalType":"uint256","name":"strictToken1InAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"getETHBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getExchangeData","outputs":[{"internalType":"uint256","name":"boxNumber","type":"uint256"},{"internalType":"uint256","name":"_reserve0","type":"uint256"},{"internalType":"uint256","name":"_reserve1","type":"uint256"},{"internalType":"uint256","name":"totalShare","type":"uint256"},{"internalType":"uint256","name":"latestSpreadRate","type":"uint256"},{"internalType":"uint256","name":"token0PerShareE18","type":"uint256"},{"internalType":"uint256","name":"token1PerShareE18","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"enum OrderType","name":"orderType","type":"uint8"}],"name":"getOrderAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"internalType":"uint256","name":"initialShare","type":"uint256"}],"name":"initializeExchange","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"marketFeePool0","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketFeePool1","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bool","name":"isLimit","type":"bool"}],"name":"orderEthToToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"internalType":"bool","name":"isLimit","type":"bool"}],"name":"orderTokenToEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"uint256","name":"minEth","type":"uint256"},{"internalType":"uint256","name":"minTokens","type":"uint256"},{"internalType":"uint256","name":"sharesBurned","type":"uint256"}],"name":"removeLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sendMarketFeeToLien","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract ERC20Interface","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"boxNumber","type":"uint256"},{"internalType":"bool","name":"isBuy","type":"bool"},{"internalType":"bool","name":"isLimit","type":"bool"}],"name":"whenToExecute","outputs":[{"internalType":"bool","name":"isExecuted","type":"bool"},{"internalType":"uint256","name":"boxCount","type":"uint256"},{"internalType":"uint256","name":"orderCount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000007591a309df68bf43ba42dd11b0344220a260020a000000000000000000000000e9aa04b8d955fd291d44c9fdb8eb1227850b3e2d000000000000000000000000ab37e1358b639fd877f015027bb62d3ddaa7557e000000000000000000000000c05cb1999ab97a9ae5337fbdc4cb0e1458bc5cbf000000000000000000000000120a078fdc516a1a98bbecb9e961f8741ac7ac8200000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000e53484152452d49444f4c2d455448000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _token (address): 0x7591a309Df68bf43ba42dD11b0344220A260020A
Arg [1] : _priceCalc (address): 0xE9aa04b8D955fD291d44C9fDb8eB1227850b3e2d
Arg [2] : _marketFeeTaker (address): 0xaB37e1358b639Fd877f015027Bb62d3ddAa7557E
Arg [3] : _spreadCalc (address): 0xC05CB1999aB97A9ae5337fBdC4cb0e1458bc5CbF
Arg [4] : _oracle (address): 0x120a078FdC516A1A98bbecb9e961F8741AC7ac82
Arg [5] : _name (string): SHARE-IDOL-ETH

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000007591a309df68bf43ba42dd11b0344220a260020a
Arg [1] : 000000000000000000000000e9aa04b8d955fd291d44c9fdb8eb1227850b3e2d
Arg [2] : 000000000000000000000000ab37e1358b639fd877f015027bb62d3ddaa7557e
Arg [3] : 000000000000000000000000c05cb1999ab97a9ae5337fbdc4cb0e1458bc5cbf
Arg [4] : 000000000000000000000000120a078fdc516a1a98bbecb9e961f8741ac7ac82
Arg [5] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [6] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [7] : 53484152452d49444f4c2d455448000000000000000000000000000000000000

Deployed Bytecode Sourcemap

86332:839:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;17757:83:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;17757:83:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;17757:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19863:169;;5:9:-1;2:2;;;27:1;24;17:12;2:2;19863:169:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;19863:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;18832:100;;5:9:-1;2:2;;;27:1;24;17:12;2:2;18832:100:0;;;:::i;:::-;;;;;;;;;;;;;;;;81294:316;;5:9:-1;2:2;;;27:1;24;17:12;2:2;81294:316:0;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;81294:316:0;;;-1:-1:-1;;;;;81294:316:0;;;;;;;;;;;;;;;;;:::i;:::-;;20506:321;;5:9:-1;2:2;;;27:1;24;17:12;2:2;20506:321:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;20506:321:0;;;;;;;;;;;;;;;;;:::i;18684:83::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;18684:83:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21236:218;;5:9:-1;2:2;;;27:1;24;17:12;2:2;21236:218:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;21236:218:0;;;;;;;;:::i;83971:122::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;83971:122:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;83971:122:0;-1:-1:-1;;;;;83971:122:0;;:::i;42913:396::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;42913:396:0;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;;;;;;42913:396:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79659:191;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;79659:191:0;;;;;;;:::i;18995:119::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;18995:119:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;18995:119:0;-1:-1:-1;;;;;18995:119:0;;:::i;46374:253::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;46374:253:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;46374:253:0;;-1:-1:-1;;;;;46374:253:0;;;;;;;;:::i;17959:87::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;17959:87:0;;;:::i;83446:81::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;83446:81:0;;;:::i;81978:407::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;81978:407:0;;;;;;;:::i;44765:1397::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;44765:1397:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;44765:1397:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21957:269;;5:9:-1;2:2;;;27:1;24;17:12;2:2;21957:269:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;21957:269:0;;;;;;;;:::i;19327:175::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;19327:175:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;19327:175:0;;;;;;;;:::i;39507:29::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;39507:29:0;;;:::i;:::-;;;;-1:-1:-1;;;;;39507:29:0;;;;;;;;;;;;;;83261:111;;5:9:-1;2:2;;;27:1;24;17:12;2:2;83261:111:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;83261:111:0;;;;:::i;39441:29::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;39441:29:0;;;:::i;43833:697::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;43833:697:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19565:151;;5:9:-1;2:2;;;27:1;24;17:12;2:2;19565:151:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;19565:151:0;;;;;;;;;;:::i;83677:180::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;83677:180:0;;;:::i;82882:237::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;82882:237:0;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;82882:237:0;;;;;;;;;;;;;;;;;:::i;80374:291::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;80374:291:0;;;-1:-1:-1;;;;;80374:291:0;;;;;;;;;;;;:::i;78479:37::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;78479:37:0;;;:::i;:::-;;;;-1:-1:-1;;;;;78479:37:0;;;;;;;;;;;;;;17757:83;17827:5;17820:12;;;;;;;;-1:-1:-1;;17820:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17794:13;;17820:12;;17827:5;;17820:12;;17827:5;17820:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17757:83;;:::o;19863:169::-;19946:4;19963:39;19972:12;:10;:12::i;:::-;19986:7;19995:6;19963:8;:39::i;:::-;-1:-1:-1;20020:4:0;19863:169;;;;;:::o;18832:100::-;18912:12;;18832:100;:::o;81294:316::-;81455:11;41637;41629:54;;;;;-1:-1:-1;;;41629:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;81477:7:::1;41775:19;:17;:19::i;:::-;41765:7;:29;41757:50;;;::::0;;-1:-1:-1;;;41757:50:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;41757:50:0;;;;;;;;;;;;;::::1;;81497:19:::2;81519:28;81533:4;81539:7;81519:13;:28::i;:::-;81497:50;;81558:44;81568:9;81579:11;81592:9;81558;:44::i;:::-;41818:1;41694::::1;81294:316:::0;;;;;:::o;20506:321::-;20612:4;20629:36;20639:6;20647:9;20658:6;20629:9;:36::i;:::-;20676:121;20685:6;20693:12;:10;:12::i;:::-;20707:89;20745:6;20707:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20707:19:0;;;;;;:11;:19;;;;;;20727:12;:10;:12::i;:::-;-1:-1:-1;;;;;20707:33:0;;;;;;;;;;;;-1:-1:-1;20707:33:0;;;:89;;:37;:89;:::i;:::-;20676:8;:121::i;:::-;-1:-1:-1;20815:4:0;20506:321;;;;;;:::o;18684:83::-;18750:9;;;;18684:83;:::o;21236:218::-;21324:4;21341:83;21350:12;:10;:12::i;:::-;21364:7;21373:50;21412:10;21373:11;:25;21385:12;:10;:12::i;:::-;-1:-1:-1;;;;;21373:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;21373:25:0;;;:34;;;;;;;;;;;:50;:38;:50;:::i;83971:122::-;-1:-1:-1;;;;;84063:22:0;;84036:7;84063:22;;;:11;:22;;;;;;83971:122;;;;:::o;42913:396::-;43107:15;43137:16;43168:18;43234:67;43249:9;43260:29;43274:5;43281:7;43260:13;:29::i;:::-;43291:9;43234:14;:67::i;:::-;43214:87;;;;;;42913:396;;;;;;;;;:::o;79659:191::-;79781:61;79795:11;79817:9;79829:12;79781:5;:61::i;:::-;79659:191;;:::o;18995:119::-;-1:-1:-1;;;;;19088:18:0;19061:7;19088:18;;;;;;;;;;;;18995:119::o;46374:253::-;46484:7;46529:10;46540:19;:17;:19::i;:::-;46529:31;;;;;;;;;;;;;;;;;;:42;;:53;46572:9;46529:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46529:53:0;;;-1:-1:-1;;;;;46529:90:0;;;;;;;;;;;-1:-1:-1;46374:253:0;;;;:::o;17959:87::-;18031:7;18024:14;;;;;;;;-1:-1:-1;;18024:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17998:13;;18024:14;;18031:7;;18024:14;;18031:7;18024:14;;;;;;;;;;;;;;;;;;;;;;;;83446:81;83497:22;:20;:22::i;:::-;83446:81::o;81978:407::-;82094:9;41637:11;41629:54;;;;;-1:-1:-1;;;41629:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;82123:7:::1;41775:19;:17;:19::i;:::-;41765:7;:29;41757:50;;;::::0;;-1:-1:-1;;;41757:50:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;41757:50:0;;;;;;;;;;;;;::::1;;82149:17:::2;82168::::0;82189:14:::2;:12;:14::i;:::-;82148:55;;;;82229:148;82257:9;82281;82305;82329:10;82354:12;82229:13;:148::i;:::-;41818:1;;41694::::1;81978:407:::0;;;:::o;44765:1397::-;44869:29;44913:26;44954:28;44997:26;45038:28;45338:26;45367:18;:28;;;;;;;;;;;;45338:57;;;;45427:10;45438:9;45427:21;;;;;;;;;;;;;;;;:66;;;:21;;;;;:66;;;;;;:94;;45555:10;:21;;45427:94;;-1:-1:-1;45555:10:0;45566:9;;45555:21;;;;;;;;;;;;;;;:68;;;:21;;;;:68;;;;;;:96;;45683:10;:21;;45555:96;;-1:-1:-1;45683:10:0;45694:9;;45683:21;;;;;;;;;;;;;;45716:32;45683:66;;:21;;;;;:66;;;;;;:94;;45811:10;:21;;45683:94;;-1:-1:-1;45811:10:0;45822:9;;45811:21;;;;;;;;;;;;;;45844:34;45811:68;;:21;;;;;:68;;;;;;:96;;;-1:-1:-1;45922:30:0;;;45918:237;;;45993:1;45969:25;;45918:237;;;46043:18;46030:9;:31;:61;;;;-1:-1:-1;46065:18:0;:26;-1:-1:-1;;;46065:26:0;;;;46030:61;46012:143;;;46142:1;46118:25;;46012:143;44765:1397;;;;;;;;:::o;21957:269::-;22050:4;22067:129;22076:12;:10;:12::i;:::-;22090:7;22099:96;22138:15;22099:96;;;;;;;;;;;;;;;;;:11;:25;22111:12;:10;:12::i;:::-;-1:-1:-1;;;;;22099:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;22099:25:0;;;:34;;;;;;;;;;;:96;;:38;:96;:::i;19327:175::-;19413:4;19430:42;19440:12;:10;:12::i;:::-;19454:9;19465:6;19430:9;:42::i;39507:29::-;;;-1:-1:-1;;;;;39507:29:0;;:::o;83261:111::-;83330:34;83352:11;83330:21;:34::i;:::-;83261:111;:::o;39441:29::-;;;;;;-1:-1:-1;;;;;39441:29:0;;:::o;43833:697::-;43941:17;43973;44005;44037:18;44070:24;44109:25;44149;44214:19;:17;:19::i;:::-;44202:31;;44269:14;:12;:14::i;:::-;44244:39;;;;;;;;44313:10;44324:9;44313:21;;;;;;;;;;;;;;;;:32;:21;;;;;:32;;-1:-1:-1;;;;;44313:32:0;;-1:-1:-1;44369:13:0;:11;:13::i;:::-;44356:26;;44413:39;44430:9;44441:10;44413:16;:39::i;:::-;44393:59;;44483:39;44500:9;44511:10;44483:16;:39::i;:::-;44463:59;;43833:697;;;;;;;:::o;19565:151::-;-1:-1:-1;;;;;19681:18:0;;;19654:7;19681:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19565:151::o;83677:180::-;83753:10;83720:18;83741:23;;;:11;:23;;;;;;;83775:27;;;83741:23;83813:36;;83741:23;83813:12;:36::i;82882:237::-;83042:7;41775:19;:17;:19::i;:::-;41765:7;:29;41757:50;;;;;-1:-1:-1;;;41757:50:0;;;;;;;;;;;;-1:-1:-1;;;41757:50:0;;;;;;;;;;;;;;;83062:49:::1;83079:9;83090:6;83098:12;83062:16;:49::i;:::-;82882:237:::0;;;;;:::o;80374:291::-;80513:9;41637:11;41629:54;;;;;-1:-1:-1;;;41629:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;80533:7:::1;41775:19;:17;:19::i;:::-;41765:7;:29;41757:50;;;::::0;;-1:-1:-1;;;41757:50:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;41757:50:0;;;;;;;;;;;;;::::1;;80553:19:::2;80575:29;80589:5;80596:7;80575:13;:29::i;:::-;80553:51;;80615:42;80625:9;80636;80647;80615;:42::i;78479:37::-:0;;;:::o;657:106::-;745:10;657:106;:::o;25104:346::-;-1:-1:-1;;;;;25206:19:0;;25198:68;;;;-1:-1:-1;;;25198:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25285:21:0;;25277:68;;;;-1:-1:-1;;;25277:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25358:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;25410:32;;;;;;;;;;;;;;;;;25104:346;;;:::o;66322:108::-;66401:10;:17;-1:-1:-1;;66401:21:0;66322:108;:::o;73128:487::-;73228:9;73259:5;73255:353;;;73285:8;73281:142;;;-1:-1:-1;73321:20:0;73314:27;;73281:142;-1:-1:-1;73389:18:0;73382:25;;73255:353;73459:8;73455:142;;;-1:-1:-1;73495:20:0;73488:27;;73455:142;-1:-1:-1;73563:18:0;73556:25;;50897:694;51036:12;:10;:12::i;:::-;51059:25;51087:19;:17;:19::i;:::-;51059:47;;51117:36;51132:1;51135:17;51117:14;:36::i;:::-;-1:-1:-1;;;;;51168:23:0;;51164:78;;51220:10;51208:22;;51164:78;51252:57;51267:19;:9;:17;;;;;;;;;:19::i;:::-;51288:10;51300:8;51252:14;:57::i;:::-;51320:70;51359:9;51370:8;51380:9;51320:10;51331:17;51320:29;;;;;;;;;;;;;;;;;;:38;;:70;;;;;;:::i;:::-;51496:17;51406:177;;51457:17;:9;:15;;;;;;;;;:17::i;:::-;51406:177;;51433:9;-1:-1:-1;;;;;51406:177:0;;51529:20;:9;:18;;;;;;;;;:20::i;:::-;51406:177;;;;;;;;;;;;;;;;;;;;;;;50897:694;;;;:::o;22716:539::-;-1:-1:-1;;;;;22822:20:0;;22814:70;;;;-1:-1:-1;;;22814:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22903:23:0;;22895:71;;;;-1:-1:-1;;;22895:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22979:47;23000:6;23008:9;23019:6;22979:20;:47::i;:::-;23059:71;23081:6;23059:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23059:17:0;;:9;:17;;;;;;;;;;;;:71;;:21;:71;:::i;:::-;-1:-1:-1;;;;;23039:17:0;;;:9;:17;;;;;;;;;;;:91;;;;23164:20;;;;;;;:32;;23189:6;23164:32;:24;:32;:::i;:::-;-1:-1:-1;;;;;23141:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;23212:35;;;;;;;23141:20;;23212:35;;;;;;;;;;;;;22716:539;;;:::o;5704:192::-;5790:7;5826:12;5818:6;;;;5810:29;;;;-1:-1:-1;;;5810:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;5810:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5862:5:0;;;5704:192::o;4801:181::-;4859:7;4891:5;;;4915:6;;;;4907:46;;;;;-1:-1:-1;;;4907:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;66496:382;66595:22;66639:5;:16;;;;;66648:7;66639:16;66635:236;;;-1:-1:-1;66689:1:0;66635:236;;;66713:5;66708:163;;66739:7;66735:125;;;-1:-1:-1;66784:1:0;66735:125;;61919:2440;62103:15;62133:16;62164:18;62226:19;:17;:19::i;:::-;62214:9;:31;62210:84;;;-1:-1:-1;62270:5:0;;-1:-1:-1;62270:5:0;;-1:-1:-1;62270:5:0;62262:20;;62210:84;62304:29;62336:10;62347:9;62336:21;;;;;;;;;;;;;;;;;;62304:53;;62368:27;62398:12;:23;;:74;62446:14;62422:49;;;;;;;;62398:74;;;;;;;;;;;;;;;;;;;;;;;;;;;:99;;62368:129;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;62368:129:0;;;;;;;;;;;;;;;;-1:-1:-1;;62537:18:0;:28;62596:29;;:19;62663:38;62368:129;;-1:-1:-1;;;;62537:28:0;;;;;;62596:29;;-1:-1:-1;62508:26:0;;-1:-1:-1;62663:38:0;;;-1:-1:-1;62655:47:0;;;;;;;;62728:18;:26;62636:66;;-1:-1:-1;;;;62728:26:0;;;;62713:12;;;62812:208;62837:10;:17;62832:1;:22;62812:208;;62897:9;-1:-1:-1;;;;;62880:26:0;:10;62891:1;62880:13;;;;;;;;;;;;;;-1:-1:-1;;;;;62880:26:0;;62876:133;;;62937:4;62927:14;;62968:1;62960:9;;62988:5;;62876:133;62856:3;;62812:208;;;;63312:18;63300:9;:30;63299:225;;;;63350:7;:44;;;;;63375:18;63362:9;:31;63350:44;63349:174;;;;;63435:8;63418:14;:25;63417:105;;;;63489:8;63471:14;:26;63470:51;;;;;63511:9;63503:5;:17;63470:51;63281:301;;;-1:-1:-1;63559:4:0;;-1:-1:-1;63565:1:0;;-1:-1:-1;63565:1:0;;-1:-1:-1;63551:19:0;;-1:-1:-1;;;;;;;63551:19:0;63281:301;63599:7;63594:61;;-1:-1:-1;63631:5:0;;-1:-1:-1;63631:5:0;;-1:-1:-1;63631:5:0;;-1:-1:-1;63623:20:0;;-1:-1:-1;;;;;;;63623:20:0;63594:61;63730:14;63772:18;63759:9;:31;:42;;;;;63794:7;63759:42;63755:597;;;63835:8;63818:147;63849:14;63845:1;:18;63818:147;;;63899:50;:12;:23;63933:1;63923:12;;;;;;;;63899:37;;;;;;;;;;;;;;;;;;;;;;;;;;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63899:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:50::i;:::-;63889:60;;;;63865:3;;63818:147;;;-1:-1:-1;63990:1:0;;-1:-1:-1;64019:32:0;64041:9;64019:17;:6;64030:5;64019:17;:10;:17;:::i;:::-;:21;:32;:21;:32;:::i;:::-;64054:1;64019:36;64006:49;;63755:597;;;64093:9;64088:141;64113:14;64108:1;:19;64088:141;;64163:50;:12;:23;64197:1;64187:12;;;;;;;64163:50;64153:60;;;;64129:3;;64088:141;;;-1:-1:-1;64254:33:0;:9;64268:18;64254:33;:13;:33;:::i;:::-;64290:1;64254:37;;-1:-1:-1;64319:17:0;:6;64330:5;64319:17;:10;:17;:::i;:::-;64339:1;64319:21;64306:34;;63755:597;61919:2440;;;;;;;;;;;;;;;;;:::o;47693:461::-;47834:13;:11;:13::i;:::-;:18;47826:50;;;;;-1:-1:-1;;;47826:50:0;;;;;;;;;;;;-1:-1:-1;;;47826:50:0;;;;;;;;;;;;;;;47895:10;-1:-1:-1;;;;;47909:7:0;47895:21;;47887:30;;12:1:-1;9;2:12;47887:30:0;47928:32;47943:7;47952;47928:14;:32::i;:::-;47971:31;47977:10;47989:12;47971:5;:31::i;:::-;48013:49;48028:12;48042:10;48054:7;-1:-1:-1;;;;;48013:49:0;:14;:49::i;:::-;48073;48088:12;48102:10;48114:7;-1:-1:-1;;;;;48073:49:0;:14;:49::i;:::-;48133:13;:11;:13::i;:::-;47693:461;;;:::o;51977:353::-;52052:23;52090;52127:20;:18;:20::i;:::-;52037:110;;;;52158:26;52179:1;52182;52158:20;:26::i;:::-;52202:46;;;;;;;;;;;;;;;;;;;;;;;;;52259:63;52273:14;52289:15;52306;52259:13;:63::i;64367:187::-;64507:8;;64538;;-1:-1:-1;;;;;;;;64507:8:0;;;;;;64538;;;64367:187::o;48414:806::-;48607:15;48624;48641:13;48658:121;48690:6;48711:9;48735;48759;48658:17;:121::i;:::-;48606:173;;;;;;48807:8;48798:5;:17;;48790:61;;;;;-1:-1:-1;;;48790:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48862:49;48877:12;48891:10;48903:7;48862:14;:49::i;:::-;48922;48937:12;48951:10;48963:7;48922:14;:49::i;:::-;48982:123;49011:34;:22;:9;49025:7;49011:22;:13;:22;:::i;:::-;:32;:34::i;:::-;49060;:22;:9;49074:7;49060:22;:13;:22;:::i;:34::-;48982:14;:123::i;:::-;49116:24;49122:10;49134:5;49116;:24::i;:::-;49156:56;;;;;;;;;;;;;;;;;;;;49182:4;;49170:10;;49156:56;;;;;;;;;48414:806;;;;;;;;:::o;51749:134::-;51827:48;51842:11;51827:48;;51855:19;:17;:19::i;:::-;51827:14;:48::i;35499:132::-;35561:7;35588:35;35621:1;35588:28;:1;35462:19;35588:28;:5;:28;:::i;:::-;:32;:35;:32;:35;:::i;85981:230::-;86130:26;;86112:12;;-1:-1:-1;;;;;86130:7:0;;;86145:6;;86112:12;86130:26;86112:12;86130:26;86145:6;86130:7;:26;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;86111:45:0;;;86175:7;86167:36;;;;;-1:-1:-1;;;86167:36:0;;;;;;;;;;;;-1:-1:-1;;;86167:36:0;;;;;;;;;;;;;;49640:896;49784:17;49803;49824:14;:12;:14::i;:::-;49783:55;;;;49864:20;49887:13;:11;:13::i;:::-;49864:36;-1:-1:-1;49911:15:0;49929:38;49864:36;49929:20;:9;49943:5;49929:20;:13;:20;:::i;:38::-;49911:56;-1:-1:-1;49978:15:0;49996:38;50021:12;49996:20;:9;50010:5;49996:20;:13;:20;:::i;:38::-;49978:56;;50078:10;50067:7;:21;;:46;;;;;50103:10;50092:7;:21;;50067:46;50045:127;;;;;-1:-1:-1;;;50045:127:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;50183:123;50212:34;:22;:9;50226:7;50212:22;:13;:22;:::i;:34::-;50261;:22;:9;50275:7;50261:22;:13;:22;:::i;50183:123::-;50317:24;50323:10;50335:5;50317;:24::i;:::-;50352:46;50364:12;50378:10;50390:7;50352:11;:46::i;:::-;50409;50421:12;50435:10;50447:7;50409:11;:46::i;:::-;50471:57;;;;;;;;;;;;;;;;;;;;50497:5;;50485:10;;50471:57;;;;;;;;;49640:896;;;;;;;;:::o;52690:164::-;52779:26;:24;:26::i;:::-;52775:72;;;52822:13;:11;:13::i;53103:3738::-;53208:45;;:::i;:::-;:66;;;;;;;;;53256:18;53208:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53208:66:0;;-1:-1:-1;;;;;53208:66:0;;;;;-1:-1:-1;;;53208:66:0;;;;;;;;-1:-1:-1;;;53208:66:0;;;;;;;;;;;;-1:-1:-1;53285:47:0;;:::i;:::-;:69;;;;;;;;;53335:19;53285:69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53625:17;53592:19;:29;;;:50;;;;:166;;;;;53661:26;:24;:26::i;:::-;53660:27;:97;;;;53740:17;53708:19;:29;;;:49;;;53660:97;53574:229;;;53785:7;;;;53574:229;53818:19;:27;;;53813:950;;54024:34;54081:27;54131:12;54165:105;54222:19;:29;;;54165:34;:105::i;:::-;54001:269;;-1:-1:-1;54001:269:0;-1:-1:-1;54001:269:0;-1:-1:-1;54289:19:0;54001:269;54289:93;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54443:52:0;:19;:50;:52::i;:::-;54401:94;;:39;;;:94;54541:16;:4;:14;:16::i;:::-;-1:-1:-1;;;;;54514:43:0;:24;;;:43;-1:-1:-1;;54606:4:0;54576:27;;;:34;-1:-1:-1;;54629:54:0;;;54702:30;;;:34;53813:950;54875:16;;54868:1862;;54908:31;54942:10;54953:19;:47;;;54942:59;;;;;;;;;;;;;;;;;55031:39;;54942:59;;;;;;;:129;;;;;;;;;;;;;;;;;;;;;;;;;;;54908:163;;55105:19;55143:17;55179:24;55221:458;55260:13;55292:49;:20;:39;;;:47;;;;;;;:49;55360:30;;;;55462:39;;55409:111;;:19;;:111;:30;:111;:::i;:::-;55539:19;:24;;;-1:-1:-1;;;;;55221:458:0;55582:10;55593:19;:29;;;55582:41;;;;;;;;;;;;;;;;;;:52;:41;;;;;:52;;-1:-1:-1;;;;;55582:52:0;55653:11;55221:20;:458::i;:::-;55086:593;;;;;;55698:14;55694:911;;;55733:18;55754:159;55791:10;55802:19;:29;;;55791:41;;;;;;;;;;;;;;;;;;;;55855:20;:39;;;55754:14;:159::i;:::-;55733:180;;55939:10;55950:19;:29;;;55939:41;;;;;;;;;;;;;;;;;56014:39;;55939:41;;;;;;;:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;55932:122;;;;;;;;:::i;:::-;;;;;;;;;56153:13;56149:290;;;56191:29;;;:34;;;56224:1;56191:34;;;;;;;-1:-1:-1;56248:27:0;;;:35;56306:40;;:18;:40;;56191:19;;56306:18;;:40;:18;;-1:-1:-1;;56306:40:0;;;;;;;;;;;;;;;-1:-1:-1;56306:40:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;56306:40:0;-1:-1:-1;;;;56306:40:0;;;;-1:-1:-1;;;56306:40:0;-1:-1:-1;;;;;;;;;56306:40:0;;;-1:-1:-1;;;56306:40:0;-1:-1:-1;;;;;;;;56306:40:0;;;;;;-1:-1:-1;;56306:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56371:7:0;;-1:-1:-1;;;;;;56371:7:0;56149:290;56499:61;;:90;;:88;;;;;;;;;:90::i;:::-;56457:20;;:132;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55694:911:0;56652:20;:9;:18;:20::i;:::-;56619:53;;:30;;;:53;56687:31;;;;-1:-1:-1;54868:1862:0;;-1:-1:-1;;54868:1862:0;;56740:40;;:18;:40;;56761:19;;56740:40;:18;;-1:-1:-1;;56740:40:0;;;;;;;;;;;;;;;-1:-1:-1;56740:40:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;56740:40:0;-1:-1:-1;;;;56740:40:0;;;;-1:-1:-1;;;56740:40:0;-1:-1:-1;;;;;;;;;56740:40:0;;;-1:-1:-1;;;56740:40:0;-1:-1:-1;;;;;;;;56740:40:0;;;;;;-1:-1:-1;;56740:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56791:42;;:19;:42;;56813:20;;56791:42;:19;;-1:-1:-1;;56791:42:0;56740:40;56791:42;;;;;;;;;;;;;;;;;;;;;;;;;53103:3738;;;;:::o;34485:243::-;34541:5;;34563:4;:26;;;;;;;;;:58;;;-1:-1:-1;34601:20:0;34593:4;:28;;;;;;;;;34563:58;34559:162;;;-1:-1:-1;34645:12:0;34638:19;;34559:162;-1:-1:-1;34697:12:0;34690:19;;84283:335;84434:12;84421:9;:25;;;;;;;;;84417:194;;;84463:51;-1:-1:-1;;;;;84463:5:0;:22;84486:4;84500;84507:6;84463:51;:22;:51;:::i;:::-;84417:194;;;84568:6;84555:9;:19;84547:52;;;;;-1:-1:-1;;;84547:52:0;;;;;;;;;;;;-1:-1:-1;;;84547:52:0;;;;;;;;;;;;;;38043:526;38205:27;38235:4;38205:27;38251:9;38235:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38235:26:0;;;-1:-1:-1;;;;;38276:30:0;;;;;;;;;;38235:26;;-1:-1:-1;38272:104:0;;38328:20;;;;27:10:-1;;23:18;;;45:23;;-1:-1;38328:36:0;;;;;;;;;-1:-1:-1;;;;;;38328:36:0;-1:-1:-1;;;;;38328:36:0;;;;;38272:104;-1:-1:-1;;;;;38419:30:0;;:19;:30;;;;;;;;;;;:68;;38468:8;38419:68;:34;:68;:::i;:::-;-1:-1:-1;;;;;38386:30:0;;:19;:30;;;;;;;;;;:101;38524:23;;;;:37;;38552:8;38524:37;:27;:37;:::i;:::-;38498:23;;;;:63;-1:-1:-1;;;;38043:526:0:o;35129:146::-;35183:4;;35208;:26;;;;;;;;;:58;;;-1:-1:-1;35246:20:0;35238:28;:4;:28;;;;;;;;;35200:67;35129:146;-1:-1:-1;;35129:146:0:o;34887:102::-;34944:4;34969:12;34976:4;34969:6;:12::i;:::-;34968:13;;34887:102;-1:-1:-1;;34887:102:0:o;38608:123::-;38701:15;:22;;38608:123::o;5265:136::-;5323:7;5350:43;5354:1;5357;5350:43;;;;;;;;;;;;;;;;;:3;:43::i;64799:219::-;64885:8;:22;;-1:-1:-1;;;;;64885:22:0;;;-1:-1:-1;;;64885:22:0;;;;;;;;64918:8;:22;;-1:-1:-1;;;;;;64918:22:0;;;;;;;;;;64956:54;64885:22;64918;64996:13;:11;:13::i;:::-;64956:54;;;-1:-1:-1;;;;;64956:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;64799:219;;:::o;23536:378::-;-1:-1:-1;;;;;23620:21:0;;23612:65;;;;;-1:-1:-1;;;23612:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;23690:49;23719:1;23723:7;23732:6;23690:20;:49::i;:::-;23767:12;;:24;;23784:6;23767:24;:16;:24;:::i;:::-;23752:12;:39;-1:-1:-1;;;;;23823:18:0;;:9;:18;;;;;;;;;;;:30;;23846:6;23823:30;:22;:30;:::i;:::-;-1:-1:-1;;;;;23802:18:0;;:9;:18;;;;;;;;;;;:51;;;;23869:37;;;;;;;23802:18;;:9;;23869:37;;;;;;;;;;23536:378;;:::o;85721:252::-;85773:19;:17;:19::i;:::-;85803:18;85824:19;:17;:19::i;:::-;85803:40;;85884:22;:10;:20;:22::i;:::-;-1:-1:-1;;;;;85859:106:0;;85921:10;85932;85921:22;;;;;;;;;;;;;;;;;:33;:22;;;;;:33;;85859:106;;;-1:-1:-1;;;;;85921:33:0;;;85859:106;;;;;;;;;;;;85721:252;:::o;64562:229::-;64726:14;;64769;;-1:-1:-1;;;;;64726:14:0;;;;;;;64769;;;64562:229::o;66886:215::-;67014:14;:34;;-1:-1:-1;;67014:34:0;;-1:-1:-1;;;;;67014:34:0;;;;;;;67059:14;:34;;-1:-1:-1;;;;;;67059:34:0;;;;;;;;66886:215::o;84915:334::-;85064:12;;85060:89;;85093:44;-1:-1:-1;;;;;85093:5:0;:18;85112:15;85129:7;85093:44;:18;:44;:::i;:::-;85163:12;;85159:83;;85192:38;85205:15;85222:7;85192:12;:38::i;67109:703::-;67313:7;;;;67396:9;:25;;;;;;;;;67392:413;;;67464:6;67489:36;67515:9;67489:21;67464:6;67500:9;67489:21;:10;:21;:::i;:36::-;67544:40;67574:9;67544:25;67555:13;:11;:13::i;:::-;67544:6;;:25;:10;:25;:::i;:40::-;67438:161;;;;;;;;67392:413;67658:36;67684:9;67658:21;:6;67669:9;67658:21;:10;:21;:::i;:36::-;67713:6;67738:40;67768:9;67738:25;67749:13;:11;:13::i;27739:184::-;27796:7;-1:-1:-1;;;27824:5:0;:14;27816:67;;;;-1:-1:-1;;;27816:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27909:5:0;27739:184::o;6155:471::-;6213:7;6458:6;6454:47;;-1:-1:-1;6488:1:0;6481:8;;6454:47;6525:5;;;6529:1;6525;:5;:1;6549:5;;;;;:10;6541:56;;;;-1:-1:-1;;;6541:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7102:132;7160:7;7187:39;7191:1;7194;7187:39;;;;;;;;;;;;;;;;;:3;:39::i;24246:418::-;-1:-1:-1;;;;;24330:21:0;;24322:67;;;;-1:-1:-1;;;24322:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24402:49;24423:7;24440:1;24444:6;24402:20;:49::i;:::-;24485:68;24508:6;24485:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24485:18:0;;:9;:18;;;;;;;;;;;;:68;;:22;:68;:::i;:::-;-1:-1:-1;;;;;24464:18:0;;:9;:18;;;;;;;;;;:89;24579:12;;:24;;24596:6;24579:24;:16;:24;:::i;:::-;24564:12;:39;24619:37;;;;;;;;24645:1;;-1:-1:-1;;;;;24619:37:0;;;;;;;;;;;;24246:418;;:::o;84626:281::-;84772:12;84759:9;:25;;;;;;;;;84755:145;;;84801:30;-1:-1:-1;;;;;84801:5:0;:18;84820:2;84824:6;84801:30;:18;:30;:::i;84755:145::-;84864:24;84877:2;84881:6;84864:12;:24::i;85557:156::-;85625:4;85665:10;85676:19;:17;:19::i;:::-;85665:31;;;;;;;;;;;;;;;;;;;;;:40;;;-1:-1:-1;;;85665:40:0;;-1:-1:-1;;;;;85665:40:0;85649:12;:56;;;85557:156;-1:-1:-1;85557:156:0:o;68826:2706::-;68937:34;68986:27;69028:12;69068:25;69096:10;69107:9;69096:21;;;;;;;;;;;;;;;;;;69559:39;;;69096:21;;;;;69559:39;;;;;;;;:67;;;69689:18;69669:39;;;;;:67;;;69781:55;;;;;;:83;;;69929:34;69909:55;;;;;:83;;;;69096:21;;-1:-1:-1;69096:21:0;;;;69559:67;;69669;;70185:202;69096:21;69559:67;69669;69781:83;69909;70185:20;:202::i;:::-;70003:384;;-1:-1:-1;70003:384:0;;-1:-1:-1;70003:384:0;;-1:-1:-1;70003:384:0;;-1:-1:-1;70003:384:0;-1:-1:-1;70419:17:0;70415:580;;70484:20;70457:47;;70415:580;;;70565:12;70581:1;70565:17;70561:434;;;70630:20;70603:47;;70561:434;;;70676:12;70692:1;70676:17;70672:323;;;70741:18;70714:45;;70672:323;;;70785:12;70801:1;70785:17;70781:214;;;70850:20;70823:47;;70781:214;;;70896:12;70912:1;70896:17;70892:103;;;70961:18;70934:45;;70892:103;71052:9;71021:298;;;71082:24;71076:31;;;;;;;;71021:298;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71387:19;;;;71330:194;;-1:-1:-1;;;;;71387:19:0;71421:29;71465;71509:4;71330:42;:194::i;:::-;68826:2706;;;;;;;;;;;;;:::o;28222:179::-;28278:6;28313:5;28305;:13;28297:65;;;;-1:-1:-1;;;28297:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36485:874;36608:7;36734:19;:9;:17;;;;;;;:19;36691:62;;;;;;;;:29;;:39;;:37;;;;;;;:39;:62;;;;;;;;;36687:103;;-1:-1:-1;36777:1:0;36770:8;;36687:103;36919:29;;:38;;:36;;;;;;;;;:38::i;:::-;36915:282;;;37012:18;:9;:16;;;;;;;:18;37008:90;;;-1:-1:-1;37058:24:0;;;;37051:31;;;;37008:90;-1:-1:-1;35462:19:0;37148:37;;36915:282;37253:20;:9;:18;;;;;;;:20;37249:84;;;-1:-1:-1;37297:24:0;;;;37290:31;;;;37249:84;-1:-1:-1;37350:1:0;36485:874;;;;:::o;57281:1140::-;57571:4;57590:7;57612;57647:13;57671:18;57692:22;:9;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;57692:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:22::i;:::-;57671:43;;57752:12;57744:20;;57725:535;57802:11;57787:12;57779:5;:20;:34;57725:535;;;57875:10;57866:5;:19;57862:98;;-1:-1:-1;57914:4:0;;-1:-1:-1;57920:1:0;;-1:-1:-1;57923:20:0;;;;-1:-1:-1;57906:38:0;;57862:98;57974:17;57994:9;:20;;58015:5;57994:27;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;57994:27:0;58122:30;;;;;;;;;;;;57994:27;;-1:-1:-1;58036:212:0;;58068:7;;57994:27;;58171:10;58200:4;58223:10;58036:13;:212::i;:::-;-1:-1:-1;57828:7:0;;;;;57725:535;;;58283:10;58274:5;:19;58270:90;;-1:-1:-1;58318:4:0;;-1:-1:-1;58324:1:0;;-1:-1:-1;58327:20:0;;;;-1:-1:-1;58310:38:0;;58270:90;-1:-1:-1;58378:5:0;;-1:-1:-1;58385:5:0;-1:-1:-1;;58392:20:0;;;57281:1140;;;;;;;;;;;;:::o;71722:627::-;71851:4;71953:20;71928:21;:45;;;;;;;;;71924:89;;;-1:-1:-1;71997:4:0;71990:11;;71924:89;72028:9;72048:28;:21;:26;;;;;;;:28;72040:37;;;;;;;;72028:49;;72023:297;72079:1;72084;72079:6;72023:297;;72107:21;;:::i;:::-;72131:6;:17;72159:1;72149:12;;;;;;;;72131:31;;;;;;;;;;;;;;;;;;;;;;;;;;;72107:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;72107:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72238:17;:4;:15;:17::i;:::-;:22;72234:75;;72288:5;72281:12;;;;;;72234:75;-1:-1:-1;72087:3:0;;72023:297;;34997:124;35050:9;35111:1;35098:4;35090:13;;;;;;;;35106:1;35090:17;35089:23;;;;;;35079:34;;;;;;;28700:179;28756:6;28791:5;28783;:13;28775:65;;;;-1:-1:-1;;;28775:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74496:205;74624:68;;;-1:-1:-1;;;;;74624:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;74624:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;74597:96:0;;74617:5;;74597:19;:96::i;:::-;74496:205;;;;:::o;34736:143::-;34791:4;;34815;:26;;;;;;;;;:56;;;-1:-1:-1;34853:18:0;34845:26;;52463:219;52514:10;52544:119;52590:10;:8;:10::i;:::-;52619:29;52620:12;52635:1;52620:16;52619:27;:29::i;:::-;52544:119;;:27;:119::i;:::-;27:10:-1;;39:1;23:18;;;45:23;;-1:-1;52514:160:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;52514:160:0;;;-1:-1:-1;;;;;52514:160:0;;;;;;-1:-1:-1;;;52514:160:0;;;;;;;;52463:219::o;74311:177::-;74421:58;;;-1:-1:-1;;;;;74421:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;74421:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;74394:86:0;;74414:5;;74394:19;:86::i;7730:278::-;7816:7;7851:12;7844:5;7836:28;;;;-1:-1:-1;;;7836:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;7836:28:0;;7875:9;7891:1;7887;:5;;;;;;;7730:278;-1:-1:-1;;;;;7730:278:0:o;67820:998::-;68389:19;;;;68120:12;;;;;;;;;;-1:-1:-1;;;;;68389:19:0;35462;68343:65;68439:371;68480:50;:21;68343:65;68480:31;:50::i;:::-;68549:52;:23;68583:17;68549:52;:33;:52;:::i;:::-;68620:50;:21;68652:17;68620:50;:31;:50;:::i;:::-;68689:52;:23;68723:17;68689:52;:33;:52;:::i;:::-;68760:8;;68787;;-1:-1:-1;;;;;;;;68760:8:0;;;;;;68787;68439:22;:371::i;:::-;68419:391;;;;-1:-1:-1;68419:391:0;;-1:-1:-1;68419:391:0;-1:-1:-1;68419:391:0;;-1:-1:-1;67820:998:0;-1:-1:-1;;;;;;;67820:998:0:o;60320:1591::-;60555:19;60585;60615:25;60651;60721:27;60767:29;60814:230;60869:10;60898:29;60946;60994:4;61017:12;60814:36;:230::i;:::-;61073:8;;61138:14;;-1:-1:-1;;;;;;;;61073:8:0;;;;;:30;;;;-1:-1:-1;61073:8:0;61138:14;;;;;;:38;;-1:-1:-1;61232:27:0;;-1:-1:-1;61232:27:0;;-1:-1:-1;61325:230:0;61380:10;61409:29;61457;61505:4;61138:14;61325:36;:230::i;:::-;61584:8;;61649:14;;-1:-1:-1;;;;;61584:8:0;;;:30;;;;-1:-1:-1;61649:14:0;;;;:38;;-1:-1:-1;61709:64:0;;-1:-1:-1;61724:23:0;;-1:-1:-1;61724:11:0;:21;:23::i;:::-;61749;:11;:21;:23::i;61709:64::-;61784:119;61819:29;:17;:27;:29::i;:::-;61863;:17;:27;:29::i;:::-;61784:20;:119::i;:::-;60320:1591;;;;;;;;:::o;58741:1250::-;58951:14;58968:17;:7;:15;;;;;;;;;:17::i;:::-;58951:34;-1:-1:-1;59045:20:0;59068:30;:8;59087:10;59068:30;:18;:30;:::i;:::-;59045:53;-1:-1:-1;59197:38:0;59238:112;59303:46;35462:19;59338:10;59303:46;:34;:46;:::i;:::-;59238:40;:8;59265:12;59238:40;:26;:40;:::i;:::-;:64;:112;:64;:112;:::i;:::-;59197:153;;59497:17;59517:120;59555:7;59577:30;59622:4;59517:23;:120::i;:::-;59497:140;;59648:55;59670:7;59679:9;59690:12;59648:21;:55::i;:::-;59714:53;59736:8;59746:9;59757;59714:21;:53::i;:::-;59889:9;-1:-1:-1;;;;;59783:200:0;59854:19;:17;:19::i;:::-;59783:200;;59819:12;59808:7;:23;;;;;;;;59783:200;;;;;;;;;;;;;;;;;;;;59808:23;;;;;59783:200;;;;;;;;;58741:1250;;;;;;;;;;:::o;76616:761::-;77040:23;77066:69;77094:4;77066:69;;;;;;;;;;;;;;;;;77074:5;-1:-1:-1;;;;;77066:27:0;;;:69;;;;;:::i;:::-;77150:17;;77040:95;;-1:-1:-1;77150:21:0;77146:224;;77292:10;77281:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;77281:30:0;77273:85;;;;-1:-1:-1;;;77273:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84142:133;84189:7;84216:10;-1:-1:-1;;;;;84216:43:0;;84260:6;84216:51;;;;;;;;;;;;;-1:-1:-1;;;;;84216:51:0;-1:-1:-1;;;;;84216:51:0;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;84216:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;84216:51:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;84216:51:0;;-1:-1:-1;84142:133:0;:::o;37824:211::-;37933:15;;:::i;:::-;-1:-1:-1;37973:54:0;;;;;;;;;-1:-1:-1;;;;;37973:54:0;;;;;;;;;;;;37824:211::o;65026:877::-;65365:12;65392:20;65427:27;65469:24;65508;65560:22;;:::i;:::-;65585:247;;;-1:-1:-1;;;65585:247:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65585:9:0;:24;;;;:247;;;;;;;;;;;;;;:24;:247;;;2:2:-1;;;;27:1;24;17:12;2:2;65585:247:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;65585:247: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;15:3;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;65585:247:0;-1:-1:-1;65585:247:0;65856:1;65851:7;;;;65860:4;65865:1;65860:7;;;;65869:4;65874:1;65869:7;;;;65878:4;65883:1;65878:7;;;;65887:4;65892:1;65887:7;;;;65843:52;;;;;;;;;;;65026:877;;;;;;;;;;;;:::o;72357:763::-;72607:7;;;72658:74;:28;72711:10;72658:74;:38;:74;:::i;:::-;72636:96;-1:-1:-1;72743:17:0;72763:38;72636:96;39229:18;72763:38;:21;:38;:::i;:::-;72743:58;;72812:18;72918:153;72960:19;:9;:17;;;;;;;:19;72998:35;73052:4;72918:23;:153::i;:::-;72878:23;;;;72833:69;;:238;;;;;-1:-1:-1;72892:9:0;-1:-1:-1;;72357:763:0;;;;;;;;:::o;34245:201::-;34297:5;;34319:4;:20;;;;;;;;;34315:124;;;-1:-1:-1;34363:12:0;34356:19;;34315:124;-1:-1:-1;34415:12:0;34408:19;;35825:178;35922:7;35954:41;35462:19;35954:14;:4;35963;35954:14;:8;:14;:::i;65994:320::-;66132:7;;66156:5;:21;;;;;;;;;66152:155;;;66201:27;:6;66218:9;66201:27;:16;:27;:::i;:::-;66194:34;;;;66152:155;66268:27;:6;66285:9;66268:27;:16;:27;:::i;85257:292::-;85413:12;85400:9;:25;;;;;;;;;85396:146;;;85442:30;-1:-1:-1;;;;;85442:5:0;:18;85461:2;85465:6;85442:30;:18;:30;:::i;85396:146::-;-1:-1:-1;;;;;85505:15:0;;;;;;:11;:15;;;;;:25;;;;;;85257:292;;;:::o;13173:196::-;13276:12;13308:53;13331:6;13339:4;13345:1;13348:12;13308:22;:53::i;:::-;13301:60;13173:196;-1:-1:-1;;;;13173:196:0:o;14550:979::-;14680:12;14713:18;14724:6;14713:10;:18::i;:::-;14705:60;;;;;-1:-1:-1;;;14705:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;14839:12;14853:23;14880:6;-1:-1:-1;;;;;14880:11:0;14900:8;14911:4;14880:36;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;14880:36:0;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;14838:78:0;;;;14931:7;14927:595;;;14962:10;-1:-1:-1;14955:17:0;;-1:-1:-1;14955:17:0;14927:595;15076:17;;:21;15072:439;;15339:10;15333:17;15400:15;15387:10;15383:2;15379:19;15372:44;15287:148;15475:20;;-1:-1:-1;;;15475:20:0;;;;;;;;;;;;;;;;;15482:12;;15475:20;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;10058:619:0;10118:4;10586:20;;10429:66;10626:23;;;;;;:42;;-1:-1:-1;;10653:15:0;;;10618:51;-1:-1:-1;;10058:619:0:o;86332:839::-;;;;;;;;;;;-1:-1:-1;86332:839:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;86332:839:0;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;-1:-1;86332:839:0;;;-1:-1:-1;;86332:839:0:o;:::-;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://5260bf1a0d271daa871e5ae10109c19c391198744ecaa6063f0d9d734d70b804

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services