Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

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

        return c;
    }

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

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

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // 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

pragma solidity ^0.6.0;

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

pragma solidity ^0.6.0;


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

pragma solidity ^0.6.0;





/**
 * @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/BondMakerInterface.sol

pragma solidity 0.6.6;


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/util/Time.sol

pragma solidity 0.6.6;


abstract contract Time {
    function _getBlockTimestampSec() internal view returns (uint256 unixtimesec) {
        unixtimesec = now; // solium-disable-line security/no-block-members
    }
}

// File: contracts/util/TransferETHInterface.sol

pragma solidity 0.6.6;


interface TransferETHInterface {
    receive() external payable;

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

// File: contracts/util/TransferETH.sol

pragma solidity 0.6.6;



abstract contract TransferETH is TransferETHInterface {
    receive() external override payable {
        emit LogTransferETH(msg.sender, address(this), msg.value);
    }

    function _hasSufficientBalance(uint256 amount) internal view returns (bool ok) {
        address thisContract = address(this);
        return amount <= thisContract.balance;
    }

    /**
     * @notice transfer `amount` ETH to the `recipient` account with emitting log
     */
    function _transferETH(
        address payable recipient,
        uint256 amount,
        string memory errorMessage
    ) internal {
        require(_hasSufficientBalance(amount), errorMessage);
        (bool success, ) = recipient.call{value: amount}("");
        require(success, "transferring Ether failed");
        emit LogTransferETH(address(this), recipient, amount);
    }

    function _transferETH(address payable recipient, uint256 amount) internal {
        _transferETH(recipient, amount, "TransferETH: transfer amount exceeds balance");
    }
}

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

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
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/token/ERC20/IERC20.sol

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.6.2;

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

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

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

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

pragma solidity ^0.6.0;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {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/bondToken/BondTokenInterface.sol

pragma solidity 0.6.6;




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/util/DeployerRole.sol

pragma solidity 0.6.6;


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: contracts/bondToken/BondToken.sol

pragma solidity 0.6.6;






contract BondToken is DeployerRole, BondTokenInterface, TransferETH, ERC20 {
    struct Frac128x128 {
        uint128 numerator;
        uint128 denominator;
    }

    Frac128x128 internal _rate;

    constructor(string memory name, string memory symbol) public ERC20(name, symbol) {
        _setupDecimals(8);
    }

    function mint(address account, uint256 amount)
        public
        virtual
        override
        onlyDeployer
        returns (bool success)
    {
        require(!isExpired(), "this token contract has expired");
        _mint(account, amount);
        return true;
    }

    function transfer(address recipient, uint256 amount)
        public
        override(ERC20, IERC20)
        returns (bool success)
    {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override(ERC20, IERC20) returns (bool success) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            msg.sender,
            allowance(sender, msg.sender).sub(amount, "ERC20: transfer amount exceeds allowance")
        );
        return true;
    }

    /**
     * @dev Record the settlement price at maturity in the form of a fraction and let the bond
     * token expire.
     */
    function expire(uint128 rateNumerator, uint128 rateDenominator)
        public
        override
        onlyDeployer
        returns (bool isFirstTime)
    {
        isFirstTime = !isExpired();
        if (isFirstTime) {
            _setRate(Frac128x128(rateNumerator, rateDenominator));
        }

        emit LogExpire(rateNumerator, rateNumerator, isFirstTime);
    }

    function simpleBurn(address from, uint256 amount) public onlyDeployer returns (bool) {
        if (amount > balanceOf(from)) {
            return false;
        }

        _burn(from, amount);
        return true;
    }

    function burn(uint256 amount) public override returns (bool success) {
        if (!isExpired()) {
            return false;
        }

        _burn(msg.sender, amount);

        if (_rate.numerator != 0) {
            uint256 withdrawAmount = amount.mul(10**(18 - 8)).mul(_rate.numerator).div(
                _rate.denominator
            );
            _transferETH(msg.sender, withdrawAmount, "system error: insufficient balance");
        }

        return true;
    }

    function burnAll() public override returns (uint256 amount) {
        amount = balanceOf(msg.sender);
        bool success = burn(amount);
        if (!success) {
            amount = 0;
        }
    }

    /**
     * @dev rateDenominator never be zero due to div() function, thus initial _rateDenominator is 0
     * can be used for flag of non-expired;
     */
    function isExpired() public view returns (bool) {
        return _rate.denominator != 0;
    }

    function isMinter(address account) public override view returns (bool) {
        return _isDeployer(account);
    }

    function getRate()
        public
        override
        view
        returns (uint128 rateNumerator, uint128 rateDenominator)
    {
        rateNumerator = _rate.numerator;
        rateDenominator = _rate.denominator;
    }

    function _setRate(Frac128x128 memory rate) internal {
        require(
            rate.denominator != 0,
            "system error: the exchange rate must be non-negative number"
        );
        _rate = rate;
    }
}

// File: contracts/util/Polyline.sol

pragma solidity 0.6.6;



contract Polyline is UseSafeMath {
    struct Point {
        uint64 x; // Value of the x-axis of the x-y plane
        uint64 y; // Value of the y-axis of the x-y plane
    }

    struct LineSegment {
        Point left; // The left end of the line definition range
        Point right; // The right end of the line definition range
    }

    /**
     * @notice Return the value of y corresponding to x on the given line line in the form of
     * a rational number (numerator / denominator).
     * If you treat a line as a line segment instead of a line, you should run
     * includesDomain(line, x) to check whether x is included in the line's domain or not.
     * @dev To guarantee accuracy, the bit length of the denominator must be greater than or equal
     * to the bit length of x, and the bit length of the numerator must be greater than or equal
     * to the sum of the bit lengths of x and y.
     */
    function _mapXtoY(LineSegment memory line, uint64 x)
        internal
        pure
        returns (uint128 numerator, uint64 denominator)
    {
        int256 x1 = int256(line.left.x);
        int256 y1 = int256(line.left.y);
        int256 x2 = int256(line.right.x);
        int256 y2 = int256(line.right.y);

        require(x2 > x1, "must be left.x < right.x");

        denominator = uint64(x2 - x1);

        // Calculate y = ((x2 - x) * y1 + (x - x1) * y2) / (x2 - x1)
        // in the form of a fraction (numerator / denominator).
        int256 n = (x - x1) * y2 + (x2 - x) * y1;

        require(n >= 0, "underflow n");
        require(n < 2**128, "system error: overflow n");
        numerator = uint128(n);
    }

    /**
     * @notice Checking that a line segment is a line segment of a valid format.
     */
    function assertLineSegment(LineSegment memory segment) internal pure {
        uint64 x1 = segment.left.x;
        uint64 x2 = segment.right.x;
        require(x1 < x2, "must be left.x < right.x");
    }

    /**
     * @notice Checking that a polyline is a line graph of a valid form.
     */
    function assertPolyline(LineSegment[] memory polyline) internal pure {
        uint256 numOfSegment = polyline.length;
        require(numOfSegment > 0, "polyline must not be empty array");

        // About the first line segment.
        LineSegment memory firstSegment = polyline[0];

        // The beginning of the first line segment's domain is 0.
        require(
            firstSegment.left.x == uint64(0),
            "the x coordinate of left end of the first segment is 0"
        );
        // The value of y when x is 0 is 0.
        require(
            firstSegment.left.y == uint64(0),
            "the y coordinate of left end of the first segment is 0"
        );

        // About the last line segment.
        LineSegment memory lastSegment = polyline[numOfSegment - 1];

        // The slope of the last line segment should be between 0 and 1.
        int256 gradientNumerator = int256(lastSegment.right.y).sub(lastSegment.left.y);
        int256 gradientDenominator = int256(lastSegment.right.x).sub(lastSegment.left.x);
        require(
            gradientNumerator >= 0 && gradientNumerator <= gradientDenominator,
            "the gradient of last line segment must be non-negative number equal to or less than 1"
        );

        // Making sure that the first line segment is in the correct format.
        assertLineSegment(firstSegment);

        // The end of the domain of a segment and the beginning of the domain of the adjacent
        // segment coincide.
        for (uint256 i = 1; i < numOfSegment; i++) {
            LineSegment memory leftSegment = polyline[i - 1];
            LineSegment memory rightSegment = polyline[i];

            // Make sure that the i-th line segment is in the correct format.
            assertLineSegment(rightSegment);

            // Checking that the x-coordinates are same.
            require(
                leftSegment.right.x == rightSegment.left.x,
                "given polyline is not single-valued function."
            );

            // Checking that the y-coordinates are same.
            require(
                leftSegment.right.y == rightSegment.left.y,
                "given polyline is not continuous function"
            );
        }
    }

    /**
     * @notice zip a LineSegment structure to uint256
     * @return zip uint256( 0 ... 0 | x1 | y1 | x2 | y2 )
     */
    function zipLineSegment(LineSegment memory segment) internal pure returns (uint256 zip) {
        uint256 x1U256 = uint256(segment.left.x) << (64 + 64 + 64); // uint64
        uint256 y1U256 = uint256(segment.left.y) << (64 + 64); // uint64
        uint256 x2U256 = uint256(segment.right.x) << 64; // uint64
        uint256 y2U256 = uint256(segment.right.y); // uint64
        zip = x1U256 | y1U256 | x2U256 | y2U256;
    }

    /**
     * @notice unzip uint256 to a LineSegment structure
     */
    function unzipLineSegment(uint256 zip) internal pure returns (LineSegment memory) {
        uint64 x1 = uint64(zip >> (64 + 64 + 64));
        uint64 y1 = uint64(zip >> (64 + 64));
        uint64 x2 = uint64(zip >> 64);
        uint64 y2 = uint64(zip);
        return LineSegment({left: Point({x: x1, y: y1}), right: Point({x: x2, y: y2})});
    }

    /**
     * @notice unzip the fnMap to uint256[].
     */
    function decodePolyline(bytes memory fnMap) internal pure returns (uint256[] memory) {
        return abi.decode(fnMap, (uint256[]));
    }
}

// File: contracts/oracle/OracleInterface.sol

pragma solidity ^0.6.6;


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

pragma solidity 0.6.6;



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/bondTokenName/BondTokenNameInterface.sol

pragma solidity ^0.6.6;


/**
 * @title bond token name contract interface
 */
interface BondTokenNameInterface {
    function genBondTokenName(
        string calldata shortNamePrefix,
        string calldata longNamePrefix,
        uint256 maturity,
        uint256 solidStrikePriceE4
    ) external pure returns (string memory shortName, string memory longName);

    function getBondTokenName(
        uint256 maturity,
        uint256 solidStrikePriceE4,
        uint256 rateLBTWorthlessE4
    ) external pure returns (string memory shortName, string memory longName);
}

// File: contracts/UseBondTokenName.sol

pragma solidity 0.6.6;



abstract contract UseBondTokenName {
    BondTokenNameInterface internal immutable _bondTokenNameContract;

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

// File: contracts/BondMaker.sol

pragma solidity 0.6.6;










contract BondMaker is
    UseSafeMath,
    BondMakerInterface,
    Time,
    TransferETH,
    Polyline,
    UseOracle,
    UseBondTokenName
{
    uint8 internal constant DECIMALS_OF_BOND_AMOUNT = 8;

    address internal immutable LIEN_TOKEN_ADDRESS;

    uint256 public nextBondGroupID = 1;

    /**
     * @dev The contents in this internal storage variable can be seen by getBond function.
     */
    struct BondInfo {
        uint256 maturity;
        BondToken contractInstance;
        uint64 solidStrikePriceE4;
        bytes32 fnMapID;
    }
    mapping(bytes32 => BondInfo) internal _bonds;

    /**
     * @notice mapping fnMapID to polyline
     * @dev The contents in this internal storage variable can be seen by getFnMap function.
     */
    mapping(bytes32 => LineSegment[]) internal _registeredFnMap;

    /**
     * @dev The contents in this internal storage variable can be seen by getBondGroup function.
     */
    struct BondGroup {
        bytes32[] bondIDs;
        uint256 maturity;
    }
    mapping(uint256 => BondGroup) internal _bondGroupList;

    constructor(
        address oracleAddress,
        address lienTokenAddress,
        address bondTokenNameAddress
    ) public UseOracle(oracleAddress) UseBondTokenName(bondTokenNameAddress) {
        LIEN_TOKEN_ADDRESS = lienTokenAddress;
    }

    /**
     * @notice Create bond token contract.
     * The name of this bond token is its bond ID.
     * @dev To convert bytes32 to string, encode its bond ID at first, then convert to string.
     * The symbol of any bond token with bond ID is either SBT or LBT;
     * As SBT is a special case of bond token, any bond token which does not match to the form of
     * SBT is defined as LBT.
     */
    function registerNewBond(uint256 maturity, bytes memory fnMap)
        public
        override
        returns (
            bytes32,
            address,
            uint64,
            bytes32
        )
    {
        bytes32 bondID = generateBondID(maturity, fnMap);

        // Check if the same form of bond is already registered.
        // Cannot detect if the bond is described in a different polyline while two are
        // mathematically equivalent.
        require(
            address(_bonds[bondID].contractInstance) == address(0),
            "already register given bond type"
        );

        // Register function mapping if necessary.
        bytes32 fnMapID = generateFnMapID(fnMap);
        if (_registeredFnMap[fnMapID].length == 0) {
            uint256[] memory polyline = decodePolyline(fnMap);
            for (uint256 i = 0; i < polyline.length; i++) {
                _registeredFnMap[fnMapID].push(unzipLineSegment(polyline[i]));
            }

            assertPolyline(_registeredFnMap[fnMapID]);
        }

        uint64 solidStrikePrice = _getSolidStrikePrice(_registeredFnMap[fnMapID]);
        uint64 rateLBTWorthless = _getRateLBTWorthless(_registeredFnMap[fnMapID]);

        (string memory shortName, string memory longName) = _bondTokenNameContract.getBondTokenName(
            maturity,
            solidStrikePrice,
            rateLBTWorthless
        );

        BondToken bondTokenContract = _createNewBondToken(longName, shortName);

        // Set bond info to storage.
        _bonds[bondID] = BondInfo({
            maturity: maturity,
            contractInstance: bondTokenContract,
            solidStrikePriceE4: solidStrikePrice,
            fnMapID: fnMapID
        });

        emit LogNewBond(bondID, address(bondTokenContract), solidStrikePrice, fnMapID);

        return (bondID, address(bondTokenContract), solidStrikePrice, fnMapID);
    }

    function _assertBondGroup(bytes32[] memory bondIDs, uint256 maturity) internal view {
        /**
         * @dev Count the number of the end points on x axis. In the case of a simple SBT/LBT split,
         * 3 for SBT plus 3 for LBT equals to 6.
         * In the case of SBT with the strike price 100, (x,y) = (0,0), (100,100), (200,100) defines
         * the form of SBT on the field.
         * In the case of LBT with the strike price 100, (x,y) = (0,0), (100,0), (200,100) defines
         * the form of LBT on the field.
         * Right hand side area of the last grid point is expanded on the last line to the infinity.
         * @param nextBreakPointIndex returns the number of unique points on x axis.
         * In the case of SBT and LBT with the strike price 100, x = 0,100,200 are the unique points
         * and the number is 3.
         */
        uint256 numOfBreakPoints = 0;
        for (uint256 i = 0; i < bondIDs.length; i++) {
            BondInfo storage bond = _bonds[bondIDs[i]];
            require(bond.maturity == maturity, "the maturity of the bonds must be same");
            LineSegment[] storage polyline = _registeredFnMap[bond.fnMapID];
            numOfBreakPoints = numOfBreakPoints.add(polyline.length);
        }

        uint256 nextBreakPointIndex = 0;
        uint64[] memory rateBreakPoints = new uint64[](numOfBreakPoints);
        for (uint256 i = 0; i < bondIDs.length; i++) {
            BondInfo storage bond = _bonds[bondIDs[i]];
            LineSegment[] storage segments = _registeredFnMap[bond.fnMapID];
            for (uint256 j = 0; j < segments.length; j++) {
                uint64 breakPoint = segments[j].right.x;
                bool ok = false;

                for (uint256 k = 0; k < nextBreakPointIndex; k++) {
                    if (rateBreakPoints[k] == breakPoint) {
                        ok = true;
                        break;
                    }
                }

                if (ok) {
                    continue;
                }

                rateBreakPoints[nextBreakPointIndex] = breakPoint;
                nextBreakPointIndex++;
            }
        }

        for (uint256 k = 0; k < rateBreakPoints.length; k++) {
            uint64 rate = rateBreakPoints[k];
            uint256 totalBondPriceN = 0;
            uint256 totalBondPriceD = 1;
            for (uint256 i = 0; i < bondIDs.length; i++) {
                BondInfo storage bond = _bonds[bondIDs[i]];
                LineSegment[] storage segments = _registeredFnMap[bond.fnMapID];
                (uint256 segmentIndex, bool ok) = _correspondSegment(segments, rate);

                require(ok, "invalid domain expression");

                (uint128 n, uint64 d) = _mapXtoY(segments[segmentIndex], rate);

                if (n != 0) {
                    // totalBondPrice += (n / d);
                    // N = D*n + N*d, D = D*d
                    totalBondPriceN = totalBondPriceD.mul(n).add(totalBondPriceN.mul(d));
                    totalBondPriceD = totalBondPriceD.mul(d);
                }
            }
            /**
             * @dev Ensure that totalBondPrice (= totalBondPriceN / totalBondPriceD) is the same
             * with rate. Because we need 1 Ether to mint a unit of each bond token respectively,
             * the sum of strike price (USD) per a unit of bond token is the same with USD/ETH
             * rate at maturity.
             */
            require(
                totalBondPriceN == totalBondPriceD.mul(rate),
                "the total price at any rateBreakPoints should be the same value as the rate"
            );
        }
    }

    /**
     * @notice Collect bondIDs that regenerate the original ETH, and group them as a bond group.
     * Any bond is described as a set of linear functions(i.e. polyline),
     * so we can easily check if the set of bondIDs are well-formed by looking at all the end
     * points of the lines.
     */
    function registerNewBondGroup(bytes32[] memory bondIDs, uint256 maturity)
        public
        override
        returns (uint256 bondGroupID)
    {
        _assertBondGroup(bondIDs, maturity);

        // Get and increment next bond group ID
        bondGroupID = nextBondGroupID;
        nextBondGroupID = nextBondGroupID.add(1);

        _bondGroupList[bondGroupID] = BondGroup(bondIDs, maturity);

        emit LogNewBondGroup(bondGroupID);

        return bondGroupID;
    }

    /**
     * @notice A user needs to issue a bond via BondGroup in order to guarantee that the total value
     * of bonds in the bond group equals to the input Ether except for about 0.2% fee (accurately 2/1002).
     */
    function issueNewBonds(uint256 bondGroupID) public override payable returns (uint256) {
        BondGroup storage bondGroup = _bondGroupList[bondGroupID];
        bytes32[] storage bondIDs = bondGroup.bondIDs;
        uint256 fee = msg.value.mul(2).div(1002);

        uint256 amount = msg.value.sub(fee).div(10**10); // ether's decimal is 18 and that of LBT is 8;

        bytes32 bondID;
        for (uint256 bondFnMapIndex = 0; bondFnMapIndex < bondIDs.length; bondFnMapIndex++) {
            bondID = bondIDs[bondFnMapIndex];
            _issueNewBond(bondID, msg.sender, amount);
        }

        _transferETH(payable(LIEN_TOKEN_ADDRESS), fee);

        emit LogIssueNewBonds(bondGroupID, msg.sender, amount);

        return amount;
    }

    /**
     * @notice redeems ETH from the total set of bonds in the bondGroupID before maturity date.
     */
    function reverseBondToETH(uint256 bondGroupID, uint256 amountE8)
        public
        override
        returns (bool)
    {
        BondGroup storage bondGroup = _bondGroupList[bondGroupID];
        bytes32[] storage bondIDs = bondGroup.bondIDs;
        require(_getBlockTimestampSec() < bondGroup.maturity, "already expired");
        bytes32 bondID;
        for (uint256 bondFnMapIndex = 0; bondFnMapIndex < bondIDs.length; bondFnMapIndex++) {
            bondID = bondIDs[bondFnMapIndex];
            BondToken bondTokenContract = _bonds[bondID].contractInstance;
            require(
                bondTokenContract.simpleBurn(msg.sender, amountE8),
                "insufficient bond token balance"
            );
        }

        _transferETH(msg.sender, amountE8.mul(10**10), "system error: insufficient Ether balance");

        emit LogReverseBondToETH(bondGroupID, msg.sender, amountE8.mul(10**10));

        return true;
    }

    /**
     * @notice Burns set of LBTs and mints equivalent set of LBTs that are not in the exception list.
     * @param inputBondGroupID is the BondGroupID of bonds which you want to burn.
     * @param outputBondGroupID is the BondGroupID of bonds which you want to mint.
     * @param exceptionBonds is the list of bondIDs that should be excluded in burn/mint process.
     */
    function exchangeEquivalentBonds(
        uint256 inputBondGroupID,
        uint256 outputBondGroupID,
        uint256 amount,
        bytes32[] memory exceptionBonds
    ) public override returns (bool) {
        (bytes32[] memory inputIDs, uint256 inputMaturity) = getBondGroup(inputBondGroupID);
        (bytes32[] memory outputIDs, uint256 outputMaturity) = getBondGroup(outputBondGroupID);
        require(inputMaturity == outputMaturity, "cannot exchange bonds with different maturities");
        bool flag;

        uint256 exceptionCount;
        for (uint256 i = 0; i < inputIDs.length; i++) {
            // this flag control checks whether the bond is in the scope of burn/mint
            flag = true;
            for (uint256 j = 0; j < exceptionBonds.length; j++) {
                if (exceptionBonds[j] == inputIDs[i]) {
                    flag = false;
                    // this count checks if all the bondIDs in exceptionBonds are included both in inputBondGroupID and outputBondGroupID
                    exceptionCount = exceptionCount.add(1);
                }
            }
            if (flag) {
                BondToken bondTokenContract = _bonds[inputIDs[i]].contractInstance;
                require(
                    bondTokenContract.simpleBurn(msg.sender, amount),
                    "success of burning the amount of token required."
                );
            }
        }

        require(
            exceptionBonds.length == exceptionCount,
            "All the exceptionBonds need to be included in input"
        );

        for (uint256 i = 0; i < outputIDs.length; i++) {
            flag = true;
            for (uint256 j = 0; j < exceptionBonds.length; j++) {
                if (exceptionBonds[j] == outputIDs[i]) {
                    flag = false;
                    exceptionCount = exceptionCount.sub(1);
                }
            }
            if (flag) {
                _issueNewBond(outputIDs[i], msg.sender, amount);
            }
        }

        require(
            exceptionCount == 0,
            "All the exceptionBonds need to be included both in input and output"
        );

        emit LogExchangeEquivalentBonds(msg.sender, inputBondGroupID, outputBondGroupID, amount);

        return true;
    }

    /**
     * @notice Distributes ETH to the bond token holders after maturity date based on the oracle price.
     * @param oracleHintID is manyally set to be smaller number than the oracle latestId when the caller wants to save gas.
     */
    function liquidateBond(uint256 bondGroupID, uint256 oracleHintID) public override {
        if (oracleHintID == 0) {
            _distributeETH2BondTokenContract(bondGroupID, _oracleContract.latestId());
        } else {
            _distributeETH2BondTokenContract(bondGroupID, oracleHintID);
        }
    }

    /**
     * @notice Returns multiple information for the bondID.
     */
    function getBond(bytes32 bondID)
        public
        override
        view
        returns (
            address bondTokenAddress,
            uint256 maturity,
            uint64 solidStrikePrice,
            bytes32 fnMapID
        )
    {
        BondInfo memory bondInfo = _bonds[bondID];
        bondTokenAddress = address(bondInfo.contractInstance);
        maturity = bondInfo.maturity;
        solidStrikePrice = bondInfo.solidStrikePriceE4;
        fnMapID = bondInfo.fnMapID;
    }

    /**
     * @dev Returns polyline for the fnMapID.
     */
    function getFnMap(bytes32 fnMapID) public override view returns (bytes memory) {
        LineSegment[] storage segments = _registeredFnMap[fnMapID];
        uint256[] memory polyline = new uint256[](segments.length);
        for (uint256 i = 0; i < segments.length; i++) {
            polyline[i] = zipLineSegment(segments[i]);
        }
        return abi.encode(polyline);
    }

    /**
     * @dev Returns all the bondIDs and their maturity for the bondGroupID.
     */
    function getBondGroup(uint256 bondGroupID)
        public
        virtual
        override
        view
        returns (bytes32[] memory bondIDs, uint256 maturity)
    {
        BondGroup memory bondGroup = _bondGroupList[bondGroupID];
        bondIDs = bondGroup.bondIDs;
        maturity = bondGroup.maturity;
    }

    /**
     * @dev Returns keccak256 for the fnMap.
     */
    function generateFnMapID(bytes memory fnMap) public pure returns (bytes32) {
        return keccak256(fnMap);
    }

    /**
     * @dev Returns keccak256 for the pair of maturity and fnMap.
     */
    function generateBondID(uint256 maturity, bytes memory fnMap)
        public
        override
        pure
        returns (bytes32)
    {
        return keccak256(abi.encodePacked(maturity, fnMap));
    }

    function _createNewBondToken(string memory name, string memory symbol)
        internal
        virtual
        returns (BondToken)
    {
        return new BondToken(name, symbol);
    }

    function _issueNewBond(
        bytes32 bondID,
        address receiver,
        uint256 amount
    ) internal {
        BondToken bondTokenContract = _bonds[bondID].contractInstance;
        bool success = bondTokenContract.mint(receiver, amount);
        require(success, "failed to mint bond token");
    }

    function _distributeETH2BondTokenContract(uint256 bondGroupID, uint256 oracleHintID) internal {
        BondGroup storage bondGroup = _bondGroupList[bondGroupID];
        require(bondGroup.bondIDs.length > 0, "the bond group does not exist");
        require(_getBlockTimestampSec() >= bondGroup.maturity, "the bond has not expired yet");

        // rateETH2USDE8 is the USD/ETH price multiplied by 10^8 returned from the oracle.
        uint256 rateETH2USDE8 = _getPriceOn(bondGroup.maturity, oracleHintID);

        // rateETH2USDE8 needs to be converted to rateETH2USDE4 as to match the decimal of the
        // values in segment.
        uint256 rateETH2USDE4 = rateETH2USDE8.div(10000);
        require(rateETH2USDE4 != 0, "system error: rate should be non-zero value");
        require(
            rateETH2USDE4 < 2**64,
            "system error: rate should be less than the maximum value of uint64"
        );

        for (uint256 i = 0; i < bondGroup.bondIDs.length; i++) {
            bytes32 bondID = bondGroup.bondIDs[i];
            BondToken bondTokenContract = _bonds[bondID].contractInstance;
            require(address(bondTokenContract) != address(0), "the bond is not registered");

            LineSegment[] storage segments = _registeredFnMap[_bonds[bondID].fnMapID];

            (uint256 segmentIndex, bool ok) = _correspondSegment(segments, uint64(rateETH2USDE4));

            require(
                ok,
                "system error: did not found a segment whose price range include USD/ETH rate"
            );
            LineSegment storage segment = segments[segmentIndex];
            (uint128 n, uint64 _d) = _mapXtoY(segment, uint64(rateETH2USDE4));

            // uint64(-1) *  uint64(-1) < uint128(-1)
            uint128 d = uint128(_d) * uint128(rateETH2USDE4);

            uint256 totalSupply = bondTokenContract.totalSupply();
            bool expiredFlag = bondTokenContract.expire(n, d);

            if (expiredFlag) {
                uint256 payment = totalSupply.mul(10**(18 - 8)).mul(n).div(d);
                _transferETH(
                    address(bondTokenContract),
                    payment,
                    "system error: BondMaker's balance is less than payment"
                );
            }
        }
    }

    /**
     * @dev Return the strike price only when the form of polyline matches to the definition of SBT.
     * Check if the form is SBT even when the polyline is in a verbose style.
     */
    function _getSolidStrikePrice(LineSegment[] memory polyline) internal pure returns (uint64) {
        uint64 solidStrikePrice = polyline[0].right.x;

        if (solidStrikePrice == 0) {
            return 0;
        }

        for (uint256 i = 0; i < polyline.length; i++) {
            LineSegment memory segment = polyline[i];
            if (segment.right.y != solidStrikePrice) {
                return 0;
            }
        }

        return uint64(solidStrikePrice);
    }

    /**
     * @dev Only when the form of polyline matches to the definition of LBT, this function returns
     * the minimum USD/ETH rate that LBT is not worthless.
     * Check if the form is LBT even when the polyline is in a verbose style.
     */
    function _getRateLBTWorthless(LineSegment[] memory polyline) internal pure returns (uint64) {
        uint64 rateLBTWorthless = polyline[0].right.x;

        if (rateLBTWorthless == 0) {
            return 0;
        }

        for (uint256 i = 0; i < polyline.length; i++) {
            LineSegment memory segment = polyline[i];
            if (segment.right.y.add(rateLBTWorthless) != segment.right.x) {
                return 0;
            }
        }

        return uint64(rateLBTWorthless);
    }

    /**
     * @dev In order to calculate y axis value for the corresponding x axis value, we need to find
     * the place of domain of x value on the polyline.
     * As the polyline is already checked to be correctly formed, we can simply look from the right
     * hand side of the polyline.
     */
    function _correspondSegment(LineSegment[] memory segments, uint64 x)
        internal
        pure
        returns (uint256 i, bool ok)
    {
        i = segments.length;
        while (i > 0) {
            i--;
            if (segments[i].left.x <= x) {
                ok = true;
                break;
            }
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"oracleAddress","type":"address"},{"internalType":"address","name":"lienTokenAddress","type":"address"},{"internalType":"address","name":"bondTokenNameAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"inputBondGroupID","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"outputBondGroupID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogExchangeEquivalentBonds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"indexed":true,"internalType":"address","name":"issuer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogIssueNewBonds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"bondID","type":"bytes32"},{"indexed":false,"internalType":"address","name":"bondTokenAddress","type":"address"},{"indexed":false,"internalType":"uint64","name":"stableStrikePrice","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"fnMapID","type":"bytes32"}],"name":"LogNewBond","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"bondGroupID","type":"uint256"}],"name":"LogNewBondGroup","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogReverseBondToETH","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"LogTransferETH","type":"event"},{"inputs":[{"internalType":"uint256","name":"inputBondGroupID","type":"uint256"},{"internalType":"uint256","name":"outputBondGroupID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"exceptionBonds","type":"bytes32[]"}],"name":"exchangeEquivalentBonds","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"bytes","name":"fnMap","type":"bytes"}],"name":"generateBondID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"fnMap","type":"bytes"}],"name":"generateFnMapID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"bondID","type":"bytes32"}],"name":"getBond","outputs":[{"internalType":"address","name":"bondTokenAddress","type":"address"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"uint64","name":"solidStrikePrice","type":"uint64"},{"internalType":"bytes32","name":"fnMapID","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"}],"name":"getBondGroup","outputs":[{"internalType":"bytes32[]","name":"bondIDs","type":"bytes32[]"},{"internalType":"uint256","name":"maturity","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"fnMapID","type":"bytes32"}],"name":"getFnMap","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"}],"name":"issueNewBonds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"internalType":"uint256","name":"oracleHintID","type":"uint256"}],"name":"liquidateBond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nextBondGroupID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"bytes","name":"fnMap","type":"bytes"}],"name":"registerNewBond","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint64","name":"","type":"uint64"},{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"bondIDs","type":"bytes32[]"},{"internalType":"uint256","name":"maturity","type":"uint256"}],"name":"registerNewBondGroup","outputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"bondGroupID","type":"uint256"},{"internalType":"uint256","name":"amountE8","type":"uint256"}],"name":"reverseBondToETH","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000120a078fdc516a1a98bbecb9e961f8741ac7ac82000000000000000000000000ab37e1358b639fd877f015027bb62d3ddaa7557e0000000000000000000000000B06dADA89d0dF1c9162C97009Af56509caEeD72

-----Decoded View---------------
Arg [0] : oracleAddress (address): 0x120a078FdC516A1A98bbecb9e961F8741AC7ac82
Arg [1] : lienTokenAddress (address): 0xaB37e1358b639Fd877f015027Bb62d3ddAa7557E
Arg [2] : bondTokenNameAddress (address): 0x0B06dADA89d0dF1c9162C97009Af56509caEeD72

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000120a078fdc516a1a98bbecb9e961f8741ac7ac82
Arg [1] : 000000000000000000000000ab37e1358b639fd877f015027bb62d3ddaa7557e
Arg [2] : 0000000000000000000000000B06dADA89d0dF1c9162C97009Af56509caEeD72

49381:20694:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15995:52;;;16037:9;15995:52;;;;16030:4;;16010:10;;15995:52;;;;;;;;;49381:20694;;12:1:-1;9;2:12;63159:510:0;;5:9:-1;2:2;;;27:1;24;17:12;2:2;63159:510:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;63159:510:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64842:212;;5:9:-1;2:2;;;27:1;24;17:12;2:2;64842:212:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;64842:212:0;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;64842:212:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;64842:212:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;64842:212:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;64842:212:0;;-1:-1:-1;64842:212:0;;-1:-1:-1;;;;;64842:212:0:i;:::-;;;;;;;;;;;;;;;;60163:2338;;5:9:-1;2:2;;;27:1;24;17:12;2:2;60163:2338:0;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;60163:2338:0;;;;;;;;;;;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;60163:2338:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;60163:2338:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;60163:2338:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;60163:2338:0;;-1:-1:-1;60163:2338:0;;-1:-1:-1;;;;;60163:2338:0:i;:::-;;;;;;;;;;;;;;;;;;63742:387;;5:9:-1;2:2;;;27:1;24;17:12;2:2;63742:387:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;63742:387:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;63742:387:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64632:117;;5:9:-1;2:2;;;27:1;24;17:12;2:2;64632:117:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;64632:117:0;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;64632:117:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;64632:117:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;64632:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;64632:117:0;;-1:-1:-1;64632:117:0;;-1:-1:-1;;;;;64632:117:0:i;62757:315::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;62757:315:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;62757:315:0;;;;;;;:::i;:::-;;51173:1957;;5:9:-1;2:2;;;27:1;24;17:12;2:2;51173:1957:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;51173:1957:0;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;51173:1957:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;51173:1957:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51173:1957:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;51173:1957:0;;-1:-1:-1;51173:1957:0;;-1:-1:-1;;;;;51173:1957:0:i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57913:764;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;57913:764:0;;:::i;49650:34::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;49650:34:0;;;:::i;57181:496::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;57181:496:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;57181:496:0;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;57181:496:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;57181:496:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;57181:496:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;57181:496:0;;-1:-1:-1;;57181:496:0;;;-1:-1:-1;57181:496:0;;-1:-1:-1;;57181:496:0:i;64232:328::-;;5:9:-1;2:2;;;27:1;24;17:12;2:2;64232:328:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;64232:328:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;64232:328:0;;;;;;;;;;;;;;;;;;58800:966;;5:9:-1;2:2;;;27:1;24;17:12;2:2;58800:966:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;58800:966:0;;;;;;;:::i;63159:510::-;63272:24;63311:16;63342:23;63380:15;63423:24;;:::i;:::-;-1:-1:-1;;;63450:14:0;;;;-1:-1:-1;;63450:6:0;:14;;;;;;;;;63423:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63159:510::o;64842:212::-;64970:7;65029:8;65039:5;65012:33;;;;;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;139:12;;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;65012:33:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;65012:33:0;;;65002:44;;;;;;64995:51;;64842:212;;;;;:::o;60163:2338::-;60366:4;60384:25;60411:21;60436:30;60449:16;60436:12;:30::i;:::-;60383:83;;;;60478:26;60506:22;60532:31;60545:17;60532:12;:31::i;:::-;60477:86;;;;60599:14;60582:13;:31;60574:91;;;;-1:-1:-1;;;60574:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60676:9;;;60731:878;60755:8;:15;60751:1;:19;60731:878;;;60886:4;;-1:-1:-1;60910:9:0;60905:379;60929:14;:21;60925:1;:25;60905:379;;;61001:8;61010:1;61001:11;;;;;;;;;;;;;;60980:14;60995:1;60980:17;;;;;;;;;;;;;;:32;60976:293;;;61044:5;;-1:-1:-1;61228:21:0;:14;61247:1;61228:21;:18;:21;:::i;:::-;61211:38;;60976:293;60952:3;;60905:379;;;;61302:4;61298:300;;;61327:27;61357:6;:19;61364:8;61373:1;61364:11;;;;;;;;;;;;;;61357:19;;;;;;;;;;;:36;;;;;;;;;;;;61327:66;;61442:17;:28;;;61471:10;61483:6;61442:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;61442:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;61442:48:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;61442:48:0;61412:170;;;;-1:-1:-1;;;61412:170:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61298:300;;60772:3;;60731:878;;;;61668:14;61643;:21;:39;61621:140;;;;-1:-1:-1;;;61621:140:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61779:9;61774:446;61798:9;:16;61794:1;:20;61774:446;;;61843:4;;-1:-1:-1;61867:9:0;61862:241;61886:14;:21;61882:1;:25;61862:241;;;61958:9;61968:1;61958:12;;;;;;;;;;;;;;61937:14;61952:1;61937:17;;;;;;;;;;;;;;:33;61933:155;;;62002:5;;-1:-1:-1;62047:21:0;:14;62066:1;62047:21;:18;:21;:::i;:::-;62030:38;;61933:155;61909:3;;61862:241;;;;62121:4;62117:92;;;62146:47;62160:9;62170:1;62160:12;;;;;;;;;;;;;;62174:10;62186:6;62146:13;:47::i;:::-;61816:3;;61774:446;;;-1:-1:-1;62254:19:0;;62232:136;;;;-1:-1:-1;;;62232:136:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62386:83;;;;;;;;62443:17;;62425:16;;62413:10;;62386:83;;;;;;;;;;-1:-1:-1;62489:4:0;;60163:2338;-1:-1:-1;;;;;;;;;;60163:2338:0:o;63742:387::-;63832:30;63865:25;;;:16;:25;;;;;63943:15;;63807:12;;63865:25;63807:12;;63929:30;;;2:2:-1;;;;27:1;24;17:12;2:2;63929:30:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;144:17;;-1:-1;63929:30:0;-1:-1:-1;63901:58:0;-1:-1:-1;63975:9:0;63970:114;63994:15;;63990:19;;63970:114;;;64045:27;64060:8;64069:1;64060:11;;;;;;;;;;;;;;;;;64045:27;;;;;;;;64060:11;;;;;;;64045:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:14;:27::i;:::-;64031:8;64040:1;64031:11;;;;;;;;;;;;;;;;;:41;64011:3;;63970:114;;;;64112:8;64101:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;64101:20:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;64101:20:0;;;64094:27;;;;63742:387;;;;:::o;64632:117::-;64725:16;;;;;;;;64632:117::o;62757:315::-;62854:17;62850:215;;62888:73;62921:11;62934:15;;;;;;;;;;;:24;;;:26;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;62934:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;62934:26:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;62934:26:0;62888:32;:73::i;:::-;62850:215;;;62994:59;63027:11;63040:12;62994:32;:59::i;:::-;62757:315;;:::o;51173:1957::-;51302:7;51324;51346:6;51367:7;51402:14;51419:31;51434:8;51444:5;51419:14;:31::i;:::-;51731:1;51687:14;;;:6;:14;;;;;:31;;;51402:48;;-1:-1:-1;51679:54:0;51687:31;51679:54;51657:136;;;;;-1:-1:-1;;;51657:136:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51858:15;51876:22;51892:5;51876:15;:22::i;:::-;51913:25;;;;:16;:25;;;;;:32;51858:40;;-1:-1:-1;51909:333:0;;51967:25;51995:21;52010:5;51995:14;:21::i;:::-;51967:49;-1:-1:-1;52036:9:0;52031:142;52055:8;:15;52051:1;:19;52031:142;;;52096:25;;;;:16;:25;;;;;52144:11;;52127:29;;52144:8;;52153:1;;52144:11;;;;;;;;;;;;52127:16;:29::i;:::-;27:10:-1;;39:1;23:18;;;45:23;;-1:-1;52096:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52072:3;52031:142;;;;52189:41;52204:16;:25;52221:7;52204:25;;;;;;;;;;;52189:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:14;:41::i;:::-;51909:333;;52254:23;52301:25;;;:16;:25;;;;;;;;52280:47;;;;;;;;;;;;;;;;;;;52254:23;;52280:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:20;:47::i;:::-;52254:73;;52338:23;52364:47;52385:16;:25;52402:7;52385:25;;;;;;;;;;;52364:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:20;:47::i;:::-;52338:73;;52425:23;52450:22;52476;:39;;;52530:8;52553:16;52584;52476:135;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;52476:135:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52476:135:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;52476:135:0;80:15:-1;;;97:9;76:31;65:43;;120:4;113:20;;;7:11;;4:2;;;31:1;28;21:12;4:2;52476:135:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;62:21;;;;123:4;114:14;;138:31;;;135:2;;;182:1;179;172:12;135:2;213:10;;261:11;244:29;;285:43;;;282:58;-1:-1;233:115;230:2;;;361:1;358;351:12;230:2;372:25;;-1:-1;52476:135:0;;420:4:-1;411:14;;;;52476:135:0;;;;;411:14:-1;52476:135:0;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;52476:135:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;62:21;;;;123:4;114:14;;138:31;;;135:2;;;182:1;179;172:12;135:2;213:10;;261:11;244:29;;285:43;;;282:58;-1:-1;233:115;230:2;;;361:1;358;351:12;230:2;372:25;;-1:-1;52476:135:0;;420:4:-1;411:14;;;;52476:135:0;;;;;411:14:-1;52476:135:0;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;52476:135:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52424:187;;;;52624:27;52654:40;52674:8;52684:9;52654:19;:40::i;:::-;52624:70;;52762:186;;;;;;;;52796:8;52762:186;;;;52837:17;52762:186;;;;;;52889:16;52762:186;;;;;;52929:7;52762:186;;;52745:6;:14;52752:6;52745:14;;;;;;;;;;;:203;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52977:6;52966:73;52993:17;53013:16;53031:7;52966:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53060:6;;;;-1:-1:-1;53096:16:0;;-1:-1:-1;53114:7:0;;-1:-1:-1;51173:1957:0;;-1:-1:-1;;;;;;51173:1957:0:o;57913:764::-;57990:7;58040:27;;;:14;:27;;;;;;57990:7;58148:26;58169:4;58148:16;:9;58162:1;58148:16;:13;:16;:::i;:::-;:20;:26;:20;:26;:::i;:::-;58134:40;-1:-1:-1;58187:14:0;58204:30;58227:6;58204:18;:9;58134:40;58204:18;:13;:18;:::i;:30::-;58187:47;-1:-1:-1;58294:14:0;;58319:199;58369:14;;58352:31;;58319:199;;;58427:7;58435:14;58427:23;;;;;;;;;;;;;;;;58418:32;;58465:41;58479:6;58487:10;58499:6;58465:13;:41::i;:::-;58385:16;;58319:199;;;;58530:46;58551:18;58572:3;58530:12;:46::i;:::-;58594:49;;;;;;;;58624:10;;58611:11;;58594:49;;;;;;;;;-1:-1:-1;58663:6:0;57913:764;-1:-1:-1;;;;;57913:764:0:o;49650:34::-;;;;:::o;57181:496::-;57307:19;57344:35;57361:7;57370:8;57344:16;:35::i;:::-;-1:-1:-1;57455:15:0;;;;57499:22;;57455:15;;57499:22;:19;:22;:::i;:::-;57481:15;:40;57564:28;;;;;;;;;;;;;;;;;;-1:-1:-1;57534:27:0;;;:14;:27;;;;;;:58;;;;57564:28;;57534:27;;:58;;:27;;:58;;;:::i;:::-;-1:-1:-1;57534:58:0;;;;;;;;;;;57610:28;;57626:11;;57610:28;;;;;57181:496;;;;:::o;64232:328::-;64358:24;64384:16;64418:26;;:::i;:::-;64447:27;;;;:14;:27;;;;;;;;;64418:56;;;;;;;;;;;;;;;;;;;;;;64447:27;;64418:56;;64447:27;;64418:56;;64447:27;64418:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;64418:56:0;;;-1:-1:-1;;64418:56:0;;;;;;;;;;;64495:17;;64534:18;;;64495:17;;64534:18;;-1:-1:-1;64232:328:0;-1:-1:-1;;;64232:328:0:o;58800:966::-;58917:4;58969:27;;;:14;:27;;;;;59097:18;;;;58969:27;;59071:23;:21;:23::i;:::-;:44;59063:72;;;;;-1:-1:-1;;;59063:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;59146:14;;59171:377;59221:14;;59204:31;;59171:377;;;59279:7;59287:14;59279:23;;;;;;;;;;;;;;;;;;;;59347:14;;;:6;:14;;;;;;:31;;;59419:50;;;;;59448:10;59419:50;;;;;;;;;;;;59279:23;;-1:-1:-1;59347:31:0;;;;;59419:28;;:50;;;;;59279:23;;59419:50;;;;;;;;;59347:31;59419:50;;;2:2:-1;;;;27:1;24;17:12;2:2;59419:50:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59419:50:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;59419:50:0;59393:143;;;;;-1:-1:-1;;;59393:143:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59237:16:0;;59171:377;;;-1:-1:-1;59560:90:0;59573:10;59585:20;:8;59598:6;59585:20;:12;:20;:::i;:::-;59560:90;;;;;;;;;;;;;;;;;:12;:90::i;:::-;59701:10;59688:11;59668:66;59713:20;:8;59726:6;59713:20;:12;:20;:::i;:::-;59668:66;;;;;;;;;;;;;;;-1:-1:-1;59754:4:0;;58800:966;-1:-1:-1;;;;;58800:966:0:o;913:181::-;971:7;1003:5;;;1027:6;;;;1019:46;;;;;-1:-1:-1;;;1019:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1085:1;913:181;-1:-1:-1;;;913:181:0:o;1369:136::-;1427:7;1454:43;1458:1;1461;1454:43;;;;;;;;;;;;;;;;;:3;:43::i;65263:318::-;65390:27;65420:14;;;:6;:14;;;;;;;;:31;;;65477:40;;;;;65420:31;65477:40;;;;;;;;;;;;;;;65420:31;;;;;65390:27;65420:31;;65477:22;;:40;;;;;65420:14;65477:40;;;;;;65390:27;65420:31;65477:40;;;2:2:-1;;;;27:1;24;17:12;2:2;65477:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;65477:40:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;65477:40:0;;-1:-1:-1;65477:40:0;65528:45;;;;;-1:-1:-1;;;65528:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;65263:318;;;;;:::o;44166:429::-;44290:12;;:14;;44369;;;;;44443:13;;;;:15;;44511;;;44282:23;44503:24;44463:2;44435:30;;;;;;44310:12;44282:41;;;;;;44389:7;44361:36;;;;;;44554:15;;;;:24;;;;:33;;44166:429::o;65589:2331::-;65694:27;65724;;;:14;:27;;;;;65770:24;;65762:70;;;;;-1:-1:-1;;;65762:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;65878:9;:18;;;65851:23;:21;:23::i;:::-;:45;;65843:86;;;;;-1:-1:-1;;;65843:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;66034:21;66058:45;66070:9;:18;;;66090:12;66058:11;:45::i;:::-;66034:69;-1:-1:-1;66243:21:0;66267:24;66034:69;66285:5;66267:24;:17;:24;:::i;:::-;66243:48;-1:-1:-1;66310:18:0;66302:74;;;;-1:-1:-1;;;66302:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66425:5;66409:13;:21;66387:137;;;;-1:-1:-1;;;66387:137:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66542:9;66537:1376;66561:24;;66557:28;;66537:1376;;;66607:14;66624:9;:17;;66642:1;66624:20;;;;;;;;;;;;;;;;;;;;66689:14;;;:6;:14;;;;;;;:31;;;66624:20;;-1:-1:-1;66689:31:0;;66743:40;66735:79;;;;;-1:-1:-1;;;66735:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;66831:30;66881:14;;;:6;:14;;;;;;;;:22;;;;66864:40;;:16;:40;;;;;66955:51;;;;;;;;;;;;;;;;;66864:40;;66831:30;;;66955:51;;66864:40;;66831:30;;66955:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66991:13;66955:18;:51::i;:::-;66921:85;;;;67049:2;67023:140;;;;-1:-1:-1;;;67023:140:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67178:27;67208:8;67217:12;67208:22;;;;;;;;;;;;;;;;67270:40;;;;;;;;67208:22;;;;;;;67270:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67208:22;-1:-1:-1;67208:22:0;;67270:40;;67295:13;67270:8;:40::i;:::-;67245:65;;;;67382:9;67416:13;67402:2;67394:11;;:36;67382:48;;67447:19;67469:17;:29;;;:31;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;67469:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;67469:31:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;67469:31:0;67534:30;;;;;;;;;;;;;;;;;;;;;;67469:31;;-1:-1:-1;67515:16:0;;67534:24;;;;;;:30;;;;;67469:31;;67534:30;;;;;;;67515:16;67534:24;:30;;;2:2:-1;;;;27:1;24;17:12;2:2;67534:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;67534:30:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;67534:30:0;;-1:-1:-1;67581:321:0;;;;67617:15;67635:43;;;;;;:36;;;;:29;:11;67651:12;67635:29;:15;:29;:::i;:::-;:33;:36;:33;:36;:::i;:43::-;67617:61;;67697:189;67740:17;67781:7;67697:189;;;;;;;;;;;;;;;;;:12;:189::i;:::-;67581:321;;-1:-1:-1;;66587:3:0;;;;;-1:-1:-1;66537:1376:0;;-1:-1:-1;;;;;;;;66537:1376:0;;;65589:2331;;;;;:::o;45103:141::-;45170:16;45217:5;45206:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;45206:30:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;62:21;;;;123:4;114:14;;138:31;;;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;373:25;;-1:-1;45206:30:0;;421:4:-1;412:14;;;;45206:30:0;;;;;412:14:-1;45206:30:0;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;45206:30:0;;;;;;;;;;;45199:37;;45103:141;;;:::o;44678:353::-;44740:18;;:::i;:::-;-1:-1:-1;44896:2:0;44951:72;;44850:7;44970:21;;;;;44798:12;44790:21;;;44951:72;;;44970:21;;;;44842:16;;;;44970:21;;;;;;44951:72;;45000:21;;;;;;;44889:9;;;;45000:21;;;;;;;-1:-1:-1;45000:21:0;;;;;;;-1:-1:-1;;44951:72:0;;44678:353::o;41731:2295::-;41834:15;;41868:16;41860:61;;;;;-1:-1:-1;;;41860:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41976:31;;:::i;:::-;42010:8;42019:1;42010:11;;;;;;;;;;;;;;;;;;42123:17;;:19;42010:11;;-1:-1:-1;42123:32:0;;;42101:136;;;;-1:-1:-1;;;42101:136:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42315:17;;:19;;;:32;;;42293:136;;;;-1:-1:-1;;;42293:136:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42483:30;;:::i;:::-;42516:8;42540:1;42525:12;:16;42516:26;;;;;;;;;;;;;;42483:59;;42629:24;42656:51;42688:11;:16;;;:18;;;42656:51;;42663:11;:17;;;:19;;;42656:27;;:31;;:51;;;;:::i;:::-;42779:16;;:18;42754:17;;;;:19;42629:78;;-1:-1:-1;42718:26:0;;42747:51;;;:27;;;;:51;;:31;:51;:::i;:::-;42718:80;;42852:1;42831:17;:22;;:66;;;;;42878:19;42857:17;:40;;42831:66;42809:201;;;;-1:-1:-1;;;42809:201:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43101:31;43119:12;43101:17;:31::i;:::-;43287:1;43270:749;43294:12;43290:1;:16;43270:749;;;43328:30;;:::i;:::-;43361:8;43374:1;43370;:5;43361:15;;;;;;;;;;;;;;43328:48;;43391:31;;:::i;:::-;43425:8;43434:1;43425:11;;;;;;;;;;;;;;43391:45;;43532:31;43550:12;43532:17;:31::i;:::-;43687:17;;:19;43664:17;;;;:19;:42;;;;;;;43638:149;;;;-1:-1:-1;;;43638:149:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43911:12;:17;;;:19;;;43888:42;;:11;:17;;;:19;;;:42;;;43862:145;;;;-1:-1:-1;;;43862:145:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43308:3:0;;43270:749;;;;41731:2295;;;;;;:::o;68127:497::-;68211:6;68230:23;68256:8;68265:1;68256:11;;;;;;;;;;;;;;:17;;;:19;;;68230:45;;68292:16;:21;;68312:1;68292:21;68288:62;;;68337:1;68330:8;;;;;68288:62;68367:9;68362:211;68386:8;:15;68382:1;:19;68362:211;;;68423:26;;:::i;:::-;68452:8;68461:1;68452:11;;;;;;;;;;;;;;68423:40;;68501:16;68482:35;;:7;:13;;;:15;;;:35;;;68478:84;;68545:1;68538:8;;;;;;;68478:84;-1:-1:-1;68403:3:0;;68362:211;;;-1:-1:-1;68599:16:0;68127:497;-1:-1:-1;;68127:497:0:o;68889:518::-;68973:6;68992:23;69018:8;69027:1;69018:11;;;;;;;;;;;;;;:17;;;:19;;;68992:45;;69054:16;:21;;69074:1;69054:21;69050:62;;;69099:1;69092:8;;;;;69050:62;69129:9;69124:232;69148:8;:15;69144:1;:19;69124:232;;;69185:26;;:::i;:::-;69214:8;69223:1;69214:11;;;;;;;;;;;;;;69185:40;;69285:7;:13;;;:15;;;69244:56;;:37;69264:16;69244:37;;:7;:13;;;:15;;;:19;;;;:37;;;;:::i;:::-;:56;69240:105;;69328:1;69321:8;;;;;;;69240:105;-1:-1:-1;69165:3:0;;69124:232;;65062:193;65186:9;65234:4;65240:6;65220:27;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;65220:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65220:27:0;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;65220:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;65213:34:0;65062:193;-1:-1:-1;;;65062:193:0:o;2243:471::-;2301:7;2546:6;2542:47;;-1:-1:-1;2576:1:0;2569:8;;2542:47;2613:5;;;2617:1;2613;:5;:1;2637:5;;;;;:10;2629:56;;;;-1:-1:-1;;;2629:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3182:132;3240:7;3267:39;3271:1;3274;3267:39;;;;;;;;;;;;;;;;;:3;:39::i;16752:172::-;16837:79;16850:9;16861:6;16837:79;;;;;;;;;;;;;;;;;:12;:79::i;53138:3720::-;54020:24;;54059:354;54083:7;:14;54079:1;:18;54059:354;;;54119:21;54143:6;:18;54150:7;54158:1;54150:10;;;;;;;;;;;;;;54143:18;;;;;;;;;;;54119:42;;54201:8;54184:4;:13;;;:25;54176:76;;;;-1:-1:-1;;;54176:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54317:12;;;;54267:30;54300;;;:16;:30;;;;;54385:15;;54364:37;;:16;;:37;:20;:37;:::i;:::-;54345:56;-1:-1:-1;;;54099:3:0;;54059:354;;;-1:-1:-1;54425:27:0;54467:31;54514:16;54501:30;;;2:2:-1;;;;27:1;24;17:12;2:2;54501:30:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;144:17;;-1:-1;54501:30:0;-1:-1:-1;54467:64:0;-1:-1:-1;54547:9:0;54542:791;54566:7;:14;54562:1;:18;54542:791;;;54602:21;54626:6;:18;54633:7;54641:1;54633:10;;;;;;;;;;;;;;54626:18;;;;;;;;;;;54602:42;;54659:30;54692:16;:30;54709:4;:12;;;54692:30;;;;;;;;;;;54659:63;;54742:9;54754:1;54742:13;;54737:585;54761:15;;54757:19;;54737:585;;;54802:17;54822:8;54831:1;54822:11;;;;;;;;;;;;;;;:17;:11;;;;;:17;:19;;;;-1:-1:-1;54822:11:0;54896:222;54920:19;54916:1;:23;54896:222;;;54995:10;54973:32;;:15;54989:1;54973:18;;;;;;;;;;;;;;:32;;;54969:130;;;55039:4;55034:9;;55070:5;;54969:130;54941:3;;54896:222;;;;55142:2;55138:59;;;55169:8;;;;55138:59;55256:10;55217:15;55233:19;55217:36;;;;;;;;:49;;;;:36;;;;;;;;;;;:49;-1:-1:-1;;55285:21:0;;;;;54737:585;54778:3;;54737:585;;;-1:-1:-1;;;54582:3:0;;54542:791;;;-1:-1:-1;55350:9:0;55345:1506;55369:15;:22;55365:1;:26;55345:1506;;;55413:11;55427:15;55443:1;55427:18;;;;;;;;;;;;;;;;;;;-1:-1:-1;55460:23:0;55528:1;55460:23;55544:739;55568:7;:14;55564:1;:18;55544:739;;;55608:21;55632:6;:18;55639:7;55647:1;55639:10;;;;;;;;;;;;;;55632:18;;;;;;;;;;;55608:42;;55669:30;55702:16;:30;55719:4;:12;;;55702:30;;;;;;;;;;;55669:63;;55752:20;55774:7;55785:34;55804:8;55785:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55814:4;55785:18;:34::i;:::-;55751:68;;;;55848:2;55840:40;;;;;-1:-1:-1;;;55840:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55902:9;55913:8;55925:38;55934:8;55943:12;55934:22;;;;;;;;;;;;;;;;;55925:38;;;;;;;;55934:22;;;;;;;55925:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55958:4;55925:8;:38::i;:::-;55901:62;;;;55988:1;:6;;55993:1;55988:6;55984:284;;56135:50;56162:22;:15;:22;;;;:19;:22;:::i;:::-;56135;:15;:22;;;;:19;:22;:::i;:::-;:26;:50;:26;:50;:::i;:::-;56117:68;-1:-1:-1;56226:22:0;:15;:22;;;;:19;:22;:::i;:::-;56208:40;;55984:284;-1:-1:-1;;55584:3:0;;;;;-1:-1:-1;55544:739:0;;-1:-1:-1;;;55544:739:0;;-1:-1:-1;56703:25:0;:15;:25;;;;:19;:25;:::i;:::-;56684:15;:44;56658:181;;;;-1:-1:-1;;;56658:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;55393:3:0;;55345:1506;;15402:162;15504:3;;15402:162::o;16354:390::-;16509:29;16531:6;16509:21;:29::i;:::-;16540:12;16501:52;;;;;-1:-1:-1;;;16501:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;16501:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16583:33:0;;16565:12;;16583:14;;;;16605:6;;16565:12;16583:33;16565:12;16583:33;16605:6;16583:14;:33;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;16564:52:0;;;16635:7;16627:45;;;;;-1:-1:-1;;;16627:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16688:48;;;;;;;;;;;;16711:4;;16688:48;;;;;;;;;16354:390;;;;:::o;1800:192::-;1886:7;1922:12;1914:6;;;;1906:29;;;;-1:-1:-1;;;1906:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1906:29:0;-1:-1:-1;;;1958:5:0;;;1800:192::o;47405:818::-;47497:21;47555:15;;:26;;;;;;;;47497:21;;47555:15;;;:24;;:26;;;;;;;;;;;;;;47497:21;47555:15;:26;;;2:2:-1;;;;27:1;24;17:12;2:2;47555:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47555:26:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;47555:26:0;;-1:-1:-1;47600:13:0;47592:80;;;;-1:-1:-1;;;47592:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47693:11;47685:52;;;;;-1:-1:-1;;;47685:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47761:6;47782:17;;;47778:63;;;-1:-1:-1;47821:8:0;47778:63;47910:9;47875:15;;;;;;;;;;;:28;;;47904:2;47875:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;47875:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47875:32:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;47875:32:0;:44;47853:131;;;;-1:-1:-1;;;47853:131:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47997:4;;48012:152;48019:7;;48012:152;;48083:9;48047:15;;;;;;;;;;;:28;;;48076:2;48047:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;48047:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48047:32:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;48047:32:0;:45;48043:91;;48113:5;;48043:91;48148:4;;48012:152;;;48183:15;;;:32;;;;;;:15;48208:6;;48183:32;;;;;;:15;;;;;:24;;:32;;;;;;;;;;;;;;;;;:15;:32;;;2:2:-1;;;;27:1;24;17:12;2:2;48183:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48183:32:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;48183:32:0;;47405:818;-1:-1:-1;;;;;47405:818:0:o;69725:347::-;69884:15;;69844:9;69910:155;69917:5;;69910:155;;69939:3;;;;;;;;69983:1;69961:23;;:8;69970:1;69961:11;;;;;;;;;;;;;;:16;;;:18;;;:23;;;69957:97;;-1:-1:-1;70010:4:0;70033:5;;69957:97;69910:155;;;69725:347;;;;;:::o;40570:746::-;40747:9;;:11;;40789;;;;;40831:10;;;;:12;;40874;;;40673:17;;;;40740:19;;;;;40782;;;40824:20;;;;40867;40908:7;;;40900:44;;;;;-1:-1:-1;;;40900:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;40978:7;;;;-1:-1:-1;41162:6:0;;;41146;;;41145:13;;41162:6;;;41161:13;;41145:29;41134:8;41195:6;;;41187:30;;;;;-1:-1:-1;;;41187:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;41240:6;41236:1;:10;41228:47;;;;;-1:-1:-1;;;41228:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;41306:1;40570:746;;-1:-1:-1;40570:746:0;;-1:-1:-1;;;;;;40570:746:0:o;6811:218::-;6867:6;6897:5;;;6922:6;;;;;;:16;;;6937:1;6932;:6;;6922:16;6921:38;;;;6948:1;6944;:5;:14;;;;;6957:1;6953;:5;6944:14;6913:87;;;;-1:-1:-1;;;6913:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41424:207;41516:12;;:14;41553:13;;;;:15;41587:7;;;;;;;;41579:44;;;;;-1:-1:-1;;;41579:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;41424:207;;;:::o;3802:345::-;3888:7;3990:12;3983:5;3975:28;;;;-1:-1:-1;;;3975:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;3975:28:0;;4014:9;4030:1;4026;:5;;;;;;;3802:345;-1:-1:-1;;;;;3802:345:0:o;16063:182::-;16184:4;16217:20;-1:-1:-1;16207:30:0;;16063:182::o;49381:20694::-;;;;;;;;;-1:-1:-1;49381:20694:0;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49381:20694:0;;;-1:-1:-1;49381:20694:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;49381:20694:0;;;;;;;;:::o

ipfs://cab4411aa577d3284840d9b309579cfadacb342772f5333f7055c8e1829058a6