Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _isDeployer(address account)
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library SignedSafeMath
•    - function mul(int256 a, int256 b)
•    - function div(int256 a, int256 b)
•    - function sub(int256 a, int256 b)
•    - function add(int256 a, int256 b)
• library SafeCast
•    - function toUint128(uint256 value)
•    - function toUint64(uint256 value)
•    - function toUint32(uint256 value)
•    - function toUint16(uint256 value)
•    - function toUint8(uint256 value)
•    - function toUint256(int256 value)
•    - function toInt256(uint256 value)
• library SafeMathDivRoundUp
•    - function divRoundUp(
•    - function divRoundUp(uint256 a, uint25 ...
• interface OracleInterface
•    - function alive()
•    - function latestId()
•    - function latestPrice()
•    - function latestTimestamp()
•    - function getPrice(uint256 id)
•    - function getTimestamp(uint256 id)
•    - function getVolatility()
•    - function _getOracleData()
•    - function _getPriceOn(uint256 timestam ...
• interface BondMakerInterface
•    - function registerNewBond(uint256 matu ...
•    - function registerNewBondGroup(
•    - function issueNewBonds(uint256 bondGr ...
•    - function reverseBondToETH(uint256 bon ...
•    - function exchangeEquivalentBonds(
•    - function liquidateBond(uint256 bondGr ...
•    - function getBond(bytes32 bondID)
•    - function getFnMap(bytes32 fnMapID)
•    - function getBondGroup(uint256 bondGro ...
•    - function generateBondID(uint256 matur ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• interface StableCoinInterface is IERC ...
•    - function getPoolInfo(bytes32 poolID)
•    - function solidValueTotal()
•    - function isAcceptableSBT(bytes32 bond ...
•    - function mint(
•    - function burnFrom(address account, ui ...
•    - function unlockSBT(bytes32 bondID, ui ...
•    - function startAuctionOnMaturity(bytes ...
•    - function startAuctionByMarket(bytes32 ...
•    - function setSettledAverageAuctionPric ...
•    - function calcSBT2IDOL(uint256 solidBo ...
•    - function returnLockedPool(bytes32[] c ...
•    - function returnLockedPoolTo(bytes32[] ...
•    - function generatePoolID(bytes32 bondI ...
•    - function getCurrentPoolID(bytes32 bon ...
•    - function getLockedPool(address user, ...
•    - function _transferIDOLFrom(
•    - function _transferIDOL(address to, ui ...
•    - function _transferIDOL(
• interface LBTExchangeFactoryInterface
•    - function launchExchange(
•    - function addressToExchangeLookup(addr ...
•    - function bondIDToExchangeLookup(bytes ...
•    - function initializeExchange(
• interface WrapperInterface
•    - function registerBondAndBondGroup(byt ...
•    - function swapSBT2LBT(
•    - function issueLBTAndIDOL(uint256 bond ...
•    - function issueIDOLOnly(
•    - function issueLBTOnly(
•  contract Context
•    - function _msgSender()
•    - function _msgData()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•  contract ERC20 is Context, IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(address ...
• interface TransferETHInterface
• interface BondTokenInterface is Trans ...
•    - function mint(address account, uint25 ...
•    - function expire(uint128 rateNumerator ...
•    - function burn(uint256 amount)
•    - function burnAll()
•    - function isMinter(address account)
•    - function getRate()
• library TokenLibrary
•    - function another(Token self)
• library OrderTypeLibrary
•    - function inToken(OrderType self)
•    - function isFlex(OrderType self)
•    - function isStrict(OrderType self)
•    - function next(OrderType self)
•    - function isBuy(OrderType self)
• interface BoxExchangeInterface
•    - function marketFeePool0()
•    - function marketFeePool1()
•    - function whenToExecute(
•    - function getExchangeData()
•    - function getBoxSummary(uint256 boxNum ...
•    - function getOrderAmount(address accou ...
•    - function initializeExchange(
•    - function orderBaseToSettlement(
•    - function orderSettlementToBase(
•    - function addLiquidity(
•    - function removeLiquidity(
•    - function executeUnexecutedBox(uint8 m ...
•    - function sendMarketFeeToLien()
•  contract Wrapper is *
•    - function setExchangeLBTAndIDOLFactory ...
•    - function _setExchangeLBTAndIDOLFactor ...
•    - function exchangeLBTAndIDOLFactoryAdd ...
•    - function registerBondAndBondGroup(byt ...
•    - function _swapSBT2IDOL(
•    - function _swapLBT2IDOL(
•    - function _swapIDOL2LBT(
•    - function swapSBT2LBT(
•    - function _swapSBT2LBT(
•    - function _findSBTAndLBTBondGroup(uint ...
•    - function _usesERC20(address erc20Addr ...
•    - function _reductionERC20(address erc2 ...
•    - function _findBondAddressListInBondGr ...
•    - function issueLBTAndIDOL(uint256 bond ...
•    - function issueIDOLOnly(
•    - function issueLBTOnly(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

pragma solidity 0.6.6;

// File: contracts/util/DeployerRole.sol


abstract contract DeployerRole {
    address internal immutable _deployer;

    modifier onlyDeployer() {
        require(
            _isDeployer(msg.sender),
            "only deployer is allowed to call this function"
        );
        _;
    }

    constructor() public {
        _deployer = msg.sender;
    }

    function _isDeployer(address account) internal view returns (bool) {
        return account == _deployer;
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol



/**
 * @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) {
        // Solidity only automatically asserts when dividing by 0
        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/math/SignedSafeMath.sol



/**
 * @title SignedSafeMath
 * @dev Signed math operations with safety checks that revert on error.
 */
library SignedSafeMath {
    int256 constant private _INT256_MIN = -2**255;

    /**
     * @dev Multiplies two signed integers, reverts on overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // 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;
        }

        require(!(a == -1 && b == _INT256_MIN), "SignedSafeMath: multiplication overflow");

        int256 c = a * b;
        require(c / a == b, "SignedSafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        require(b != 0, "SignedSafeMath: division by zero");
        require(!(b == -1 && a == _INT256_MIN), "SignedSafeMath: division overflow");

        int256 c = a / b;

        return c;
    }

    /**
     * @dev Subtracts two signed integers, reverts on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");

        return c;
    }

    /**
     * @dev Adds two signed integers, reverts on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");

        return c;
    }
}

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




/**
 * @dev Wrappers over Solidity's uintXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256 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} to extend it to smaller types, by performing
 * all math on `uint256` 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 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/math/UseSafeMath.sol







/**
 * @notice ((a - 1) / b) + 1 = (a + b -1) / b
 * for example a.add(10**18 -1).div(10**18) = a.sub(1).div(10**18) + 1
 */

library SafeMathDivRoundUp {
    using SafeMath for uint256;

    function divRoundUp(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        require(b > 0, errorMessage);
        return ((a - 1) / b) + 1;
    }

    function divRoundUp(uint256 a, uint256 b) internal pure returns (uint256) {
        return divRoundUp(a, b, "SafeMathDivRoundUp: modulo by zero");
    }
}


/**
 * @title UseSafeMath
 * @dev One can use SafeMath for not only uint256 but also uin64 or uint16,
 * and also can use SafeCast for uint256.
 * For example:
 *   uint64 a = 1;
 *   uint64 b = 2;
 *   a = a.add(b).toUint64() // `a` become 3 as uint64
 * In additionally, one can use SignedSafeMath and SafeCast.toUint256(int256) for int256.
 * In the case of the operation to the uint64 value, one need to cast the value into int256 in
 * advance to use `sub` as SignedSafeMath.sub not SafeMath.sub.
 * For example:
 *   int256 a = 1;
 *   uint64 b = 2;
 *   int256 c = 3;
 *   a = a.add(int256(b).sub(c)); // `a` become 0 as int256
 *   b = a.toUint256().toUint64(); // `b` become 0 as uint64
 */
abstract contract UseSafeMath {
    using SafeMath for uint256;
    using SafeMathDivRoundUp for uint256;
    using SafeMath for uint64;
    using SafeMathDivRoundUp for uint64;
    using SafeMath for uint16;
    using SignedSafeMath for int256;
    using SafeCast for uint256;
    using SafeCast for int256;
}

// File: contracts/oracle/OracleInterface.sol


// Oracle referenced by OracleProxy must implement this interface.
interface OracleInterface {
    // Returns if oracle is running.
    function alive() external view returns (bool);

    // Returns latest id.
    // The first id is 1 and 0 value is invalid as id.
    // Each price values and theirs timestamps are identified by id.
    // Ids are assigned incrementally to values.
    function latestId() external returns (uint256);

    // Returns latest price value.
    // decimal 8
    function latestPrice() external returns (uint256);

    // Returns timestamp of latest price.
    function latestTimestamp() external returns (uint256);

    // Returns price of id.
    function getPrice(uint256 id) external returns (uint256);

    // Returns timestamp of id.
    function getTimestamp(uint256 id) external returns (uint256);

    function getVolatility() external returns (uint256);
}

// File: contracts/oracle/UseOracle.sol


abstract contract UseOracle {
    OracleInterface internal _oracleContract;

    constructor(address contractAddress) public {
        require(
            contractAddress != address(0),
            "contract should be non-zero address"
        );
        _oracleContract = OracleInterface(contractAddress);
    }

    /// @notice Get the latest USD/ETH price and historical volatility using oracle.
    /// @return rateETH2USDE8 (10^-8 USD/ETH)
    /// @return volatilityE8 (10^-8)
    function _getOracleData()
        internal
        returns (uint256 rateETH2USDE8, uint256 volatilityE8)
    {
        rateETH2USDE8 = _oracleContract.latestPrice();
        volatilityE8 = _oracleContract.getVolatility();

        return (rateETH2USDE8, volatilityE8);
    }

    /// @notice Get the price of the oracle data with a minimum timestamp that does more than input value
    /// when you know the ID you are looking for.
    /// @param timestamp is the timestamp that you want to get price.
    /// @param hintID is the ID of the oracle data you are looking for.
    /// @return rateETH2USDE8 (10^-8 USD/ETH)
    function _getPriceOn(uint256 timestamp, uint256 hintID)
        internal
        returns (uint256 rateETH2USDE8)
    {
        uint256 latestID = _oracleContract.latestId();
        require(
            latestID != 0,
            "system error: the ID of oracle data should not be zero"
        );

        require(hintID != 0, "the hint ID must not be zero");
        uint256 id = hintID;
        if (hintID > latestID) {
            id = latestID;
        }

        require(
            _oracleContract.getTimestamp(id) > timestamp,
            "there is no price data after maturity"
        );

        id--;
        while (id != 0) {
            if (_oracleContract.getTimestamp(id) <= timestamp) {
                break;
            }
            id--;
        }

        return _oracleContract.getPrice(id + 1);
    }
}

// File: contracts/BondMakerInterface.sol


interface BondMakerInterface {
    event LogNewBond(
        bytes32 indexed bondID,
        address bondTokenAddress,
        uint64 stableStrikePrice,
        bytes32 fnMapID
    );

    event LogNewBondGroup(uint256 indexed bondGroupID);

    event LogIssueNewBonds(
        uint256 indexed bondGroupID,
        address indexed issuer,
        uint256 amount
    );

    event LogReverseBondToETH(
        uint256 indexed bondGroupID,
        address indexed owner,
        uint256 amount
    );

    event LogExchangeEquivalentBonds(
        address indexed owner,
        uint256 indexed inputBondGroupID,
        uint256 indexed outputBondGroupID,
        uint256 amount
    );

    event LogTransferETH(
        address indexed from,
        address indexed to,
        uint256 value
    );

    function registerNewBond(uint256 maturity, bytes calldata fnMap)
        external
        returns (
            bytes32 bondID,
            address bondTokenAddress,
            uint64 solidStrikePrice,
            bytes32 fnMapID
        );

    function registerNewBondGroup(
        bytes32[] calldata bondIDList,
        uint256 maturity
    ) external returns (uint256 bondGroupID);

    function issueNewBonds(uint256 bondGroupID)
        external
        payable
        returns (uint256 amount);

    function reverseBondToETH(uint256 bondGroupID, uint256 amount)
        external
        returns (bool success);

    function exchangeEquivalentBonds(
        uint256 inputBondGroupID,
        uint256 outputBondGroupID,
        uint256 amount,
        bytes32[] calldata exceptionBonds
    ) external returns (bool);

    function liquidateBond(uint256 bondGroupID, uint256 oracleHintID) external;

    function getBond(bytes32 bondID)
        external
        view
        returns (
            address bondAddress,
            uint256 maturity,
            uint64 solidStrikePrice,
            bytes32 fnMapID
        );

    function getFnMap(bytes32 fnMapID)
        external
        view
        returns (bytes memory fnMap);

    function getBondGroup(uint256 bondGroupID)
        external
        view
        returns (bytes32[] memory bondIDs, uint256 maturity);

    function generateBondID(uint256 maturity, bytes calldata functionHash)
        external
        pure
        returns (bytes32 bondID);
}

// File: contracts/UseBondMaker.sol





abstract contract UseBondMaker {
    BondMakerInterface internal immutable _bondMakerContract;

    constructor(address contractAddress) public {
        require(
            contractAddress != address(0),
            "contract should be non-zero address"
        );
        _bondMakerContract = BondMakerInterface(payable(contractAddress));
    }
}

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



/**
 * @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: contracts/StableCoinInterface.sol





interface StableCoinInterface is IERC20 {
    event LogIsAcceptableSBT(bytes32 indexed bondID, bool isAcceptable);

    event LogMintIDOL(
        bytes32 indexed bondID,
        address indexed owner,
        bytes32 poolID,
        uint256 obtainIDOLAmount,
        uint256 poolIDOLAmount
    );

    event LogBurnIDOL(
        bytes32 indexed bondID, // poolID?
        address indexed owner,
        uint256 burnIDOLAmount,
        uint256 unlockSBTAmount
    );

    event LogReturnLockedPool(
        bytes32 indexed poolID,
        address indexed owner,
        uint64 backIDOLAmount
    );

    event LogLambda(
        bytes32 indexed poolID,
        uint64 settledAverageAuctionPrice,
        uint256 totalSupply,
        uint256 lockedSBTValue
    );

    function getPoolInfo(bytes32 poolID)
        external
        view
        returns (
            uint64 lockedSBTTotal,
            uint64 unlockedSBTTotal,
            uint64 lockedPoolIDOLTotal,
            uint64 burnedIDOLTotal,
            uint64 soldSBTTotalInAuction,
            uint64 paidIDOLTotalInAuction,
            uint64 settledAverageAuctionPrice,
            bool isAllAmountSoldInAuction
        );

    function solidValueTotal() external view returns (uint256 solidValue);

    function isAcceptableSBT(bytes32 bondID) external returns (bool ok);

    function mint(
        bytes32 bondID,
        address recipient,
        uint64 lockAmount
    )
        external
        returns (
            bytes32 poolID,
            uint64 obtainIDOLAmount,
            uint64 poolIDOLAmount
        );

    function burnFrom(address account, uint256 amount) external;

    function unlockSBT(bytes32 bondID, uint64 burnAmount)
        external
        returns (uint64 rewardSBT);

    function startAuctionOnMaturity(bytes32 bondID) external;

    function startAuctionByMarket(bytes32 bondID) external;

    function setSettledAverageAuctionPrice(
        bytes32 bondID,
        uint64 totalPaidIDOL,
        uint64 SBTAmount,
        bool isLast
    ) external;

    function calcSBT2IDOL(uint256 solidBondAmount)
        external
        view
        returns (uint256 IDOLAmount);

    function returnLockedPool(bytes32[] calldata poolIDs)
        external
        returns (uint64 IDOLAmount);

    function returnLockedPoolTo(bytes32[] calldata poolIDs, address account)
        external
        returns (uint64 IDOLAmount);

    function generatePoolID(bytes32 bondID, uint64 count)
        external
        pure
        returns (bytes32 poolID);

    function getCurrentPoolID(bytes32 bondID)
        external
        view
        returns (bytes32 poolID);

    function getLockedPool(address user, bytes32 poolID)
        external
        view
        returns (uint64, uint64);
}

// File: contracts/UseStableCoin.sol





abstract contract UseStableCoin {
    StableCoinInterface internal immutable _IDOLContract;

    constructor(address contractAddress) public {
        require(
            contractAddress != address(0),
            "contract should be non-zero address"
        );
        _IDOLContract = StableCoinInterface(contractAddress);
    }

    function _transferIDOLFrom(
        address from,
        address to,
        uint256 amount
    ) internal {
        _IDOLContract.transferFrom(from, to, amount);
    }

    function _transferIDOL(address to, uint256 amount) internal {
        _IDOLContract.transfer(to, amount);
    }

    function _transferIDOL(
        address to,
        uint256 amount,
        string memory errorMessage
    ) internal {
        require(_IDOLContract.balanceOf(address(this)) >= amount, errorMessage);
        _IDOLContract.transfer(to, amount);
    }
}

// File: contracts/fairswap/LBTExchangeFactoryInterface.sol




interface LBTExchangeFactoryInterface {
    /**
     * @notice Launches new exchange
     * @param bondGroupId ID of bondgroup which target LBT belongs to
     * @param place The place of target bond in the bondGroup
     * @param IDOLAmount Initial liquidity of iDOL
     * @param LBTAmount Initial liquidity of LBT
     * @dev Get strikeprice and maturity from bond maker contract
     **/
    function launchExchange(
        uint256 bondGroupId,
        uint256 place,
        uint256 IDOLAmount,
        uint256 LBTAmount
    ) external returns (address);

    /**
     * @notice Gets exchange address from Address of LBT
     * @param tokenAddress Address of LBT
     **/
    function addressToExchangeLookup(address tokenAddress)
        external
        view
        returns (address exchange);

    /**
     * @notice Gets exchange address from BondID of LBT
     * @param bondID
     **/
    function bondIDToExchangeLookup(bytes32 bondID)
        external
        view
        returns (address exchange);

    /**
     * @dev Initial supply of share token is equal to amount of iDOL
     * @dev If there is no share token, user can reinitialize exchange
     * @param token Address of LBT
     * @param IDOLAmount Amount of idol to be provided
     * @param LBTAmount Amount of LBT to be provided
     **/
    function initializeExchange(
        address token,
        uint256 IDOLAmount,
        uint256 LBTAmount
    ) external;
}

// File: contracts/WrapperInterface.sol


pragma experimental ABIEncoderV2;


interface WrapperInterface {
    event LogRegisterBondAndBondGroup(
        uint256 indexed bondGroupID,
        bytes32[] bondIDs
    );
    event LogIssueIDOL(
        bytes32 indexed bondID,
        address indexed sender,
        bytes32 poolID,
        uint256 amount
    );

    event LogIssueLBT(
        bytes32 indexed bondID,
        address indexed sender,
        uint256 amount
    );

    function registerBondAndBondGroup(bytes[] calldata fnMaps, uint256 maturity)
        external
        returns (bool);

    /**
     * @notice swap (SBT -> LBT)
     * @param solidBondID is a solid bond ID
     * @param liquidBondID is a liquid bond ID
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function swapSBT2LBT(
        bytes32 solidBondID,
        bytes32 liquidBondID,
        uint256 SBTAmount,
        uint256 timeout,
        bool isLimit
    ) external;

    /**
     * @notice ETH -> LBT & iDOL
     * @param bondGroupID is a bond group ID
     * @return poolID is a pool ID
     * @return liquidBondAmount is LBT amount obtained
     * @return IDOLAmount is iDOL amount obtained
     */
    function issueLBTAndIDOL(uint256 bondGroupID)
        external
        payable
        returns (
            bytes32 poolID,
            uint256 liquidBondAmount,
            uint256 IDOLAmount
        );

    /**
     * @notice ETH -> iDOL
     * @param bondGroupID is a bond group ID
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function issueIDOLOnly(
        uint256 bondGroupID,
        uint256 timeout,
        bool isLimit
    ) external payable;

    /**
     * @notice ETH -> LBT
     * @param bondGroupID is a bond group ID
     * @param liquidBondID is a liquid bond ID
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function issueLBTOnly(
        uint256 bondGroupID,
        bytes32 liquidBondID,
        uint256 timeout,
        bool isLimit
    ) external payable;
}

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



/*
 * @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.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }

    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/utils/Address.sol


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

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

/**
 * @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 {ERC20MinterPauser}.
 *
 * 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: contracts/util/TransferETHInterface.sol




interface TransferETHInterface {
    receive() external payable;

    event LogTransferETH(
        address indexed from,
        address indexed to,
        uint256 value
    );
}

// File: contracts/bondToken/BondTokenInterface.sol






interface BondTokenInterface is TransferETHInterface, IERC20 {
    event LogExpire(
        uint128 rateNumerator,
        uint128 rateDenominator,
        bool firstTime
    );

    function mint(address account, uint256 amount)
        external
        returns (bool success);

    function expire(uint128 rateNumerator, uint128 rateDenominator)
        external
        returns (bool firstTime);

    function burn(uint256 amount) external returns (bool success);

    function burnAll() external returns (uint256 amount);

    function isMinter(address account) external view returns (bool minter);

    function getRate()
        external
        view
        returns (uint128 rateNumerator, uint128 rateDenominator);
}

// File: contracts/fairswap/Libraries/Enums.sol



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/fairswap/BoxExchangeInterface.sol


interface BoxExchangeInterface {
    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
    );

    function marketFeePool0() external view returns (uint128);

    function marketFeePool1() external view returns (uint128);

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

    /**
     * @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
        view
        returns (
            uint256 boxNumber,
            uint256 _reserve0,
            uint256 _reserve1,
            uint256 totalShare,
            uint256 latestSpreadRate,
            uint256 token0PerShareE18,
            uint256 token1PerShareE18
        );

    /**
     * @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)
        external
        view
        returns (
            uint256 executionStatusNumber,
            uint256 flexToken0InAmount,
            uint256 strictToken0InAmount,
            uint256 flexToken1InAmount,
            uint256 strictToken1InAmount
        );

    /**
     * @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)
        external
        view
        returns (uint256);

    /**
     * @param IDOLAmount Amount of initial liquidity of iDOL to be provided
     * @param settlementTokenAmount Amount of initial liquidity of the other token to be provided
     * @param initialShare Initial amount of share token
     **/
    function initializeExchange(
        uint256 IDOLAmount,
        uint256 settlementTokenAmount,
        uint256 initialShare
    ) external;

    /**
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param recipient Recipient of swapped token. If `recipient` == address(0), recipient is msg.sender
     * @param IDOLAmount 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 orderBaseToSettlement(
        uint256 timeout,
        address recipient,
        uint256 IDOLAmount,
        bool isLimit
    ) external;

    /**
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param recipient Recipient of swapped token. If `recipient` == address(0), recipient is msg.sender
     * @param settlementTokenAmount 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 * 0.999 > `rate`, the order will be executed, otherwise token will be refunded
     * @dev if isLimit is false and reserve0/reserve1 * 0.95 > `rate`, the order will be executed, otherwise token will be refunded
     **/
    function orderSettlementToBase(
        uint256 timeout,
        address recipient,
        uint256 settlementTokenAmount,
        bool isLimit
    ) external;

    /**
     * @notice LP provides liquidity and receives share token
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param IDOLAmount Amount of iDOL to be provided. The amount of the other token required is calculated based on this amount
     * @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 IDOLAmount,
        uint256 settlementTokenAmount,
        uint256 minShares
    ) external;

    /**
     * @notice LP burns share token and receives iDOL and the other token
     * @param timeout Revert if nextBoxNumber exceeds `timeout`
     * @param minBaseTokens Minimum amount of iDOL LP will receive. If amount of iDOL is less than `minBaseTokens`, revert the transaction
     * @param minSettlementTokens Minimum amount of the other token LP will get. If amount is less than `minSettlementTokens`, revert the transaction
     * @param sharesBurned Amount of share token to be burned
     **/
    function removeLiquidity(
        uint256 timeout,
        uint256 minBaseTokens,
        uint256 minSettlementTokens,
        uint256 sharesBurned
    ) external;

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

    function sendMarketFeeToLien() external;
}

// File: contracts/Wrapper.sol

// solium-disable security/no-low-level-calls

contract Wrapper is
    DeployerRole,
    UseSafeMath,
    UseOracle,
    UseBondMaker,
    UseStableCoin,
    WrapperInterface
{
    LBTExchangeFactoryInterface internal _exchangeLBTAndIDOLFactoryContract;

    modifier isNotEmptyExchangeInstance() {
        require(
            address(_exchangeLBTAndIDOLFactoryContract) != address(0),
            "the exchange contract is not set"
        );
        _;
    }

    constructor(
        address oracleAddress,
        address bondMakerAddress,
        address IDOLAddress,
        address exchangeLBTAndIDOLFactoryAddress
    )
        public
        UseOracle(oracleAddress)
        UseBondMaker(bondMakerAddress)
        UseStableCoin(IDOLAddress)
    {
        _setExchangeLBTAndIDOLFactory(exchangeLBTAndIDOLFactoryAddress);
    }

    function setExchangeLBTAndIDOLFactory(address contractAddress)
        public
        onlyDeployer
    {
        require(
            address(_exchangeLBTAndIDOLFactoryContract) == address(0),
            "contract has already given"
        );
        require(
            contractAddress != address(0),
            "contract should be non-zero address"
        );
        _setExchangeLBTAndIDOLFactory(contractAddress);
    }

    function _setExchangeLBTAndIDOLFactory(address contractAddress) internal {
        _exchangeLBTAndIDOLFactoryContract = LBTExchangeFactoryInterface(
            contractAddress
        );
    }

    function exchangeLBTAndIDOLFactoryAddress() public view returns (address) {
        return address(_exchangeLBTAndIDOLFactoryContract);
    }

    function registerBondAndBondGroup(bytes[] memory fnMaps, uint256 maturity)
        public
        override
        returns (bool)
    {
        bytes32[] memory bondIDs = new bytes32[](fnMaps.length);
        for (uint256 j = 0; j < fnMaps.length; j++) {
            bytes32 bondID = _bondMakerContract.generateBondID(
                maturity,
                fnMaps[j]
            );
            (address bondAddress, , , ) = _bondMakerContract.getBond(bondID);
            if (bondAddress == address(0)) {
                (bytes32 returnedBondID, , , ) = _bondMakerContract
                    .registerNewBond(maturity, fnMaps[j]);
                require(
                    returnedBondID == bondID,
                    "system error: bondID was not generated as expected"
                );
            }
            bondIDs[j] = bondID;
        }

        uint256 bondGroupID = _bondMakerContract.registerNewBondGroup(
            bondIDs,
            maturity
        );
        emit LogRegisterBondAndBondGroup(bondGroupID, bondIDs);
    }

    /**
     * @param solidBondID is a solid bond ID
     * @param SBTAmount is solid bond token amount
     * @return poolID is a pool ID
     * @return IDOLAmount is iDOL amount obtained
     */
    function _swapSBT2IDOL(
        bytes32 solidBondID,
        address SBTAddress,
        uint256 SBTAmount
    ) internal returns (bytes32 poolID, uint256 IDOLAmount) {
        // 1. approve
        ERC20(SBTAddress).approve(address(_IDOLContract), SBTAmount);

        // 2. mint (SBT -> iDOL)
        (poolID, IDOLAmount, ) = _IDOLContract.mint(
            solidBondID,
            msg.sender,
            SBTAmount.toUint64()
        );

        emit LogIssueIDOL(solidBondID, msg.sender, poolID, IDOLAmount);
        return (poolID, IDOLAmount);
    }

    /**
     * @notice swap (LBT -> iDOL)
     * @param LBTAddress is liquid bond token contract address
     * @param LBTAmount is liquid bond amount
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function _swapLBT2IDOL(
        address LBTAddress,
        uint256 LBTAmount,
        uint256 timeout,
        bool isLimit
    ) internal isNotEmptyExchangeInstance {
        address _boxExchangeAddress = _exchangeLBTAndIDOLFactoryContract
            .addressToExchangeLookup(LBTAddress);
        // 1. approve
        ERC20(LBTAddress).approve(_boxExchangeAddress, LBTAmount);

        // 2. order(exchange)
        BoxExchangeInterface exchange = BoxExchangeInterface(
            _boxExchangeAddress
        );
        exchange.orderSettlementToBase(timeout, msg.sender, LBTAmount, isLimit);
    }

    /**
     * @notice swap (iDOL -> LBT)
     * @param LBTAddress is liquid bond token contract address
     * @param IDOLAmount is iDOL amount
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function _swapIDOL2LBT(
        address LBTAddress,
        uint256 IDOLAmount,
        uint256 timeout,
        bool isLimit
    ) internal isNotEmptyExchangeInstance {
        address _boxExchangeAddress = _exchangeLBTAndIDOLFactoryContract
            .addressToExchangeLookup(LBTAddress);

        // 1. approve
        _IDOLContract.transferFrom(msg.sender, address(this), IDOLAmount);
        _IDOLContract.approve(_boxExchangeAddress, IDOLAmount);

        // 2. order(exchange)
        BoxExchangeInterface exchange = BoxExchangeInterface(
            _boxExchangeAddress
        );
        exchange.orderBaseToSettlement(
            timeout,
            msg.sender,
            IDOLAmount,
            isLimit
        );
    }

    /**
     * @notice swap (SBT -> LBT)
     * @param solidBondID is a solid bond ID
     * @param liquidBondID is a liquid bond ID
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function swapSBT2LBT(
        bytes32 solidBondID,
        bytes32 liquidBondID,
        uint256 SBTAmount,
        uint256 timeout,
        bool isLimit
    ) public override {
        (address SBTAddress, , , ) = _bondMakerContract.getBond(solidBondID);
        require(SBTAddress != address(0), "the bond is not registered");

        // uses: SBT
        _usesERC20(SBTAddress, SBTAmount);

        // 1. SBT -> LBT(exchange)
        _swapSBT2LBT(
            solidBondID,
            SBTAddress,
            liquidBondID,
            SBTAmount,
            timeout,
            isLimit
        );
    }

    function _swapSBT2LBT(
        bytes32 solidBondID,
        address SBTAddress,
        bytes32 liquidBondID,
        uint256 SBTAmount,
        uint256 timeout,
        bool isLimit
    ) internal {
        // 1. swap SBT -> IDOL)
        (, uint256 IDOLAmount) = _swapSBT2IDOL(
            solidBondID,
            SBTAddress,
            SBTAmount
        );

        // 2. swap IDOL -> LBT(exchange)
        (address LBTAddress, , , ) = _bondMakerContract.getBond(liquidBondID);
        require(LBTAddress != address(0), "the bond is not registered");

        _swapIDOL2LBT(LBTAddress, IDOLAmount, timeout, isLimit);
    }

    /**
     * @notice find a solid bond in given bond group
     * @param bondGroupID is a bond group ID
     */
    function _findSBTAndLBTBondGroup(uint256 bondGroupID)
        internal
        view
        returns (bytes32 solidBondID, bytes32[] memory liquidBondIDs)
    {
        (bytes32[] memory bondIDs, ) = _bondMakerContract.getBondGroup(
            bondGroupID
        );
        bytes32 solidID = bytes32(0);
        bytes32[] memory liquidIDs = new bytes32[](bondIDs.length - 1);
        uint256 j = 0;
        for (uint256 i = 0; i < bondIDs.length; i++) {
            (, , uint256 solidStrikePrice, ) = _bondMakerContract.getBond(
                bondIDs[i]
            );
            if (solidStrikePrice != 0) {
                // A solid bond is found.
                solidID = bondIDs[i];
            } else {
                liquidIDs[j++] = bondIDs[i];
            }
        }
        return (solidID, liquidIDs);
    }

    function _usesERC20(address erc20Address, uint256 amount) internal {
        ERC20 erc20Contract = ERC20(erc20Address);
        erc20Contract.transferFrom(msg.sender, address(this), amount);
    }

    function _reductionERC20(address erc20Address, uint256 amount) internal {
        ERC20 erc20Contract = ERC20(erc20Address);
        erc20Contract.transfer(msg.sender, amount);
    }

    function _findBondAddressListInBondGroup(uint256 bondGroupID)
        internal
        view
        returns (address[] memory bondAddressList)
    {
        (bytes32[] memory bondIDs, ) = _bondMakerContract.getBondGroup(
            bondGroupID
        );
        address[] memory bondAddreses = new address[](bondIDs.length);
        for (uint256 i = 0; i < bondIDs.length; i++) {
            (address bondTokenAddress, , , ) = _bondMakerContract.getBond(
                bondIDs[i]
            );
            bondAddreses[i] = bondTokenAddress;
        }
        return bondAddreses;
    }

    /**
     * @notice ETH -> LBT & iDOL
     * @param bondGroupID is a bond group ID
     * @return poolID is a pool ID
     * @return IDOLAmount is iDOL amount obtained
     */
    function issueLBTAndIDOL(uint256 bondGroupID)
        public
        override
        payable
        returns (
            bytes32,
            uint256,
            uint256
        )
    {
        (
            bytes32 solidBondID,
            bytes32[] memory liquidBondIDs
        ) = _findSBTAndLBTBondGroup(bondGroupID); // find SBT & LBT
        require(
            solidBondID != bytes32(0),
            "solid bond is not found in given bond group"
        );

        // 1. ETH -> SBT & LBTs
        uint256 bondAmount = _bondMakerContract.issueNewBonds{value: msg.value}(
            bondGroupID
        );

        // 2. SBT -> IDOL
        (address SBTAddress, , , ) = _bondMakerContract.getBond(solidBondID);
        (bytes32 poolID, uint256 IDOLAmount) = _swapSBT2IDOL(
            solidBondID,
            SBTAddress,
            bondAmount
        );

        // 3. IDOL reduction.
        //_reductionERC20(address(_IDOLContract), IDOLAmount);

        // 4. LBTs reduction.
        for (uint256 i = 0; i < liquidBondIDs.length; i++) {
            (address liquidAddress, , , ) = _bondMakerContract.getBond(
                liquidBondIDs[i]
            );
            _reductionERC20(liquidAddress, bondAmount);
            LogIssueLBT(liquidBondIDs[i], msg.sender, bondAmount);
        }
        return (poolID, bondAmount, IDOLAmount);
    }

    /**
     * @notice ETH -> iDOL
     * @param bondGroupID is a bond group ID
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function issueIDOLOnly(
        uint256 bondGroupID,
        uint256 timeout,
        bool isLimit
    ) public override payable {
        // 0. uses: ETH
        (
            bytes32 solidBondID,
            bytes32[] memory liquidBondIDs
        ) = _findSBTAndLBTBondGroup(bondGroupID); // find SBT & LBT
        require(
            solidBondID != bytes32(0),
            "solid bond is not found in given bond group"
        );

        // 1. ETH -> SBT & LBTs
        uint256 bondAmount = _bondMakerContract.issueNewBonds{value: msg.value}(
            bondGroupID
        );

        // 2. SBT -> IDOL
        (address SBTAddress, , , ) = _bondMakerContract.getBond(solidBondID);
        _swapSBT2IDOL(solidBondID, SBTAddress, bondAmount);

        // 3. IDOL reduction.
        //_reductionERC20(address(_IDOLContract), IDOLAmount);

        // 4. LBTs -> IDOL(+exchange)
        for (uint256 i = 0; i < liquidBondIDs.length; i++) {
            (address liquidAddress, , , ) = _bondMakerContract.getBond(
                liquidBondIDs[i]
            );
            // LBT -> IDOL(+exchange)
            _swapLBT2IDOL(liquidAddress, bondAmount, timeout, isLimit);
        }
    }

    /**
     * @notice ETH -> LBT
     * @param bondGroupID is a bond group ID
     * @param liquidBondID is a liquid bond ID
     * @param timeout (uniswap)
     * @param isLimit (uniswap)
     */
    function issueLBTOnly(
        uint256 bondGroupID,
        bytes32 liquidBondID,
        uint256 timeout,
        bool isLimit
    ) public override payable {
        (
            bytes32 solidBondID,
            bytes32[] memory liquidBondIDs
        ) = _findSBTAndLBTBondGroup(bondGroupID); // find SBT & LBT
        require(
            solidBondID != bytes32(0),
            "solid bond is not found in given bond group"
        );

        // 1. ETH -> SBT & LBTs
        uint256 bondAmount = _bondMakerContract.issueNewBonds{value: msg.value}(
            bondGroupID
        );

        // 2. SBT -> IDOL
        (address SBTAddress, , , ) = _bondMakerContract.getBond(solidBondID);
        (, uint256 IDOLAmount) = _swapSBT2IDOL(
            solidBondID,
            SBTAddress,
            bondAmount
        );

        // 3. IDOL -> LBT(+exchange)
        (address LBTAddress, , , ) = _bondMakerContract.getBond(liquidBondID);
        _swapIDOL2LBT(LBTAddress, IDOLAmount, timeout, isLimit);

        // 4. LBTs reduction
        for (uint256 i = 0; i < liquidBondIDs.length; i++) {
            (address liquidAddress, , , ) = _bondMakerContract.getBond(
                liquidBondIDs[i]
            );
            _reductionERC20(liquidAddress, bondAmount);
            LogIssueLBT(liquidBondIDs[i], msg.sender, bondAmount);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"oracleAddress","type":"address"},{"internalType":"address","name":"bondMakerAddress","type":"address"},{"internalType":"address","name":"IDOLAddress","type":"address"},{"internalType":"address","name":"exchangeLBTAndIDOLFactoryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"bondID","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"poolID","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogIssueIDOL","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"bondID","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogIssueLBT","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"indexed":false,"internalType":"bytes32[]","name":"bondIDs","type":"bytes32[]"}],"name":"LogRegisterBondAndBondGroup","type":"event"},{"inputs":[],"name":"exchangeLBTAndIDOLFactoryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"bool","name":"isLimit","type":"bool"}],"name":"issueIDOLOnly","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"}],"name":"issueLBTAndIDOL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"internalType":"bytes32","name":"liquidBondID","type":"bytes32"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"bool","name":"isLimit","type":"bool"}],"name":"issueLBTOnly","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"fnMaps","type":"bytes[]"},{"internalType":"uint256","name":"maturity","type":"uint256"}],"name":"registerBondAndBondGroup","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"}],"name":"setExchangeLBTAndIDOLFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"solidBondID","type":"bytes32"},{"internalType":"bytes32","name":"liquidBondID","type":"bytes32"},{"internalType":"uint256","name":"SBTAmount","type":"uint256"},{"internalType":"uint256","name":"timeout","type":"uint256"},{"internalType":"bool","name":"isLimit","type":"bool"}],"name":"swapSBT2LBT","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000120a078fdc516a1a98bbecb9e961f8741ac7ac820000000000000000000000008b24f5c764ab741bc8a2426505bda458c30df0100000000000000000000000007591a309df68bf43ba42dd11b0344220a260020a0000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : oracleAddress (address): 0x120a078FdC516A1A98bbecb9e961F8741AC7ac82
Arg [1] : bondMakerAddress (address): 0x8B24F5C764AB741Bc8a2426505BDa458C30dF010
Arg [2] : IDOLAddress (address): 0x7591a309Df68bf43ba42dD11b0344220A260020A
Arg [3] : exchangeLBTAndIDOLFactoryAddress (address): 0x0000000000000000000000000000000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000120a078fdc516a1a98bbecb9e961f8741ac7ac82
Arg [1] : 0000000000000000000000008b24f5c764ab741bc8a2426505bda458c30df010
Arg [2] : 0000000000000000000000007591a309df68bf43ba42dd11b0344220a260020a
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000

55111:13430:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;60671:629:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;60671:629:0;;;;;;;;:::i;:::-;;65708:1222;;;;;;;;;:::i;56741:1078::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;56741:1078:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;64137:1405;;;;;;;;;:::i;:::-;;;;;;;;;;55937:440;;5:9:-1;2:2;;;27:1;24;17:12;2:2;-1:-1;55937:440:0;;;;;;;;:::i;67143:1395::-;;;;;;;;;:::i;56590:143::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;56590:143:0;;;:::i;:::-;;;;;;;;60671:629;60893:39;;;;;60865:18;;60893:26;:18;:26;;;;:39;;60920:11;;60893:39;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;60893:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;60893:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;60893:39:0;;;;;;;;;-1:-1:-1;60864:68:0;;-1:-1:-1;;;60951:24:0;;;60943:63;;;;;;;;;;;;;;;;;;;;;;61041:33;61052:10;61064:9;61041:10;:33::i;:::-;61123:169;61150:11;61176:10;61201:12;61228:9;61252:7;61274;61123:12;:169::i;:::-;60671:629;;;;;;:::o;65708:1222::-;65892:19;65926:30;65970:36;65994:11;65970:23;:36::i;:::-;65877:129;;-1:-1:-1;65877:129:0;-1:-1:-1;66057:25:0;66035:118;;;;;;;;;;;;;;66199:18;66220;:32;;;66260:9;66285:11;66220:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;66220:87:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;66220:87: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;66220:87:0;;;;;;;;;66199:108;;66348:18;66376;:26;;;66403:11;66376:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;66376:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;66376:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;66376:39:0;;;;;;;;;66347:68;;;;;66426:50;66440:11;66453:10;66465;66426:13;:50::i;:::-;-1:-1:-1;66630:9:0;;-1:-1:-1;66625:298:0;66649:13;:20;66645:1;:24;66625:298;;;66692:21;66723:18;:26;;;66768:13;66782:1;66768:16;;;;;;;;;;;;;;66723:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;66723:76:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;66723:76: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;66723:76:0;;;;;;;;;66691:108;;;;;66853:58;66867:13;66882:10;66894:7;66903;66853:13;:58::i;:::-;-1:-1:-1;66671:3:0;;66625:298;;;;65708:1222;;;;;;;:::o;56741:1078::-;56868:4;56890:24;56931:6;:13;56917:28;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;56917:28:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;144:17;;-1:-1;56917:28:0;-1:-1:-1;56890:55:0;-1:-1:-1;56961:9:0;56956:661;56980:6;:13;56976:1;:17;56956:661;;;57015:14;57032:18;:33;;;57084:8;57111:6;57118:1;57111:9;;;;;;;;;;;;;;57032:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57032:103:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57032:103: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;57032:103:0;;;;;;;;;57015:120;;57151:19;57180:18;:26;;;57207:6;57180:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57180:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57180:34: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;57180:34:0;;;;;;;;;-1:-1:-1;57150:64:0;;-1:-1:-1;;;57233:25:0;;;57229:343;;57280:22;57312:18;:56;;;57369:8;57379:6;57386:1;57379:9;;;;;;;;;;;;;;57312:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57312:77:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57312:77: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;57312:77:0;;;;;;;;;57279:110;;;;;57456:6;57438:14;:24;57408:148;;;;;;;;;;;;;;57229:343;;57599:6;57586:7;57594:1;57586:10;;;;;;;;;;;;;;;;;:19;-1:-1:-1;;56995:3:0;;56956:661;;;-1:-1:-1;57651:95:0;;;;;57629:19;;57651:39;:18;:39;;;;:95;;57705:7;;57727:8;;57651:95;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57651:95:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57651:95: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;57651:95:0;;;;;;;;;57629:117;;57790:11;57762:49;57803:7;57762:49;;;;;;;;;;;;;;;56741:1078;;;;;;:::o;64137:1405::-;64266:7;64288;64310;64360:19;64394:30;64438:36;64462:11;64438:23;:36::i;:::-;64345:129;;-1:-1:-1;64345:129:0;-1:-1:-1;64525:25:0;64503:118;;;;;;;;;;;;;;64667:18;64688;:32;;;64728:9;64753:11;64688:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;64688:87:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;64688:87: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;64688:87:0;;;;;;;;;64667:108;;64816:18;64844;:26;;;64871:11;64844:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;64844:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;64844:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;64844:39:0;;;;;;;;;64815:68;;;;;64895:14;64911:18;64933:100;64961:11;64987:10;65012;64933:13;:100::i;:::-;64894:139;;-1:-1:-1;64894:139:0;-1:-1:-1;65179:9:0;65174:311;65198:13;:20;65194:1;:24;65174:311;;;65241:21;65272:18;:26;;;65317:13;65331:1;65317:16;;;;;;;;;;;;;;65272:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;65272:76:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;65272:76: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;65272:76:0;;;;;;;;;65240:108;;;;;65363:42;65379:13;65394:10;65363:15;:42::i;:::-;65450:10;65420:53;;65432:13;65446:1;65432:16;;;;;;;;;;;;;;65420:53;65462:10;65420:53;;;;;;;;;;;;;;;-1:-1:-1;65220:3:0;;65174:311;;;-1:-1:-1;65503:6:0;;65511:10;;-1:-1:-1;65503:6:0;-1:-1:-1;64137:1405:0;;-1:-1:-1;;;;;64137:1405:0:o;55937:440::-;212:23;224:10;212:11;:23::i;:::-;190:119;;;;;;;;;;;;;;56084:34:::1;::::0;56076:57:::1;56084:34;56076:57:::0;56054:133:::1;;;;;;;;;;;;;;56220:29;::::0;::::1;56198:114;;;;;;;;;;;;;;56323:46;56353:15;56323:29;:46::i;:::-;55937:440:::0;:::o;67143:1395::-;67332:19;67366:30;67410:36;67434:11;67410:23;:36::i;:::-;67317:129;;-1:-1:-1;67317:129:0;-1:-1:-1;67497:25:0;67475:118;;;;;;;;;;;;;;67639:18;67660;:32;;;67700:9;67725:11;67660:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;67660:87:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;67660:87: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;67660:87:0;;;;;;;;;67639:108;;67788:18;67816;:26;;;67843:11;67816:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;67816:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;67816:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;67816:39:0;;;;;;;;;67787:68;;;;;67869:18;67891:100;67919:11;67945:10;67970;67891:13;:100::i;:::-;67866:125;;;68043:18;68071;:26;;;68098:12;68071:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;68071:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;68071:40: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;68071:40:0;;;;;;;;;68042:69;;;;;68122:55;68136:10;68148;68160:7;68169;68122:13;:55::i;:::-;68225:9;68220:311;68244:13;:20;68240:1;:24;68220:311;;;68287:21;68318:18;:26;;;68363:13;68377:1;68363:16;;;;;;;;;;;;;;68318:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;68318:76:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;68318:76: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;68318:76:0;;;;;;;;;68286:108;;;;;68409:42;68425:13;68440:10;68409:15;:42::i;:::-;68496:10;68466:53;;68478:13;68492:1;68478:16;;;;;;;;;;;;;;68466:53;68508:10;68466:53;;;;;;;;;;;;;;;-1:-1:-1;68266:3:0;;68220:311;;;;67143:1395;;;;;;;;;;:::o;56590:143::-;56690:34;;;;56590:143;:::o;62937:199::-;63067:61;;;;;63043:12;;63067:26;;;;;;:61;;63094:10;;63114:4;;63121:6;;63067:61;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;63067:61:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;63067:61: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;63067:61:0;;;;;;;;;;62937:199;;;:::o;61308:647::-;61560:18;61582:99;61610:11;61636:10;61661:9;61582:13;:99::i;:::-;61557:124;;;61737:18;61765;:26;;;61792:12;61765:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;61765:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;61765:40: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;61765:40:0;;;;;;;;;-1:-1:-1;61736:69:0;;-1:-1:-1;;;61824:24:0;;;61816:63;;;;;;;;;;;;;;61892:55;61906:10;61918;61930:7;61939;61892:13;:55::i;62081:848::-;62185:19;62206:30;62255:24;62285:18;:31;;;62331:11;62285:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;62285:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;62285:68:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;62285:68:0;80:15:-1;;;97:9;76:31;65:43;;120:4;113:20;62285:68:0;;;;;;;;;-1:-1:-1;62446:14:0;;62254:99;;-1:-1:-1;62364:15:0;;62403:26;;62446:18;;62432:33;;;2:2:-1;;;;27:1;24;17:12;2:2;62432:33:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;144:17;;-1:-1;62432:33:0;-1:-1:-1;62403:62:0;-1:-1:-1;62476:9:0;;62500:384;62524:7;:14;62520:1;:18;62500:384;;;62565:24;62595:18;:26;;;62640:7;62648:1;62640:10;;;;;;;;;;;;;;62595:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;62595:70:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;62595:70: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;62595:70:0;;;;;;;;;62560:105;;;;;;;62684:16;62704:1;62684:21;62680:193;;62779:7;62787:1;62779:10;;;;;;;;;;;;;;62769:20;;62680:193;;;62847:7;62855:1;62847:10;;;;;;;;;;;;;;62830:9;62840:3;;;;;;62830:14;;;;;;;;;;;;;:27;;;;;62680:193;-1:-1:-1;62540:3:0;;62500:384;;;-1:-1:-1;62902:7:0;;-1:-1:-1;62911:9:0;-1:-1:-1;;;62081:848:0;;;:::o;58030:573::-;58165:14;58181:18;58241:10;58235:25;;;58269:13;58285:9;58235:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;58235:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;58235:60: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;58235:60:0;;;;;;;;;;58367:13;:18;;;58400:11;58426:10;58451:20;:9;:18;:20::i;:::-;58367:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;58367:115:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;58367:115: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;58367:115:0;;;;;;;;;-1:-1:-1;58500:57:0;;58342:140;;-1:-1:-1;58342:140:0;;;-1:-1:-1;58526:10:0;;58513:11;;58500:57;;;;58342:140;;;;58500:57;;;;;;;;;;58030:573;;;;;;:::o;58841:619::-;55412:34;;55404:57;55412:34;55382:139;;;;;;;;;;;;;;59054:34:::1;::::0;:84:::1;::::0;;;;59024:27:::1;::::0;59054:34:::1;;::::0;:72:::1;::::0;:84:::1;::::0;59127:10;;59054:84:::1;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;59054:84:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;59054:84: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;59054:84:0;;;;;;;;;59172:57;::::0;;;;59024:114;;-1:-1:-1;59172:25:0::1;::::0;::::1;::::0;::::1;::::0;:57:::1;::::0;59024:114;;59219:9;;59172:57:::1;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;59172:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;59172:57: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;59172:57:0;;;;;;;;;-1:-1:-1::0;59381:71:0::1;::::0;;;;59340:19;;59381:30:::1;::::0;::::1;::::0;::::1;::::0;:71:::1;::::0;59412:7;;59421:10:::1;::::0;59433:9;;59444:7;;59381:71:::1;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;59381:71:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;59381:71:0;;;;55532:1;;58841:619:::0;;;;:::o;63144:185::-;63279:42;;;;;63255:12;;63279:22;;;;;;:42;;63302:10;;63314:6;;63279:42;;;;407:113;503:9;492:20;;;;;;;;407:113::o;56385:197::-;56469:34;:105;;;;;;;;;;;;;;;56385:197::o;59692:759::-;55412:34;;55404:57;55412:34;55382:139;;;;;;;;;;;;;;59906:34:::1;::::0;:84:::1;::::0;;;;59876:27:::1;::::0;59906:34:::1;;::::0;:72:::1;::::0;:84:::1;::::0;59979:10;;59906:84:::1;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;59906:84:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;59906:84: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;59906:84:0;;;;;;;;;60026:65;::::0;;;;59876:114;;-1:-1:-1;60026:26:0::1;:13;:26;::::0;::::1;::::0;:65:::1;::::0;60053:10:::1;::::0;60073:4:::1;::::0;60080:10;;60026:65:::1;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;60026:65:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;60026:65: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;60026:65:0;;;;;;;;;-1:-1:-1::0;60102:54:0::1;::::0;;;;:21:::1;:13;:21;::::0;::::1;::::0;:54:::1;::::0;60124:19;;60145:10;;60102:54:::1;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;60102:54:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;60102:54: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;60102:54:0;;;;;;;;;-1:-1:-1::0;60308:135:0::1;::::0;;;;60267:19;;60308:30:::1;::::0;::::1;::::0;::::1;::::0;:135:::1;::::0;60353:7;;60375:10:::1;::::0;60400;;60425:7;;60308:135:::1;;;;9361:179:::0;9417:6;9452:5;9444;:13;9436:65;;;;;;;;;;;;;;-1:-1:-1;9526:5:0;9361:179::o;2305:440:-1:-;;2406:3;2399:4;2391:6;2387:17;2383:27;2373:2;;-1:-1;;2414:12;2373:2;2461:6;2448:20;24009:18;24001:6;23998:30;23995:2;;;-1:-1;;24031:12;23995:2;2483:64;24172:4;24104:9;2399:4;24089:6;24085:17;24081:33;24162:15;2483:64;;;2474:73;;2567:6;2560:5;2553:21;2671:3;24172:4;2662:6;2595;2653:16;;2650:25;2647:2;;;2688:1;;2678:12;2647:2;26309:6;24172:4;2595:6;2591:17;24172:4;2629:5;2625:16;26286:30;26365:1;26347:16;;;24172:4;26347:16;26340:27;2629:5;2366:379;-1:-1;;2366:379;3031:132;3108:13;;25817:18;25806:30;;27311:34;;27301:2;;27359:1;;27349:12;27301:2;3093:70;;;;;3170:241;;3274:2;3262:9;3253:7;3249:23;3245:32;3242:2;;;-1:-1;;3280:12;3242:2;85:6;72:20;97:33;124:5;97:33;;;3332:63;3236:175;-1:-1;;;3236:175;3418:263;;3533:2;3521:9;3512:7;3508:23;3504:32;3501:2;;;-1:-1;;3539:12;3501:2;226:6;220:13;238:33;265:5;238:33;;3688:670;;;;;3853:3;3841:9;3832:7;3828:23;3824:33;3821:2;;;-1:-1;;3860:12;3821:2;226:6;220:13;238:33;265:5;238:33;;;4023:2;4073:22;;2968:13;4142:2;4191:22;;3108:13;3912:74;;-1:-1;2968:13;-1:-1;3126:32;3108:13;3126:32;;;4260:2;4310:22;;;;2241:13;3815:543;;;;-1:-1;;;3815:543;4365:528;;;4522:2;4510:9;4501:7;4497:23;4493:32;4490:2;;;-1:-1;;4528:12;4490:2;4579:17;4573:24;4617:18;4609:6;4606:30;4603:2;;;-1:-1;;4639:12;4603:2;4741:6;4730:9;4726:22;429:3;422:4;414:6;410:17;406:27;396:2;;-1:-1;;437:12;396:2;477:6;471:13;457:27;;499:80;514:64;571:6;514:64;;;499:80;;;585:16;621:6;614:5;607:21;651:4;;668:3;664:14;657:21;;651:4;643:6;639:17;773:3;651:4;;757:6;753:17;643:6;744:27;;741:36;738:2;;;-1:-1;;780:12;738:2;-1:-1;806:10;;800:217;825:6;822:1;819:13;800:217;;;2241:13;;893:61;;847:1;840:9;;;;;968:14;;;;996;;800:217;;;-1:-1;4845:22;;;;2968:13;4659:99;;2968:13;;-1:-1;;;;;;4484:409;4900:520;;;5055:2;5043:9;5034:7;5030:23;5026:32;5023:2;;;-1:-1;;5061:12;5023:2;5119:17;5106:31;5157:18;5149:6;5146:30;5143:2;;;-1:-1;;5179:12;5143:2;5279:6;5268:9;5264:22;1173:3;1166:4;1158:6;1154:17;1150:27;1140:2;;-1:-1;;1181:12;1140:2;1228:6;1215:20;1201:34;;1250:89;1265:73;1331:6;1265:73;;1250:89;1367:21;;;1411:4;1424:14;;;;1345:16;1399:17;;;-1:-1;1504:242;1529:6;1526:1;1523:13;1504:242;;;1636:46;1678:3;1411:4;1612:3;1599:17;1403:6;1587:30;;1636:46;;;1624:59;;1697:14;;;;1725;;;;1551:1;1544:9;1504:242;;;-1:-1;5199:97;;5372:22;;2820:20;;-1:-1;;;;;;;5017:403;5427:257;;5539:2;5527:9;5518:7;5514:23;5510:32;5507:2;;;-1:-1;;5545:12;5507:2;1972:6;1966:13;1984:30;2008:5;1984:30;;5691:263;;5806:2;5794:9;5785:7;5781:23;5777:32;5774:2;;;-1:-1;;5812:12;5774:2;-1:-1;2241:13;;5768:186;-1:-1;5768:186;5961:670;;;;;6126:3;6114:9;6105:7;6101:23;6097:33;6094:2;;;-1:-1;;6133:12;6094:2;2247:6;2241:13;6185:74;;6296:2;6350:9;6346:22;220:13;238:33;265:5;238:33;;;6415:2;6464:22;;3108:13;6304:74;;-1:-1;3126:32;3108:13;3126:32;;6638:737;;;;;;6807:3;6795:9;6786:7;6782:23;6778:33;6775:2;;;-1:-1;;6814:12;6775:2;2106:6;2093:20;6866:63;;6966:2;7009:9;7005:22;2093:20;6974:63;;7074:2;7117:9;7113:22;2820:20;7082:63;;7182:2;7225:9;7221:22;2820:20;7190:63;;7290:3;7331:9;7327:22;1824:20;1849:30;1873:5;1849:30;;;7299:60;;;;6769:606;;;;;;;;;7382:531;;;;7529:2;7517:9;7508:7;7504:23;7500:32;7497:2;;;-1:-1;;7535:12;7497:2;2247:6;2241:13;7587:74;;7716:63;7771:7;7698:2;7751:9;7747:22;7716:63;;;7706:73;;7834:63;7889:7;7816:2;7869:9;7865:22;7834:63;;;7824:73;;7491:422;;;;;;7920:241;;8024:2;8012:9;8003:7;7999:23;7995:32;7992:2;;;-1:-1;;8030:12;7992:2;-1:-1;2820:20;;7986:175;-1:-1;7986:175;8438:611;;;;;8590:3;8578:9;8569:7;8565:23;8561:33;8558:2;;;-1:-1;;8597:12;8558:2;2833:6;2820:20;8649:63;;8749:2;8792:9;8788:22;2093:20;8757:63;;8857:2;8900:9;8896:22;2820:20;8865:63;;8965:2;9005:9;9001:22;1824:20;1849:30;1873:5;1849:30;;;8552:497;;;;-1:-1;8552:497;;-1:-1;;8552:497;9056:485;;;;9191:2;9179:9;9170:7;9166:23;9162:32;9159:2;;;-1:-1;;9197:12;9159:2;2833:6;2820:20;9249:63;;9349:2;9392:9;9388:22;2820:20;9357:63;;9457:2;9497:9;9493:22;1824:20;1849:30;1873:5;1849:30;;;9465:60;;;;9153:388;;;;;;10030:690;;10223:5;24455:12;24870:6;24865:3;24858:19;24907:4;;24902:3;24898:14;10235:93;;24907:4;10399:5;24309:14;-1:-1;10438:260;10463:6;10460:1;10457:13;10438:260;;;10524:13;;10900:37;;9702:14;;;;24713;;;;10485:1;10478:9;10438:260;;;-1:-1;10704:10;;10154:566;-1:-1;;;;;10154:566;14609:213;25611:42;25600:54;;;;9950:37;;14727:2;14712:18;;14698:124;14829:451;25611:42;25600:54;;;9809:58;;25600:54;;;;15183:2;15168:18;;9950:37;15266:2;15251:18;;10900:37;;;;15011:2;14996:18;;14982:298;15287:340;25611:42;25600:54;;;;9809:58;;15613:2;15598:18;;10900:37;15441:2;15426:18;;15412:215;15965:361;;16133:2;16154:17;16147:47;16208:108;16133:2;16122:9;16118:18;16302:6;16208:108;;16333:472;;16529:2;16550:17;16543:47;16604:108;16529:2;16518:9;16514:18;16698:6;16604:108;;;16596:116;;10930:5;16791:2;16780:9;16776:18;10900:37;16500:305;;;;;;16812:201;25433:13;;25426:21;10793:34;;16924:2;16909:18;;16895:118;17020:213;10900:37;;;17138:2;17123:18;;17109:124;17240:447;10900:37;;;25611:42;25600:54;;;;17592:2;17577:18;;9809:58;25817:18;25806:30;17673:2;17658:18;;14561:36;17420:2;17405:18;;17391:296;17694:324;10900:37;;;18004:2;17989:18;;10900:37;17840:2;17825:18;;17811:207;18025:435;10900:37;;;18363:2;18348:18;;10900:37;;;;18446:2;18431:18;;10900:37;18199:2;18184:18;;18170:290;18467:407;18658:2;18672:47;;;18643:18;;;24858:19;11680:34;24898:14;;;11660:55;11734:12;;;18629:245;18881:407;19072:2;19086:47;;;11985:2;19057:18;;;24858:19;12021:28;24898:14;;;12001:49;12069:12;;;19043:245;19295:407;19486:2;19500:47;;;12320:2;19471:18;;;24858:19;12356:34;24898:14;;;12336:55;12425:16;12411:12;;;12404:38;12461:12;;;19457:245;19709:407;19900:2;19914:47;;;12712:2;19885:18;;;24858:19;12748:34;24898:14;;;12728:55;12817:8;12803:12;;;12796:30;12845:12;;;19871:245;20123:407;20314:2;20328:47;;;13096:2;20299:18;;;24858:19;13132:34;24898:14;;;13112:55;13201:5;13187:12;;;13180:27;13226:12;;;20285:245;20537:407;20728:2;20742:47;;;13477:2;20713:18;;;24858:19;13513:34;24898:14;;;13493:55;13582:13;13568:12;;;13561:35;13615:12;;;20699:245;20951:407;21142:2;21156:47;;;13866:2;21127:18;;;24858:19;13902:28;24898:14;;;13882:49;13950:12;;;21113:245;21365:407;21556:2;21570:47;;;14201:2;21541:18;;;24858:19;14237:34;24898:14;;;14217:55;14306:20;14292:12;;;14285:42;14346:12;;;21527:245;21999:551;10900:37;;;25611:42;25600:54;;;;22376:2;22361:18;;9809:58;22459:2;22444:18;;10900:37;25433:13;25426:21;22536:2;22521:18;;10793:34;22203:3;22188:19;;22174:376;22557:408;;10930:5;10907:3;10900:37;22839:2;22721;22839;22828:9;22824:18;22817:48;11211:5;24455:12;24870:6;22721:2;22710:9;22706:18;24858:19;-1:-1;26454:101;26468:6;26465:1;26462:13;26454:101;;;26535:11;;;;;26529:18;26516:11;;;24898:14;26516:11;26509:39;26483:10;;26454:101;;;26570:6;26567:1;26564:13;26561:2;;;-1:-1;24898:14;26626:6;22710:9;26617:16;;26610:27;26561:2;-1:-1;26746:2;26726:14;26742:7;26722:28;11368:39;;;;24898:14;11368:39;;22692:273;-1:-1;;;;22692:273;22972:256;23034:2;23028:9;23060:17;;;23135:18;23120:34;;23156:22;;;23117:62;23114:2;;;23192:1;;23182:12;23114:2;23034;23201:22;23012:216;;-1:-1;23012:216;23235:304;;23394:18;23386:6;23383:30;23380:2;;;-1:-1;;23416:12;23380:2;-1:-1;23461:4;23449:17;;;23514:15;;23317:222;26763:117;25611:42;26850:5;25600:54;26825:5;26822:35;26812:2;;26871:1;;26861:12;26887:111;26968:5;25433:13;25426:21;26946:5;26943:32;26933:2;;26989:1;;26979:12;27253:115;25817:18;27338:5;25806:30;27314:5;27311:34;27301:2;;27359:1;;27349:12

ipfs://1bcd90f37f7726dff7a1ee875f62a662a596035eda2c1e7f4a5c75f0137aa422