Contract 0x1e04db9125a9d5ce16f48a24d00d317332d19d96

Contract Overview

Balance:
0 BNB
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xe87cf87817a424cddfa1b64d9d2083d3901340eb6b2a3e6a0a60dc216f253a230x6080604070159802021-03-12 7:10:00194 days 20 hrs ago0x20000b9b01e93a39db9d286e9264eff7f2af16e9 IN  Contract Creation0 BNB0.05277958
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x6d136504f7c25b16fb9d1495ca4fcd9c0c32141dbebefa8a471febe93f9f201487232982021-05-10 15:29:45135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x13783decf87cfb46dbf8dd3d141fd3a2874364756ab9d34142a60055f9f4519587232962021-05-10 15:29:39135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x81844595eaa8d4ca9367fa81e718c843a1052bf0f2ed0ddb9db09433931d989e87232962021-05-10 15:29:39135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xb935828437c3eac9b570e1868996e3e89a74063abc1eafbb128e8c54b1f16fa587232932021-05-10 15:29:30135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xae5904d90a58f3995453cbc0026609ad253444cb0efce87322d2339090bafbad87232922021-05-10 15:29:27135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x01f0ae1f111b6485aa791a906cc4356c52ce7f0cfd5b525810bca4a0b1d2e41587232902021-05-10 15:29:21135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x9eb999825c6cd6c30b9fb4d7367d25a19a0fa365fd089e84b10ddc6f003c71f587232882021-05-10 15:29:15135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xc4c4350c257237743d2b7fc4a9d9d4a80937f348c75a5616886e00daf207726287232862021-05-10 15:29:09135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x79a462f1739cc8535ef2b570348d383d523894cedfb10bf5355a7a7850e269ea87232852021-05-10 15:29:06135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xcc59720d946b317fbd5bc3e18efe3ab5ac6ae09aa1542b38774129507ed7f6c787232832021-05-10 15:29:00135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x3824f7758800f6727a688fa8ae806c5c983646e3b921ec56f2fc7a8951a5d2b587232812021-05-10 15:28:54135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x8a220e330e991c1802a822a6a91390bb3b6afd7a3293b89279d65eb7e83e110b87232812021-05-10 15:28:54135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x39f50602372d7ddfbce982cc5663835a47d7b2b5e0ad229f63866ef49e9b289f87232792021-05-10 15:28:48135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x51e55e6e27d8a79e3f5a15a7f1e6d3020d39a33384ec5b3a8ab01966b85073b687232772021-05-10 15:28:42135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x24c38ab1bcb30f180429490e6b601b5f51a331eef3e5ddcc07211586f65355f587232752021-05-10 15:28:36135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xa90b11b66c2e84765262ce9d7b43c27203e560d33fc297589f1ab8002f6ee70d87232742021-05-10 15:28:33135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x968f04a5b3eb79d6dd138f76f9c601a19bfd42b9319bacc5b1531a9da5bd64d687232712021-05-10 15:28:24135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x625edd805b5ac7a9c251db5a2a161834a6f19c94804427e24cc412256304166f87232702021-05-10 15:28:21135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xcd3c81994497861edfb7f225ce1406f7e4f961839561beca33b2f5ec93adbae187232682021-05-10 15:28:15135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x635b5dd0207b412fb37ef2d13bae7685bdabd4af78e409590b1007a9fd6698d187232662021-05-10 15:28:09135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x563848ea74d7ea9e47b3d850e129392aaca918cf4247da5759713d64e8ac180687232652021-05-10 15:28:06135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xb6b4e5829746b0f2a3d70b4082e8618203de6335784bdb027e2f34e66a6c6eea87232612021-05-10 15:27:54135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x5454bdcbeaefd3db11bab611c2102420886ba2ab16e709b6e51bdf6c890d9d1c87232602021-05-10 15:27:51135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0xca3ac9c7bc10558f71439eae8cf56bf52c2764419ecbe09b004c9d450b98149987232592021-05-10 15:27:48135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
0x1e901df356d1fd45c48a59a946231b2f991b85fa8822c8ebbcc25d2d5b08e4b487232572021-05-10 15:27:42135 days 12 hrs ago 0x2bfdfc92fc1cd1dd503a6836450e711bc4a9b0d7 0x1e04db9125a9d5ce16f48a24d00d317332d19d960 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
CFDVault

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-12
*/

// File: @openzeppelin\contracts-upgradeable\math\SafeMathUpgradeable.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.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 SafeMathUpgradeable {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

// File: @openzeppelin\contracts-upgradeable\token\ERC20\IERC20Upgradeable.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @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: node_modules\@openzeppelin\contracts-upgradeable\token\ERC20\IERC20Upgradeable.sol


// File: node_modules\@openzeppelin\contracts-upgradeable\math\SafeMathUpgradeable.sol


// File: node_modules\@openzeppelin\contracts-upgradeable\utils\AddressUpgradeable.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin\contracts-upgradeable\token\ERC20\SafeERC20Upgradeable.sol


pragma solidity >=0.6.0 <0.8.0;




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

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

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

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

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

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

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

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

// File: node_modules\@openzeppelin\contracts-upgradeable\proxy\Initializable.sol


// solhint-disable-next-line compiler-version
pragma solidity >=0.4.24 <0.8.0;


/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 * 
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 * 
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {

    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        // solhint-disable-next-line no-inline-assembly
        assembly { cs := extcodesize(self) }
        return cs == 0;
    }
}

// File: node_modules\@openzeppelin\contracts-upgradeable\GSN\ContextUpgradeable.sol


pragma solidity >=0.6.0 <0.8.0;


/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {
    }
    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;
    }
    uint256[50] private __gap;
}

// File: @openzeppelin\contracts-upgradeable\access\OwnableUpgradeable.sol


pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

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

// File: @openzeppelin\contracts-upgradeable\utils\ReentrancyGuardUpgradeable.sol


pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuardUpgradeable is Initializable {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

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

    uint256 private _status;

    function __ReentrancyGuard_init() internal initializer {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal initializer {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// File: @openzeppelin\contracts-upgradeable\math\SignedSafeMathUpgradeable.sol

pragma solidity >=0.6.0 <0.8.0;

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

    /**
     * @dev Returns the multiplication of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot 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 Returns the integer division of two signed 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(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 Returns the subtraction of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot 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 Returns the addition of two signed integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot 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: contracts\utils\SignedDecimalMath.sol

pragma solidity ^0.6.12;


/// @dev Implements simple signed fixed point math add, sub, mul and div operations.
library SignedDecimalMath {
    using SignedSafeMathUpgradeable for int256;

    /// @dev Returns 1 in the fixed point representation, with `decimals` decimals.
    function unit(uint8 decimals) internal pure returns (int256) {
        return int256(10**uint256(decimals));
    }

    /// @dev Adds x and y, assuming they are both fixed point with 18 decimals.
    function addd(int256 x, int256 y) internal pure returns (int256) {
        return x.add(y);
    }

    /// @dev Subtracts y from x, assuming they are both fixed point with 18 decimals.
    function subd(int256 x, int256 y) internal pure returns (int256) {
        return x.sub(y);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with 18 digits.
    function muld(int256 x, int256 y) internal pure returns (int256) {
        return muld(x, y, 18);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with `decimals` digits.
    function muld(
        int256 x,
        int256 y,
        uint8 decimals
    ) internal pure returns (int256) {
        return x.mul(y).div(unit(decimals));
    }

    /// @dev Divides x between y, assuming they are both fixed point with 18 digits.
    function divd(int256 x, int256 y) internal pure returns (int256) {
        return divd(x, y, 18);
    }

    /// @dev Divides x between y, assuming they are both fixed point with `decimals` digits.
    function divd(
        int256 x,
        int256 y,
        uint8 decimals
    ) internal pure returns (int256) {
        return x.mul(unit(decimals)).div(y);
    }
}

// File: contracts\utils\DecimalMath.sol

pragma solidity ^0.6.12;


/// @dev Implements simple fixed point math add, sub, mul and div operations.
/// @author Alberto Cuesta Cañada
library DecimalMath {
    using SafeMathUpgradeable for uint256;

    /// @dev Returns 1 in the fixed point representation, with `decimals` decimals.
    function unit(uint8 decimals) internal pure returns (uint256) {
        return 10**uint256(decimals);
    }

    /// @dev Adds x and y, assuming they are both fixed point with 18 decimals.
    function addd(uint256 x, uint256 y) internal pure returns (uint256) {
        return x.add(y);
    }

    /// @dev Subtracts y from x, assuming they are both fixed point with 18 decimals.
    function subd(uint256 x, uint256 y) internal pure returns (uint256) {
        return x.sub(y);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with 18 digits.
    function muld(uint256 x, uint256 y) internal pure returns (uint256) {
        return muld(x, y, 18);
    }

    /// @dev Multiplies x and y, assuming they are both fixed point with `decimals` digits.
    function muld(
        uint256 x,
        uint256 y,
        uint8 decimals
    ) internal pure returns (uint256) {
        return x.mul(y).div(unit(decimals));
    }

    /// @dev Divides x between y, assuming they are both fixed point with 18 digits.
    function divd(uint256 x, uint256 y) internal pure returns (uint256) {
        return divd(x, y, 18);
    }

    /// @dev Divides x between y, assuming they are both fixed point with `decimals` digits.
    function divd(
        uint256 x,
        uint256 y,
        uint8 decimals
    ) internal pure returns (uint256) {
        return x.mul(unit(decimals)).div(y);
    }
}

// File: contracts\utils\Decimal.sol

pragma solidity ^0.6.12;



library Decimal {
    using DecimalMath for uint256;
    using SafeMathUpgradeable for uint256;

    struct decimal {
        uint256 d;
    }

    function zero() internal pure returns (decimal memory) {
        return decimal(0);
    }

    function one() internal pure returns (decimal memory) {
        return decimal(DecimalMath.unit(18));
    }

    function toUint(decimal memory x) internal pure returns (uint256) {
        return x.d;
    }

    function modD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        return decimal(x.d.mul(DecimalMath.unit(18)) % y.d);
    }

    function cmp(decimal memory x, decimal memory y) internal pure returns (int8) {
        if (x.d > y.d) {
            return 1;
        } else if (x.d < y.d) {
            return -1;
        }
        return 0;
    }

    /// @dev add two decimals
    function addD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.add(y.d);
        return t;
    }

    /// @dev subtract two decimals
    function subD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.sub(y.d);
        return t;
    }

    /// @dev multiple two decimals
    function mulD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.muld(y.d);
        return t;
    }

    /// @dev multiple a decimal by a uint256
    function mulScalar(decimal memory x, uint256 y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.mul(y);
        return t;
    }

    /// @dev divide two decimals
    function divD(decimal memory x, decimal memory y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.divd(y.d);
        return t;
    }

    /// @dev divide a decimal by a uint256
    function divScalar(decimal memory x, uint256 y) internal pure returns (decimal memory) {
        decimal memory t;
        t.d = x.d.div(y);
        return t;
    }
}

// File: contracts\utils\SignedDecimal.sol

pragma solidity ^0.6.12;




library SignedDecimal {
    using SignedDecimalMath for int256;
    using SignedSafeMathUpgradeable for int256;

    struct signedDecimal {
        int256 d;
    }

    function zero() internal pure returns (signedDecimal memory) {
        return signedDecimal(0);
    }

    function toInt(signedDecimal memory x) internal pure returns (int256) {
        return x.d;
    }

    function isNegative(signedDecimal memory x) internal pure returns (bool) {
        if (x.d < 0) {
            return true;
        }
        return false;
    }

    function abs(signedDecimal memory x) internal pure returns (Decimal.decimal memory) {
        Decimal.decimal memory t;
        if (x.d < 0) {
            t.d = uint256(0 - x.d);
        } else {
            t.d = uint256(x.d);
        }
        return t;
    }

    /// @dev add two decimals
    function addD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.add(y.d);
        return t;
    }

    /// @dev subtract two decimals
    function subD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.sub(y.d);
        return t;
    }

    /// @dev multiple two decimals
    function mulD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.muld(y.d);
        return t;
    }

    /// @dev multiple a signedDecimal by a int256
    function mulScalar(signedDecimal memory x, int256 y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.mul(y);
        return t;
    }

    /// @dev divide two decimals
    function divD(signedDecimal memory x, signedDecimal memory y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.divd(y.d);
        return t;
    }

    /// @dev divide a signedDecimal by a int256
    function divScalar(signedDecimal memory x, int256 y) internal pure returns (signedDecimal memory) {
        signedDecimal memory t;
        t.d = x.d.div(y);
        return t;
    }
}

// File: contracts\interface\IExchange.sol

pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;




interface IExchange {
    /**
     * @notice asset direction, used in getInputPrice, getOutputPrice, swapInput and swapOutput
     * @param ADD_TO_AMM add asset to Amm
     * @param REMOVE_FROM_AMM remove asset from Amm
     */
    enum Dir {ADD_TO_AMM, REMOVE_FROM_AMM}

    struct LiquidityChangedSnapshot {
        SignedDecimal.signedDecimal cumulativeNotional;
        // the base/quote reserve of amm right before liquidity changed
        Decimal.decimal quoteAssetReserve;
        Decimal.decimal baseAssetReserve;
        // total position size owned by amm after last snapshot taken
        // `totalPositionSize` = currentBaseAssetReserve - lastLiquidityChangedHistoryItem.baseAssetReserve + prevTotalPositionSize
        SignedDecimal.signedDecimal totalPositionSize;
    }

    function swapInput(
        Dir _dir,
        Decimal.decimal calldata _quoteAssetAmount,
        Decimal.decimal calldata _baseAssetAmountLimit
    ) external returns (Decimal.decimal memory);

    function swapOutput(
        Dir _dir,
        Decimal.decimal calldata _baseAssetAmount,
        Decimal.decimal calldata _quoteAssetAmountLimit,
        bool _skipFluctuationCheck
    ) external returns (Decimal.decimal memory);

    function migrateLiquidity(Decimal.decimal calldata _liquidityMultiplier, Decimal.decimal calldata _priceLimitRatio)
        external;

    function shutdown() external;

    function settleFunding() external returns (SignedDecimal.signedDecimal memory);

    function calcFee(Decimal.decimal calldata _quoteAssetAmount) external view returns (Decimal.decimal memory);

    function calcBaseAssetAfterLiquidityMigration(
        SignedDecimal.signedDecimal memory _baseAssetAmount,
        Decimal.decimal memory _fromQuoteReserve,
        Decimal.decimal memory _fromBaseReserve
    ) external view returns (SignedDecimal.signedDecimal memory);

    function getInputTwap(Dir _dir, Decimal.decimal calldata _quoteAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getOutputTwap(Dir _dir, Decimal.decimal calldata _baseAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getInputPrice(Dir _dir, Decimal.decimal calldata _quoteAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getOutputPrice(Dir _dir, Decimal.decimal calldata _baseAssetAmount)
        external
        view
        returns (Decimal.decimal memory);

    function getInputPriceWithReserves(
        Dir _dir,
        Decimal.decimal memory _quoteAssetAmount,
        Decimal.decimal memory _quoteAssetPoolAmount,
        Decimal.decimal memory _baseAssetPoolAmount
    ) external pure returns (Decimal.decimal memory);

    function getOutputPriceWithReserves(
        Dir _dir,
        Decimal.decimal memory _baseAssetAmount,
        Decimal.decimal memory _quoteAssetPoolAmount,
        Decimal.decimal memory _baseAssetPoolAmount
    ) external pure returns (Decimal.decimal memory);

    function getSpotPrice() external view returns (Decimal.decimal memory);

    function getLiquidityHistoryLength() external view returns (uint256);

    // overridden by state variable
    function quoteAsset() external view returns (IERC20Upgradeable);

    function open() external view returns (bool);

    // can not be overridden by state variable due to type `Deciaml.decimal`
    function getSettlementPrice() external view returns (Decimal.decimal memory);

    function getBaseAssetDeltaThisFundingPeriod() external view returns (SignedDecimal.signedDecimal memory);

    function getCumulativeNotional() external view returns (SignedDecimal.signedDecimal memory);

    function getMaxHoldingBaseAsset() external view returns (Decimal.decimal memory);

    function getOpenInterestNotionalCap() external view returns (Decimal.decimal memory);

    function getLiquidityChangedSnapshots(uint256 i) external view returns (LiquidityChangedSnapshot memory);

    function mint(address account, uint256 amount) external;

    function burn(address account, uint256 amount) external;

    function getPositionSize() external view returns (Decimal.decimal memory, Decimal.decimal memory);

    function getMMUnrealizedPNL(Decimal.decimal memory _baseAssetReserve, Decimal.decimal memory _quoteAssetReserve)
        external
        view
        returns (SignedDecimal.signedDecimal memory);

    function moveAMMPriceToOracle(uint256 _oraclePrice, bytes32 _priceFeedKey) external;

    function setPriceFeed(address _priceFeed) external;

    function getReserve() external view returns (Decimal.decimal memory, Decimal.decimal memory);
}

// File: contracts\interface\ICFD.sol

pragma solidity ^0.6.12;





interface ICFD {
    //
    // Struct and Enum
    //
    enum Side {BUY, SELL}
    enum PnlCalcOption {SPOT_PRICE, TWAP}

    /// @notice This struct records personal position information
    /// @param size denominated in amm.baseAsset
    /// @param margin isolated margin
    /// @param openNotional the quoteAsset value of position when opening position. the cost of the position
    /// @param lastUpdatedCumulativePremiumFraction for calculating funding payment, record at the moment every time when trader open/reduce/close position
    /// @param lastUpdatedCumulativeOvernightFeeRate for calculating holding fee, record at the moment every time when trader open/reduce/close position
    /// @param liquidityHistoryIndex
    /// @param blockNumber the block number of the last position
    struct Position {
        SignedDecimal.signedDecimal size;
        Decimal.decimal margin;
        Decimal.decimal openNotional;
        SignedDecimal.signedDecimal lastUpdatedCumulativePremiumFraction;
        Decimal.decimal lastUpdatedCumulativeOvernightFeeRate;
        uint256 liquidityHistoryIndex;
        uint256 blockNumber;
    }

    function getMMLiquidity(address _exchange) external view returns (SignedDecimal.signedDecimal memory);

    function getLatestCumulativePremiumFraction(IExchange _exchange)
        external
        view
        returns (SignedDecimal.signedDecimal memory);

    function getLatestCumulativeOvernightFeeRate(IExchange _exchange) external view returns (Decimal.decimal memory);

    function getPositionNotionalAndUnrealizedPnl(
        IExchange _exchange,
        address _trader,
        PnlCalcOption _pnlCalcOption
    ) external view returns (Decimal.decimal memory positionNotional, SignedDecimal.signedDecimal memory unrealizedPnl);

    function getPosition(IExchange _exchange, address _trader) external view returns (Position memory);

    function getUnadjustedPosition(IExchange _exchange, address _trader)
        external
        view
        returns (Position memory position);

    function getMarginRatio(IExchange _exchange, address _trader)
        external
        view
        returns (SignedDecimal.signedDecimal memory);
}

// File: contracts\interface\IInsuranceFund.sol

pragma solidity ^0.6.12;




interface IInsuranceFund {
    function withdraw(Decimal.decimal calldata _amount)
        external
        returns (Decimal.decimal memory badDebt);

    function setExchange(IExchange _exchange) external;

    function setBeneficiary(address _beneficiary) external;
}

// File: contracts\interface\ISystemSettings.sol

pragma solidity ^0.6.12;





interface ISystemSettings {
    function initMarginRatio() external view returns (Decimal.decimal memory);

    function maintenanceMarginRatio() external view returns (Decimal.decimal memory);

    function liquidationFeeRatio() external view returns (Decimal.decimal memory);

    function maxliquidationFee() external view returns (Decimal.decimal memory);

    function insuranceFundFeeRatio() external view returns (Decimal.decimal memory);

    function lpWithdrawFeeRatio() external view returns (Decimal.decimal memory);

    function overnightFeeRatio() external view returns (Decimal.decimal memory);

    function overnightFeeLpShareRatio() external view returns (Decimal.decimal memory);

    function fundingFeeLpShareRatio() external view returns (Decimal.decimal memory);

    function overnightFeePeriod() external view returns (uint256);

    function isExistedExchange(IExchange _exchange) external view returns (bool);

    function getAllExchanges() external view returns (IExchange[] memory);

    function getInsuranceFund(IExchange _exchange) external view returns (IInsuranceFund);

    function setNextOvernightFeeTime(IExchange _exchange) external;

    function nextOvernightFeeTime(address _exchange) external view returns (uint256);
}

// File: contracts\utils\MixedDecimal.sol

pragma solidity ^0.6.12;




/// @dev To handle a signedDecimal add/sub/mul/div a decimal and provide convert decimal to signedDecimal helper
library MixedDecimal {
    using SignedDecimal for SignedDecimal.signedDecimal;
    using SignedSafeMathUpgradeable for int256;

    uint256 private constant _INT256_MAX = 2**255 - 1;
    string private constant ERROR_NON_CONVERTIBLE = "MixedDecimal: uint value is bigger than _INT256_MAX";

    modifier convertible(Decimal.decimal memory x) {
        require(_INT256_MAX >= x.d, ERROR_NON_CONVERTIBLE);
        _;
    }

    function fromDecimal(Decimal.decimal memory x)
        internal
        pure
        convertible(x)
        returns (SignedDecimal.signedDecimal memory)
    {
        return SignedDecimal.signedDecimal(int256(x.d));
    }

    function toUint(SignedDecimal.signedDecimal memory x) internal pure returns (uint256) {
        return x.abs().d;
    }

    /// @dev add SignedDecimal.signedDecimal and Decimal.decimal, using SignedSafeMath directly
    function addD(SignedDecimal.signedDecimal memory x, Decimal.decimal memory y)
        internal
        pure
        convertible(y)
        returns (SignedDecimal.signedDecimal memory)
    {
        SignedDecimal.signedDecimal memory t;
        t.d = x.d.add(int256(y.d));
        return t;
    }

    /// @dev subtract SignedDecimal.signedDecimal by Decimal.decimal, using SignedSafeMath directly
    function subD(SignedDecimal.signedDecimal memory x, Decimal.decimal memory y)
        internal
        pure
        convertible(y)
        returns (SignedDecimal.signedDecimal memory)
    {
        SignedDecimal.signedDecimal memory t;
        t.d = x.d.sub(int256(y.d));
        return t;
    }

    /// @dev multiple a SignedDecimal.signedDecimal by Decimal.decimal
    function mulD(SignedDecimal.signedDecimal memory x, Decimal.decimal memory y)
        internal
        pure
        convertible(y)
        returns (SignedDecimal.signedDecimal memory)
    {
        SignedDecimal.signedDecimal memory t;
        t = x.mulD(fromDecimal(y));
        return t;
    }

    /// @dev multiple a SignedDecimal.signedDecimal by a uint256
    function mulScalar(SignedDecimal.signedDecimal memory x, uint256 y)
        internal
        pure
        returns (SignedDecimal.signedDecimal memory)
    {
        require(_INT256_MAX >= y, ERROR_NON_CONVERTIBLE);
        SignedDecimal.signedDecimal memory t;
        t = x.mulScalar(int256(y));
        return t;
    }

    /// @dev divide a SignedDecimal.signedDecimal by a Decimal.decimal
    function divD(SignedDecimal.signedDecimal memory x, Decimal.decimal memory y)
        internal
        pure
        convertible(y)
        returns (SignedDecimal.signedDecimal memory)
    {
        SignedDecimal.signedDecimal memory t;
        t = x.divD(fromDecimal(y));
        return t;
    }

    /// @dev divide a SignedDecimal.signedDecimal by a uint256
    function divScalar(SignedDecimal.signedDecimal memory x, uint256 y)
        internal
        pure
        returns (SignedDecimal.signedDecimal memory)
    {
        require(_INT256_MAX >= y, ERROR_NON_CONVERTIBLE);
        SignedDecimal.signedDecimal memory t;
        t = x.divScalar(int256(y));
        return t;
    }
}

// File: contracts\CFDVault.sol


pragma solidity ^0.6.12;














contract CFDVault is OwnableUpgradeable {
    using Decimal for Decimal.decimal;
    using SignedDecimal for SignedDecimal.signedDecimal;
    using MixedDecimal for SignedDecimal.signedDecimal;
    using SafeERC20Upgradeable for IERC20Upgradeable;

    //
    // EVENTS
    //
    event LiquidityAdd(address indexed exchange, address indexed account, uint256 lpfund, uint256 tokenamount);
    event LiquidityRemove(address indexed exchange, address indexed account, uint256 lpfund, uint256 tokenamount);
    //changeType shows the liquidity changed by what
    event LiquidityModify(address indexed exchange, uint256 lpfund);
    event BadDebtResolved(address indexed exchange, uint256 badDebt, uint256 insuranceFundResolveBadDebt, uint256 mmResolveBadDebt);

    ISystemSettings public systemSettings;
    address public cfd;

    // key by exchange address
    // record lp liquidity for every exchange
    mapping(address => SignedDecimal.signedDecimal) internal exchangeLiquidityMap;
    // cached liquidity (from fundingFee/overnightFee/spread)
    mapping(address => Decimal.decimal) internal cachedLiquidityMap;

    //**********************************************************//
    //    Can not change the order of above state variables     //
    //**********************************************************//

    //◥◤◥◤◥◤◥◤◥◤◥◤◥◤◥◤ add state variables below ◥◤◥◤◥◤◥◤◥◤◥◤◥◤◥◤//

    //◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣ add state variables above ◢◣◢◣◢◣◢◣◢◣◢◣◢◣◢◣//
    uint256[50] private __gap;

    //
    // MODIFIERS
    //
    modifier onlyCFD() {
        require(_msgSender() == cfd, "only cfd");
        _;
    }

    //
    // PUBLIC
    //
    function initialize(address _cfd, address _systemSettings) public initializer {
        cfd = _cfd;
        systemSettings = ISystemSettings(_systemSettings);
        __Ownable_init();
    }

    /**
     * @notice set CFD dependency
     * @dev only owner can call
     * @param _cfd address
     */

    function setCFD(address _cfd) external onlyOwner {
        require(_cfd != address(0), "empty address");
        cfd = _cfd;
    }

    /**
     * @notice set systemSettings dependency
     * @dev only owner can call
     * @param _systemSettings address
     */

    function setSystemSettings(address _systemSettings) external onlyOwner {
        require(_systemSettings != address(0), "empty address");
        systemSettings = ISystemSettings(_systemSettings);
    }

    /**
     * @notice withdraw token to trader/liquidator
     * @dev only CFD can call
     * @param _exchange exchange address
     * @param _receiver receiver, could be trader or liquidator
     * @param _amount token amount
     */

    function withdraw(
        IExchange _exchange,
        address _receiver,
        Decimal.decimal memory _amount
    ) public onlyCFD {
        IERC20Upgradeable _token = _exchange.quoteAsset();
        Decimal.decimal memory totalTokenBalance = Decimal.decimal(_token.balanceOf(address(this)));
        if (totalTokenBalance.toUint() < _amount.toUint()) {
            Decimal.decimal memory balanceShortage = _amount.subD(totalTokenBalance);
            IInsuranceFund insuranceFund = systemSettings.getInsuranceFund(_exchange);
            Decimal.decimal memory totalInsurceFund = Decimal.decimal(_token.balanceOf(address(insuranceFund)));
            require(totalInsurceFund.toUint() >= balanceShortage.toUint(), "Fund not enough");
            insuranceFund.withdraw(balanceShortage);
        }

        _token.safeTransfer(_receiver, _amount.toUint());
    }

    /**
     * @notice realize bad debt. insurance fund will pay first, lp fund will pay the rest
     * @dev only CFD can call
     * @param _exchange IExchange address
     * @param _badDebt amount of the bad debt
     */

    function realizeBadDebt(IExchange _exchange, Decimal.decimal memory _badDebt) external onlyCFD {
        // in order to realize all the bad debt vault need extra tokens from insuranceFund
        IInsuranceFund insuranceFund = systemSettings.getInsuranceFund(_exchange);
        Decimal.decimal memory totalInsurceFund =
            Decimal.decimal(IERC20Upgradeable(_exchange.quoteAsset()).balanceOf(address(insuranceFund)));
        Decimal.decimal memory mmResolveBadDebt = _badDebt;
        Decimal.decimal memory insuranceFundResolveBadDebt = Decimal.zero();
        if (totalInsurceFund.toUint() > _badDebt.toUint()) {
            insuranceFund.withdraw(_badDebt);
            insuranceFundResolveBadDebt = _badDebt;
            mmResolveBadDebt = Decimal.zero();
        } else {
            insuranceFund.withdraw(totalInsurceFund);
            insuranceFundResolveBadDebt = totalInsurceFund;
            mmResolveBadDebt = _badDebt.subD(totalInsurceFund);
        }

        if (mmResolveBadDebt.toUint() > 0) {
            SignedDecimal.signedDecimal memory totalLpUnrealizedPNL =
                getTotalLpUnrealizedPNL(_exchange).subD(mmResolveBadDebt);
            require(exchangeLiquidityMap[address(_exchange)].addD(totalLpUnrealizedPNL).toInt() >= 0, "MM Bankrupt");
            exchangeLiquidityMap[address(_exchange)] = exchangeLiquidityMap[address(_exchange)].subD(mmResolveBadDebt);
        }

        emit BadDebtResolved(address(_exchange), _badDebt.toUint(), insuranceFundResolveBadDebt.toUint(), mmResolveBadDebt.toUint());
    }

    /**
     * @notice modifyLiquidity (trader fee, overnight fee, trader spread)
     */
    function modifyLiquidity() external {
        address _exchange = _msgSender();
        require(systemSettings.isExistedExchange(IExchange(_exchange)), "exchange not found");
        Decimal.decimal memory cachedLiquidity = cachedLiquidityMap[_exchange];
        exchangeLiquidityMap[_exchange] = exchangeLiquidityMap[_exchange].addD(cachedLiquidity);
        cachedLiquidityMap[_exchange] = Decimal.zero();
        emit LiquidityModify(_exchange, cachedLiquidity.toUint());
    }

    /**
     * @notice addCachedLiquidity (trader fee, overnight fee, trading spread)
     * @param _exchange exchange address
     * @param _DeltalpLiquidity liquidity amount to be added
     */
    function addCachedLiquidity(IExchange _exchange, Decimal.decimal memory _DeltalpLiquidity) public onlyCFD {
        cachedLiquidityMap[address(_exchange)] = cachedLiquidityMap[address(_exchange)].addD(_DeltalpLiquidity);
    }

    /**
     * @notice addLiquidity to Exchange
     * @param _exchange IExchange address
     * @param _quoteAssetAmount quote asset amount in 18 digits. Can Not be 0
     */
    function addLiquidity(IExchange _exchange, Decimal.decimal memory _quoteAssetAmount) external {
        requireExchange(_exchange, true);
        requireNonZeroInput(_quoteAssetAmount);

        SignedDecimal.signedDecimal memory totalLpUnrealizedPNL = getTotalLpUnrealizedPNL(_exchange);

        Decimal.decimal memory totalLpTokenAmount =
            Decimal.decimal(IERC20Upgradeable(address(_exchange)).totalSupply());
        if (totalLpTokenAmount.toUint() > 0) {
            //已有LP
            requireMMNotBankrupt(_exchange);
        }
        SignedDecimal.signedDecimal memory totalLpLiquidity = getMMLiquidity(address(_exchange));
        SignedDecimal.signedDecimal memory returnLpAmount = SignedDecimal.zero();
        if (totalLpLiquidity.toUint() == 0) {
            returnLpAmount = MixedDecimal.fromDecimal(_quoteAssetAmount);
        } else {
            returnLpAmount = MixedDecimal.fromDecimal(_quoteAssetAmount).mulD(totalLpTokenAmount).divD(
                totalLpLiquidity.addD(totalLpUnrealizedPNL)
            );
        }

        exchangeLiquidityMap[address(_exchange)] = totalLpLiquidity.addD(_quoteAssetAmount);
        IERC20Upgradeable(_exchange.quoteAsset()).safeTransferFrom(
            _msgSender(),
            address(this),
            _quoteAssetAmount.toUint()
        );
        _exchange.mint(_msgSender(), returnLpAmount.toUint());
        emit LiquidityAdd(address(_exchange), _msgSender(), _quoteAssetAmount.toUint(), returnLpAmount.toUint());
    }

    /**
     * @notice remove Liquidity from Exchange
     * @param _exchange IExchange address
     * @param _lpTokenAmount lp token asset amount in 18 digits. Can Not be 0
     */
    function removeLiquidity(IExchange _exchange, Decimal.decimal memory _lpTokenAmount) external {
        requireExchange(_exchange, true);
        requireNonZeroInput(_lpTokenAmount);
        SignedDecimal.signedDecimal memory totalLpUnrealizedPNL = getTotalLpUnrealizedPNL(_exchange);

        Decimal.decimal memory totalLpTokenAmount =
            Decimal.decimal(IERC20Upgradeable(address(_exchange)).totalSupply());
        SignedDecimal.signedDecimal memory totalLpLiquidity = getMMLiquidity(address(_exchange));
        SignedDecimal.signedDecimal memory returnQuoteAssetAmount =
            MixedDecimal
                .fromDecimal(_lpTokenAmount)
                .mulD(totalLpLiquidity.addD(totalLpUnrealizedPNL))
                .divD(totalLpTokenAmount)
                .mulD(Decimal.one().subD(systemSettings.lpWithdrawFeeRatio()));
        exchangeLiquidityMap[address(_exchange)] = totalLpLiquidity.subD(returnQuoteAssetAmount);
        IERC20Upgradeable(_exchange.quoteAsset()).safeTransfer(_msgSender(), returnQuoteAssetAmount.toUint());
        _exchange.burn(_msgSender(), _lpTokenAmount.toUint());
        emit LiquidityRemove(address(_exchange), _msgSender(), returnQuoteAssetAmount.toUint(), _lpTokenAmount.toUint());

        requireMMNotBankrupt(_exchange);
    }

    /**
     * @notice remove Liquidity from Exchange when shutdown
     * @param _exchange IExchange address
     */
    function removeLiquidityWhenShutdown(IExchange _exchange) external {
        requireExchange(_exchange, false);
        SignedDecimal.signedDecimal memory totalLpUnrealizedPNL = getTotalLpUnrealizedPNL(_exchange);
        SignedDecimal.signedDecimal memory totalLpLiquidity = getMMLiquidity(address(_exchange));
        SignedDecimal.signedDecimal memory remainAmount = totalLpUnrealizedPNL.addD(totalLpLiquidity);
        if (remainAmount.toInt() > 0) {
            Decimal.decimal memory _lpTokenAmount =
                Decimal.decimal(IERC20Upgradeable(address(_exchange)).balanceOf(_msgSender()));
            Decimal.decimal memory totalLpTokenAmount =
                Decimal.decimal(IERC20Upgradeable(address(_exchange)).totalSupply());
            SignedDecimal.signedDecimal memory returnQuoteAssetAmount =
                MixedDecimal.fromDecimal(_lpTokenAmount).mulD(remainAmount).divD(totalLpTokenAmount).mulD(
                    Decimal.one().subD(systemSettings.lpWithdrawFeeRatio())
                );
            _exchange.burn(_msgSender(), _lpTokenAmount.toUint());
            IERC20Upgradeable(_exchange.quoteAsset()).safeTransfer(_msgSender(), returnQuoteAssetAmount.toUint());
            exchangeLiquidityMap[address(_exchange)] = totalLpLiquidity.subD(returnQuoteAssetAmount);
            emit LiquidityRemove(address(_exchange), _msgSender(), returnQuoteAssetAmount.toUint(), _lpTokenAmount.toUint());
        }
    }

    //
    // VIEW FUNCTIONS
    //
    function getTotalLpUnrealizedPNL(IExchange _exchange) public view returns (SignedDecimal.signedDecimal memory) {
        (Decimal.decimal memory _quoteAssetReserve, Decimal.decimal memory _baseAssetReserve) = _exchange.getReserve();
        return _exchange.getMMUnrealizedPNL(_baseAssetReserve, _quoteAssetReserve);
    }

    function getTotalLpLiquidityAndUnrealizedPNL(IExchange _exchange)
        public
        view
        returns (
            SignedDecimal.signedDecimal memory totalLpLiquidity,
            SignedDecimal.signedDecimal memory totalLpUnrealizedPNL
        )
    {
        totalLpUnrealizedPNL = getTotalLpUnrealizedPNL(_exchange);
        totalLpLiquidity = getMMLiquidity(address(_exchange));
    }

    function getLpTokenPrice(IExchange _exchange) public view returns (int256 tokenPrice, int256 tokenPriceWithFee) {
        SignedDecimal.signedDecimal memory totalLpUnrealizedPNL = getTotalLpUnrealizedPNL(_exchange);

        Decimal.decimal memory totalLpTokenAmount = Decimal.decimal(IERC20Upgradeable(address(_exchange)).totalSupply());
        if(totalLpTokenAmount.toUint() == 0)
        {
            tokenPriceWithFee = int256(Decimal.one().toUint());
            tokenPrice = int256(Decimal.one().toUint());
        }
        else
        {
            SignedDecimal.signedDecimal memory totalLpLiquidity = getMMLiquidity(address(_exchange)).addD(getMMCachedLiquidity(address(_exchange)));
            tokenPriceWithFee = totalLpUnrealizedPNL.addD(totalLpLiquidity).divD(totalLpTokenAmount).toInt();
            tokenPrice = totalLpUnrealizedPNL.addD(getMMLiquidity(address(_exchange))).divD(totalLpTokenAmount).toInt();
        }
    } 


    function getMMLiquidity(address _exchange) public view returns (SignedDecimal.signedDecimal memory) {
        return exchangeLiquidityMap[_exchange];
    }

    function getMMCachedLiquidity(address _exchange) public view returns (Decimal.decimal memory) {
        return cachedLiquidityMap[_exchange];
    }
    //
    // REQUIRE FUNCTIONS
    //
    function requireMMNotBankrupt(IExchange _exchange) public view {
        (SignedDecimal.signedDecimal memory totalLpLiquidity, SignedDecimal.signedDecimal memory totalLpUnrealizedPNL) =
            getTotalLpLiquidityAndUnrealizedPNL(_exchange);
        require(totalLpUnrealizedPNL.addD(totalLpLiquidity).toInt() >= 0, "MM Bankrupt");
    }

    function requireNonZeroInput(Decimal.decimal memory _decimal) private pure {
        require(_decimal.toUint() != 0, "input is 0");
    }

    function requireExchange(IExchange _exchange, bool _open) private view {
        require(systemSettings.isExistedExchange(_exchange), "exchange not found");
        require(_open == _exchange.open(), _open ? "exchange was closed" : "exchange is open");
    }
}

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"exchange","type":"address"},{"indexed":false,"internalType":"uint256","name":"badDebt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"insuranceFundResolveBadDebt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mmResolveBadDebt","type":"uint256"}],"name":"BadDebtResolved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"exchange","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"lpfund","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenamount","type":"uint256"}],"name":"LiquidityAdd","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"exchange","type":"address"},{"indexed":false,"internalType":"uint256","name":"lpfund","type":"uint256"}],"name":"LiquidityModify","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"exchange","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"lpfund","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenamount","type":"uint256"}],"name":"LiquidityRemove","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"},{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"_DeltalpLiquidity","type":"tuple"}],"name":"addCachedLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"},{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"_quoteAssetAmount","type":"tuple"}],"name":"addLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cfd","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"getLpTokenPrice","outputs":[{"internalType":"int256","name":"tokenPrice","type":"int256"},{"internalType":"int256","name":"tokenPriceWithFee","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_exchange","type":"address"}],"name":"getMMCachedLiquidity","outputs":[{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_exchange","type":"address"}],"name":"getMMLiquidity","outputs":[{"components":[{"internalType":"int256","name":"d","type":"int256"}],"internalType":"struct SignedDecimal.signedDecimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"getTotalLpLiquidityAndUnrealizedPNL","outputs":[{"components":[{"internalType":"int256","name":"d","type":"int256"}],"internalType":"struct SignedDecimal.signedDecimal","name":"totalLpLiquidity","type":"tuple"},{"components":[{"internalType":"int256","name":"d","type":"int256"}],"internalType":"struct SignedDecimal.signedDecimal","name":"totalLpUnrealizedPNL","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"getTotalLpUnrealizedPNL","outputs":[{"components":[{"internalType":"int256","name":"d","type":"int256"}],"internalType":"struct SignedDecimal.signedDecimal","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_cfd","type":"address"},{"internalType":"address","name":"_systemSettings","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"modifyLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"},{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"_badDebt","type":"tuple"}],"name":"realizeBadDebt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"},{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"_lpTokenAmount","type":"tuple"}],"name":"removeLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"removeLiquidityWhenShutdown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"}],"name":"requireMMNotBankrupt","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_cfd","type":"address"}],"name":"setCFD","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_systemSettings","type":"address"}],"name":"setSystemSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"systemSettings","outputs":[{"internalType":"contract ISystemSettings","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IExchange","name":"_exchange","type":"address"},{"internalType":"address","name":"_receiver","type":"address"},{"components":[{"internalType":"uint256","name":"d","type":"uint256"}],"internalType":"struct Decimal.decimal","name":"_amount","type":"tuple"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

52283:14305:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55158:882;;;;;;:::i;:::-;;:::i;:::-;;54102:194;;;;;;:::i;:::-;;:::i;56280:1579::-;;;;;;:::i;:::-;;:::i;64079:406::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;53062:37;;;:::i;:::-;;;;;;;:::i;25284:148::-;;;:::i;60800:1306::-;;;;;;:::i;:::-;;:::i;59073:1532::-;;;;;;:::i;:::-;;:::i;24642:79::-;;;:::i;57960:487::-;;;:::i;65627:149::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;63746:325::-;;;;;;:::i;:::-;;:::i;65462:157::-;;;;;;:::i;:::-;;:::i;62236:1463::-;;;;;;:::i;:::-;;:::i;53106:18::-;;;:::i;54699:205::-;;;;;;:::i;:::-;;:::i;54420:133::-;;;;;;:::i;:::-;;:::i;58656:228::-;;;;;;:::i;:::-;;:::i;65824:345::-;;;;;;:::i;:::-;;:::i;25587:244::-;;;;;;:::i;:::-;;:::i;64493:958::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;55158:882::-;54027:3;;-1:-1:-1;;;;;54027:3:0;54011:12;:10;:12::i;:::-;-1:-1:-1;;;;;54011:19:0;;54003:40;;;;-1:-1:-1;;;54003:40:0;;;;;;;:::i;:::-;;;;;;;;;55308:24:::1;55335:9;-1:-1:-1::0;;;;;55335:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55308:49;;55368:40;;:::i;:::-;55411:48;::::0;;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;55427:31:0;;;55411:48;-1:-1:-1;;;;;55427:16:0;::::1;;:31;55452:4;55427:31:::0;;;::::1;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55411:48:::0;;55368:91;-1:-1:-1;55503:16:0::1;:7:::0;:14:::1;:16::i;:::-;55474:26;:17;:24;:26::i;:::-;:45;55470:502;;;55536:38;;:::i;:::-;55577:31;:7:::0;55590:17;55577:12:::1;:31::i;:::-;55654:14;::::0;:42:::1;::::0;-1:-1:-1;;;55654:42:0;;55536:72;;-1:-1:-1;55623:28:0::1;::::0;-1:-1:-1;;;;;55654:14:0;;::::1;::::0;:31:::1;::::0;:42:::1;::::0;55686:9;;55654:42:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55623:73;;55711:39;;:::i;:::-;55753:57;::::0;;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;55769:40:0;;;55753:57;-1:-1:-1;;;;;55769:16:0;::::1;;:40;55794:13:::0;55769:40;;;::::1;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55753:57:::0;;55711:99;-1:-1:-1;55862:24:0::1;:15:::0;:22:::1;:24::i;:::-;55833:25;:16;:23;:25::i;:::-;:53;;55825:81;;;;-1:-1:-1::0;;;55825:81:0::1;;;;;;;:::i;:::-;55921:39;::::0;-1:-1:-1;;;55921:39:0;;-1:-1:-1;;;;;55921:22:0;::::1;::::0;::::1;::::0;:39:::1;::::0;55944:15;;55921:39:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;55470:502;;;;55984:48;56004:9;56015:16;:7;:14;:16::i;:::-;-1:-1:-1::0;;;;;55984:19:0;::::1;::::0;:48;:19:::1;:48::i;:::-;54054:1;;55158:882:::0;;;:::o;54102:194::-;20979:13;;;;;;;;:33;;;20996:16;:14;:16::i;:::-;20979:50;;;-1:-1:-1;21017:12:0;;;;21016:13;20979:50;20971:109;;;;-1:-1:-1;;;20971:109:0;;;;;;;:::i;:::-;21093:19;21116:13;;;;;;21115:14;21140:101;;;;21175:13;:20;;-1:-1:-1;;;;21175:20:0;;;;;21210:19;21191:4;21210:19;;;21140:101;54191:3:::1;:10:::0;;-1:-1:-1;;;;;54191:10:0;;::::1;-1:-1:-1::0;;;;;;54191:10:0;;::::1;;::::0;;;54212:14:::1;:49:::0;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;54272:16:::1;:14;:16::i;:::-;21271:14:::0;21267:68;;;21318:5;21302:21;;-1:-1:-1;;21302:21:0;;;21267:68;54102:194;;;:::o;56280:1579::-;54027:3;;-1:-1:-1;;;;;54027:3:0;54011:12;:10;:12::i;:::-;-1:-1:-1;;;;;54011:19:0;;54003:40;;;;-1:-1:-1;;;54003:40:0;;;;;;;:::i;:::-;56509:14:::1;::::0;:42:::1;::::0;-1:-1:-1;;;56509:42:0;;56478:28:::1;::::0;-1:-1:-1;;;;;56509:14:0::1;::::0;:31:::1;::::0;:42:::1;::::0;56541:9;;56509:42:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56478:73;;56562:39;;:::i;:::-;56617:92;;;;;;;;56651:9;-1:-1:-1::0;;;;;56651:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;56633:51:0::1;;56693:13;56633:75;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56617:92:::0;;56562:147;-1:-1:-1;56720:39:0::1;;:::i;:::-;-1:-1:-1::0;56762:8:0;56781:50:::1;;:::i;:::-;56834:14;:12;:14::i;:::-;56781:67;;56891:17;:8;:15;:17::i;:::-;56863:25;:16;:23;:25::i;:::-;:45;56859:410;;;56925:32;::::0;-1:-1:-1;;;56925:32:0;;-1:-1:-1;;;;;56925:22:0;::::1;::::0;::::1;::::0;:32:::1;::::0;56948:8;;56925:32:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57002:8;56972:38;;57044:14;:12;:14::i;:::-;57025:33;;56859:410;;;57091:40;::::0;-1:-1:-1;;;57091:40:0;;-1:-1:-1;;;;;57091:22:0;::::1;::::0;::::1;::::0;:40:::1;::::0;57114:16;;57091:40:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;57176:16:0;;-1:-1:-1;57226:31:0::1;:8:::0;57176:16;57226:13:::1;:31::i;:::-;57207:50;;56859:410;57313:1;57285:25;:16;:23;:25::i;:::-;:29;57281:434;;;57331:55;;:::i;:::-;57406:57;57446:16;57406:34;57430:9;57406:23;:34::i;:::-;:39:::0;::::1;:57::i;:::-;-1:-1:-1::0;;;;;57486:40:0;::::1;57565:1;57486:40:::0;;;:20:::1;:40;::::0;;;;;;;:45;;;;::::1;::::0;;;;;;57331:132;;-1:-1:-1;57565:1:0;57486:75:::1;::::0;:67:::1;::::0;57331:132;57486:45:::1;:67::i;:::-;:73;:75::i;:::-;:80;;57478:104;;;;-1:-1:-1::0;;;57478:104:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;57640:40:0;::::1;;::::0;;;:20:::1;:40;::::0;;;;;;;;:45;;;;::::1;::::0;;;;;;;:63:::1;::::0;57686:16;57640:45:::1;:63::i;:::-;-1:-1:-1::0;;;;;57597:40:0;::::1;;::::0;;;:20:::1;:40;::::0;;;;:106;;;;-1:-1:-1;57281:434:0::1;57756:9;-1:-1:-1::0;;;;;57732:119:0::1;;57768:17;:8;:15;:17::i;:::-;57787:36;:27;:34;:36::i;:::-;57825:25;:16;:23;:25::i;:::-;57732:119;;;;;;;;:::i;:::-;;;;;;;;54054:1;;;;56280:1579:::0;;:::o;64079:406::-;64207:51;;:::i;:::-;64273:55;;:::i;:::-;64379:34;64403:9;64379:23;:34::i;:::-;64356:57;;64443:34;64466:9;64443:14;:34::i;:::-;64424:53;;64079:406;;;:::o;53062:37::-;;;-1:-1:-1;;;;;53062:37:0;;:::o;25284:148::-;24864:12;:10;:12::i;:::-;24854:6;;-1:-1:-1;;;;;24854:6:0;;;:22;;;24846:67;;;;-1:-1:-1;;;24846:67:0;;;;;;;:::i;:::-;25375:6:::1;::::0;25354:40:::1;::::0;25391:1:::1;::::0;-1:-1:-1;;;;;25375:6:0::1;::::0;25354:40:::1;::::0;25391:1;;25354:40:::1;25405:6;:19:::0;;-1:-1:-1;;;;;;25405:19:0::1;::::0;;25284:148::o;60800:1306::-;60905:32;60921:9;60932:4;60905:15;:32::i;:::-;60948:35;60968:14;60948:19;:35::i;:::-;60994:55;;:::i;:::-;61052:34;61076:9;61052:23;:34::i;:::-;60994:92;;61099:41;;:::i;:::-;61156:68;;;;;;;;61198:9;-1:-1:-1;;;;;61172:49:0;;:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61156:68;;61099:125;-1:-1:-1;61235:51:0;;:::i;:::-;61289:34;61312:9;61289:14;:34::i;:::-;61235:88;;61334:57;;:::i;:::-;61407:249;61600:55;61619:14;;;;;;;;;-1:-1:-1;;;;;61619:14:0;-1:-1:-1;;;;;61619:33:0;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61600:13;:11;:13::i;:::-;:18;;:55::i;:::-;61407:169;61557:18;61407:126;61489:43;:16;61511:20;61489:21;:43::i;:::-;61407:58;61450:14;61407:42;:58::i;:::-;:81;;:126::i;:::-;:149;;:169::i;:::-;:192;;:249::i;:::-;61334:322;-1:-1:-1;61710:45:0;:16;61334:322;61710:21;:45::i;:::-;-1:-1:-1;;;;;61667:40:0;;;;;;:20;:40;;;;;:88;;;;61766:101;61821:12;:10;:12::i;:::-;61835:31;:22;:29;:31::i;:::-;61784:9;-1:-1:-1;;;;;61784:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;61766:54:0;;:101;:54;:101::i;:::-;61878:9;-1:-1:-1;;;;;61878:14:0;;61893:12;:10;:12::i;:::-;61907:23;:14;:21;:23::i;:::-;61878:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61983:12;:10;:12::i;:::-;-1:-1:-1;;;;;61947:107:0;61971:9;-1:-1:-1;;;;;61947:107:0;;61997:31;:22;:29;:31::i;:::-;62030:23;:14;:21;:23::i;:::-;61947:107;;;;;;;:::i;:::-;;;;;;;;62067:31;62088:9;62067:20;:31::i;:::-;60800:1306;;;;;;:::o;59073:1532::-;59178:32;59194:9;59205:4;59178:15;:32::i;:::-;59221:38;59241:17;59221:19;:38::i;:::-;59272:55;;:::i;:::-;59330:34;59354:9;59330:23;:34::i;:::-;59272:92;;59377:41;;:::i;:::-;59434:68;;;;;;;;59476:9;-1:-1:-1;;;;;59450:49:0;;:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59434:68;;59377:125;-1:-1:-1;59547:1:0;59517:27;59377:125;59517:25;:27::i;:::-;:31;59513:119;;;59589:31;59610:9;59589:20;:31::i;:::-;59642:51;;:::i;:::-;59696:34;59719:9;59696:14;:34::i;:::-;59642:88;;59741:49;;:::i;:::-;59793:20;:18;:20::i;:::-;59741:72;;59828:25;:16;:23;:25::i;:::-;59824:323;;59892:43;59917:17;59892:24;:43::i;:::-;59875:60;;59824:323;;;59985:150;60077:43;:16;60099:20;60077:21;:43::i;:::-;59985:68;60034:18;59985:43;60010:17;59985:24;:43::i;:68::-;:73;;:150::i;:::-;59968:167;;59824:323;60202:40;:16;60224:17;60202:21;:40::i;:::-;-1:-1:-1;;;;;60159:40:0;;;;;;:20;:40;;;;;:83;;;;60253:165;60326:12;:10;:12::i;:::-;60361:4;60381:26;:17;:24;:26::i;:::-;60271:9;-1:-1:-1;;;;;60271:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;60253:58:0;;:165;;:58;:165::i;:::-;60429:9;-1:-1:-1;;;;;60429:14:0;;60444:12;:10;:12::i;:::-;60458:23;:14;:21;:23::i;:::-;60429:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60531:12;:10;:12::i;:::-;-1:-1:-1;;;;;60498:99:0;60519:9;-1:-1:-1;;;;;60498:99:0;;60545:26;:17;:24;:26::i;:::-;60573:23;:14;:21;:23::i;:::-;60498:99;;;;;;;:::i;:::-;;;;;;;;59073:1532;;;;;;:::o;24642:79::-;24707:6;;-1:-1:-1;;;;;24707:6:0;24642:79;:::o;57960:487::-;58007:17;58027:12;:10;:12::i;:::-;58058:14;;:54;;-1:-1:-1;;;58058:54:0;;58007:32;;-1:-1:-1;;;;;;58058:14:0;;:32;;:54;;58007:32;;58058:54;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58050:85;;;;-1:-1:-1;;;58050:85:0;;;;;;;:::i;:::-;58146:38;;:::i;:::-;-1:-1:-1;;;;;;58187:29:0;;;;;;:18;:29;;;;;;;;58146:70;;;;;;;;;;;58261:31;;;:20;:31;;;;;;:36;;;;;;;;;;;;:53;;58146:70;58261:36;:53::i;:::-;-1:-1:-1;;;;;58227:31:0;;;;;;:20;:31;;;;;:87;;;;58357:14;:12;:14::i;:::-;-1:-1:-1;;;;;58325:29:0;;;;;;:18;:29;;;;;:46;;;;;58387:52;58414:24;:15;:22;:24::i;:::-;58387:52;;;;;;:::i;:::-;;;;;;;;57960:487;;:::o;65627:149::-;65697:22;;:::i;:::-;-1:-1:-1;;;;;;65739:29:0;;;;;:18;:29;;;;;;;;;65732:36;;;;;;;;;;;;;65627:149::o;63746:325::-;63821:34;;:::i;:::-;63869:41;;:::i;:::-;63912:40;;:::i;:::-;63956:9;-1:-1:-1;;;;;63956:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63996:67;;-1:-1:-1;;;63996:67:0;;63868:110;;-1:-1:-1;63868:110:0;-1:-1:-1;;;;;;63996:28:0;;;;;:67;;63868:110;;;;63996:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63989:74;63746:325;-1:-1:-1;;;;63746:325:0:o;65462:157::-;65526:34;;:::i;:::-;-1:-1:-1;;;;;;65580:31:0;;;;;:20;:31;;;;;;;;;65573:38;;;;;;;;;;;;;65462:157::o;62236:1463::-;62314:33;62330:9;62341:5;62314:15;:33::i;:::-;62358:55;;:::i;:::-;62416:34;62440:9;62416:23;:34::i;:::-;62358:92;;62461:51;;:::i;:::-;62515:34;62538:9;62515:14;:34::i;:::-;62461:88;;62560:47;;:::i;:::-;62610:43;:20;62636:16;62610:25;:43::i;:::-;62560:93;;62691:1;62668:20;:12;:18;:20::i;:::-;:24;62664:1028;;;62709:37;;:::i;:::-;62766:78;;;;;;;;62808:9;-1:-1:-1;;;;;62782:47:0;;62830:12;:10;:12::i;:::-;62782:61;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62766:78;;62709:135;-1:-1:-1;62859:41:0;;:::i;:::-;62920:68;;;;;;;;62962:9;-1:-1:-1;;;;;62936:49:0;;:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62920:68;;62859:129;-1:-1:-1;63003:57:0;;:::i;:::-;63080:186;63192:55;63211:14;;;;;;;;;-1:-1:-1;;;;;63211:14:0;-1:-1:-1;;;;;63211:33:0;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63192:55;63080:84;63145:18;63080:59;63126:12;63080:40;63105:14;63080:24;:40::i;:186::-;63003:263;;63281:9;-1:-1:-1;;;;;63281:14:0;;63296:12;:10;:12::i;:::-;63310:23;:14;:21;:23::i;:::-;63281:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63349:101;63404:12;:10;:12::i;:::-;63418:31;:22;:29;:31::i;:::-;63367:9;-1:-1:-1;;;;;63367:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63349:101;63508:45;:16;63530:22;63508:21;:45::i;:::-;-1:-1:-1;;;;;63465:40:0;;;;;;:20;:40;;;;;:88;;;;63609:12;:10;:12::i;:::-;-1:-1:-1;;;;;63573:107:0;63597:9;-1:-1:-1;;;;;63573:107:0;;63623:31;:22;:29;:31::i;:::-;63656:23;:14;:21;:23::i;:::-;63573:107;;;;;;;:::i;:::-;;;;;;;;62664:1028;;;;62236:1463;;;;:::o;53106:18::-;;;-1:-1:-1;;;;;53106:18:0;;:::o;54699:205::-;24864:12;:10;:12::i;:::-;24854:6;;-1:-1:-1;;;;;24854:6:0;;;:22;;;24846:67;;;;-1:-1:-1;;;24846:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;54789:29:0;::::1;54781:55;;;;-1:-1:-1::0;;;54781:55:0::1;;;;;;;:::i;:::-;54847:14;:49:::0;;-1:-1:-1;;;;;;54847:49:0::1;-1:-1:-1::0;;;;;54847:49:0;;;::::1;::::0;;;::::1;::::0;;54699:205::o;54420:133::-;24864:12;:10;:12::i;:::-;24854:6;;-1:-1:-1;;;;;24854:6:0;;;:22;;;24846:67;;;;-1:-1:-1;;;24846:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;54488:18:0;::::1;54480:44;;;;-1:-1:-1::0;;;54480:44:0::1;;;;;;;:::i;:::-;54535:3;:10:::0;;-1:-1:-1;;;;;;54535:10:0::1;-1:-1:-1::0;;;;;54535:10:0;;;::::1;::::0;;;::::1;::::0;;54420:133::o;58656:228::-;54027:3;;-1:-1:-1;;;;;54027:3:0;54011:12;:10;:12::i;:::-;-1:-1:-1;;;;;54011:19:0;;54003:40;;;;-1:-1:-1;;;54003:40:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;58814:38:0;::::1;;::::0;;;:18:::1;:38;::::0;;;;;;;;:43;;;;::::1;::::0;;;;;;;:62:::1;::::0;58858:17;58814:43:::1;:62::i;:::-;-1:-1:-1::0;;;;;58773:38:0;;::::1;;::::0;;;:18:::1;:38;::::0;;;;:103;;;;;-1:-1:-1;58656:228:0:o;65824:345::-;65899:51;;:::i;:::-;65952:55;;:::i;:::-;66024:46;66060:9;66024:35;:46::i;:::-;65898:172;;-1:-1:-1;65898:172:0;-1:-1:-1;66144:1:0;66089:51;:43;65898:172;;66089:25;:43::i;:51::-;:56;;66081:80;;;;-1:-1:-1;;;66081:80:0;;;;;;;:::i;25587:244::-;24864:12;:10;:12::i;:::-;24854:6;;-1:-1:-1;;;;;24854:6:0;;;:22;;;24846:67;;;;-1:-1:-1;;;24846:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;25676:22:0;::::1;25668:73;;;;-1:-1:-1::0;;;25668:73:0::1;;;;;;;:::i;:::-;25778:6;::::0;25757:38:::1;::::0;-1:-1:-1;;;;;25757:38:0;;::::1;::::0;25778:6:::1;::::0;25757:38:::1;::::0;25778:6:::1;::::0;25757:38:::1;25806:6;:17:::0;;-1:-1:-1;;;;;;25806:17:0::1;-1:-1:-1::0;;;;;25806:17:0;;;::::1;::::0;;;::::1;::::0;;25587:244::o;64493:958::-;64560:17;64579:24;64616:55;;:::i;:::-;64674:34;64698:9;64674:23;:34::i;:::-;64616:92;;64721:41;;:::i;:::-;64765:68;;;;;;;;64807:9;-1:-1:-1;;;;;64781:49:0;;:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64765:68;;64721:112;-1:-1:-1;64847:27:0;64721:112;64847:25;:27::i;:::-;64844:600;;64932:22;:13;:11;:13::i;:22::-;64905:50;;64990:22;:13;:11;:13::i;:22::-;64970:43;;64844:600;;;65064:51;;:::i;:::-;65118:81;65158:40;65187:9;65158:20;:40::i;:::-;65118:34;65141:9;65118:14;:34::i;:::-;:39;;:81::i;:::-;65064:135;-1:-1:-1;65234:76:0;:68;65283:18;65234:43;:20;65064:135;65234:25;:43::i;:76::-;65214:96;;65338:94;:86;65405:18;65338:61;65364:34;65387:9;65364:14;:34::i;:::-;65338:20;;:25;:61::i;:94::-;65325:107;;64844:600;;64493:958;;;;;:::o;22915:106::-;23003:10;22915:106;:::o;35660:95::-;35744:3;;35660:95::o;36407:172::-;36480:14;;:::i;:::-;36507:16;;:::i;:::-;36548:3;;36540;;:12;;:7;:12::i;:::-;36534:18;;:1;-1:-1:-1;36407:172:0;;;;;:::o;16282:188::-;16376:86;16396:5;16426:23;;;16451:2;16455:5;16403:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;16403:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;16403:58:0;-1:-1:-1;;;;;;16403:58:0;;;;;;;;;;16376:19;:86::i;21435:604::-;21877:4;21988:17;22024:7;21435:604;:::o;24228:129::-;20979:13;;;;;;;;:33;;;20996:16;:14;:16::i;:::-;20979:50;;;-1:-1:-1;21017:12:0;;;;21016:13;20979:50;20971:109;;;;-1:-1:-1;;;20971:109:0;;;;;;;:::i;:::-;21093:19;21116:13;;;;;;21115:14;21140:101;;;;21175:13;:20;;-1:-1:-1;;;;21175:20:0;;;;;21210:19;21191:4;21210:19;;;21140:101;24286:26:::1;:24;:26::i;:::-;24323;:24;:26::i;:::-;21271:14:::0;21267:68;;;21318:5;21302:21;;-1:-1:-1;;21302:21:0;;;21267:68;24228:129;:::o;35444:91::-;35483:14;;:::i;:::-;-1:-1:-1;35517:10:0;;;;;;;;;-1:-1:-1;35517:10:0;;35444:91;:::o;50309:304::-;50461:34;;:::i;:::-;50440:1;49379;:3;;;-1:-1:-1;;;;;49364:18:0;;49384:21;;;;;;;;;;;;;;;;;49356:50;;;;;-1:-1:-1;;;49356:50:0;;;;;;;;:::i;:::-;;50513:36:::1;;:::i;:::-;50581:3:::0;;50566;;:20:::1;::::0;:7:::1;:20::i;:::-;50560:26:::0;;;50309:304;-1:-1:-1;;;;50309:304:0:o;38416:196::-;38501:20;;:::i;:::-;38534:22;;:::i;:::-;38581:3;;38573;;:12;;:7;:12::i;66324:261::-;66414:14;;:43;;-1:-1:-1;;;66414:43:0;;-1:-1:-1;;;;;66414:14:0;;;;:32;;:43;;66447:9;;66414:43;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66406:74;;;;-1:-1:-1;;;66406:74:0;;;;;;;:::i;:::-;66508:9;-1:-1:-1;;;;;66508:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66499:25;;:5;:25;;;66526:5;:50;;;;;;;;;;;;;;;-1:-1:-1;;;66526:50:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;66526:50:0;;;;66491:86;;;;;-1:-1:-1;;;66491:86:0;;;;;;;;:::i;66177:139::-;66271:17;:8;:15;:17::i;:::-;66263:45;;;;-1:-1:-1;;;66263:45:0;;;;;;;:::i;35543:109::-;35581:14;;:::i;:::-;35615:29;;;;;;;;35623:20;35640:2;35623:16;:20::i;:::-;35615:29;;35608:36;-1:-1:-1;35543:109:0;:::o;49434:228::-;49555:34;;:::i;:::-;49534:1;49379;:3;;;-1:-1:-1;;;;;49364:18:0;;49384:21;;;;;;;;;;;;;;;;;49356:50;;;;;-1:-1:-1;;;49356:50:0;;;;;;;;:::i;:::-;-1:-1:-1;;49614:40:0::1;::::0;;::::1;::::0;::::1;::::0;;;49649:3;;49614:40;;-1:-1:-1;49614:40:0;49434:228::o;38896:197::-;38981:20;;:::i;:::-;39014:22;;:::i;:::-;39062:3;;39053;;:13;;:8;:13::i;51480:304::-;51632:34;;:::i;:::-;51611:1;49379;:3;;;-1:-1:-1;;;;;49364:18:0;;49384:21;;;;;;;;;;;;;;;;;49356:50;;;;;-1:-1:-1;;;49356:50:0;;;;;;;;:::i;:::-;;51684:36:::1;;:::i;:::-;51735:22;51742:14;51754:1;51742:11;:14::i;:::-;51735:1:::0;;:6:::1;:22::i;:::-;51731:26:::0;51480:304;-1:-1:-1;;;;;51480:304:0:o;50693:::-;50845:34;;:::i;:::-;50824:1;49379;:3;;;-1:-1:-1;;;;;49364:18:0;;49384:21;;;;;;;;;;;;;;;;;49356:50;;;;;-1:-1:-1;;;49356:50:0;;;;;;;;:::i;:::-;;50897:36:::1;;:::i;:::-;50948:22;50955:14;50967:1;50955:11;:14::i;:::-;50948:1:::0;;:6:::1;:22::i;38656:196::-:0;38741:20;;:::i;:::-;38774:22;;:::i;:::-;38821:3;;38813;;:12;;:7;:12::i;49670:121::-;49747:7;49774;:1;:5;:7::i;:::-;:9;;49670:121;-1:-1:-1;;49670:121:0:o;39379:197::-;39464:20;;:::i;:::-;39497:22;;:::i;:::-;39545:3;;39536;;:13;;:8;:13::i;49896:304::-;50048:34;;:::i;:::-;50027:1;49379;:3;;;-1:-1:-1;;;;;49364:18:0;;49384:21;;;;;;;;;;;;;;;;;49356:50;;;;;-1:-1:-1;;;49356:50:0;;;;;;;;:::i;:::-;;50100:36:::1;;:::i;:::-;50168:3:::0;;50153;;:20:::1;::::0;:7:::1;:20::i;16478:216::-:0;16590:96;16610:5;16640:27;;;16669:4;16675:2;16679:5;16617:68;;;;;;;;;;:::i;36191:172::-;36264:14;;:::i;:::-;36291:16;;:::i;:::-;36332:3;;36324;;:12;;:7;:12::i;1462:136::-;1520:7;1547:43;1551:1;1554;1547:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1540:50;1462:136;-1:-1:-1;;;1462:136:0:o;18642:772::-;19077:23;19103:69;19131:4;19103:69;;;;;;;;;;;;;;;;;19111:5;-1:-1:-1;;;;;19103:27:0;;;:69;;;;;:::i;:::-;19187:17;;19077:95;;-1:-1:-1;19187:21:0;19183:224;;19329:10;19318:30;;;;;;;;;;;;:::i;:::-;19310:85;;;;-1:-1:-1;;;19310:85:0;;;;;;;:::i;22844:65::-;20979:13;;;;;;;;:33;;;20996:16;:14;:16::i;:::-;20979:50;;;-1:-1:-1;21017:12:0;;;;21016:13;20979:50;20971:109;;;;-1:-1:-1;;;20971:109:0;;;;;;;:::i;:::-;21093:19;21116:13;;;;;;21115:14;21140:101;;;;21175:13;:20;;-1:-1:-1;;;;21175:20:0;;;;;21210:19;21191:4;21210:19;;;21271:14;21267:68;;;21318:5;21302:21;;-1:-1:-1;;21302:21:0;;;22844:65;:::o;24365:196::-;20979:13;;;;;;;;:33;;;20996:16;:14;:16::i;:::-;20979:50;;;-1:-1:-1;21017:12:0;;;;21016:13;20979:50;20971:109;;;;-1:-1:-1;;;20971:109:0;;;;;;;:::i;:::-;21093:19;21116:13;;;;;;21115:14;21140:101;;;;21175:13;:20;;-1:-1:-1;;;;21175:20:0;;;;;21210:19;21191:4;21210:19;;;21140:101;24433:17:::1;24453:12;:10;:12::i;:::-;24476:6;:18:::0;;-1:-1:-1;;;;;;24476:18:0::1;-1:-1:-1::0;;;;;24476:18:0;::::1;::::0;;::::1;::::0;;;24510:43:::1;::::0;24476:18;;-1:-1:-1;24476:18:0;-1:-1:-1;;24510:43:0::1;::::0;-1:-1:-1;;24510:43:0::1;21253:1;21271:14:::0;21267:68;;;21318:5;21302:21;;-1:-1:-1;;21302:21:0;;;24365:196;:::o;30952:218::-;31008:6;31038:5;;;31063:6;;;;;;:16;;;31078:1;31073;:6;;31063:16;31062:38;;;;31089:1;31085;:5;:14;;;;;31098:1;31094;:5;31085:14;31054:87;;;;-1:-1:-1;;;31054:87:0;;;;;;;:::i;31415:215::-;31471:6;31501:5;;;31526:6;;;;;;:16;;;31541:1;31536;:6;;31526:16;31525:38;;;;31552:1;31548;:5;:14;;;;;31561:1;31557;:5;31548:14;31517:84;;;;-1:-1:-1;;;31517:84:0;;;;;;;:::i;33762:109::-;33846:17;;33842:2;:21;;33762:109::o;32563:105::-;32620:6;32646:14;32651:1;32654;32657:2;32646:4;:14::i;38108:269::-;38168:22;;:::i;:::-;38203:24;;:::i;:::-;38242:3;;38248:1;-1:-1:-1;38238:113:0;;;38284:3;;;38280:7;38266:22;;38238:113;;;38335:3;;38321:18;;-1:-1:-1;38321:18:0;38108:269::o;33032:105::-;33089:6;33115:14;33120:1;33123;33126:2;33115:4;:14::i;998:181::-;1056:7;1088:5;;;1112:6;;;;1104:46;;;;-1:-1:-1;;;1104:46:0;;;;;;;:::i;1901:192::-;1987:7;2023:12;2015:6;;;;2007:29;;;;-1:-1:-1;;;2007:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;2059:5:0;;;1901:192::o;12225:195::-;12328:12;12360:52;12382:6;12390:4;12396:1;12399:12;12360:21;:52::i;32769:169::-;32876:6;32902:28;32915:14;32920:8;32915:4;:14::i;:::-;32902:8;:1;32908;32902:5;:8::i;:::-;:12;;:28::i;33239:169::-;33346:6;33372:28;33398:1;33372:21;33378:14;33383:8;33378:4;:14::i;:::-;33372:1;;:5;:21::i;13277:530::-;13404:12;13462:5;13437:21;:30;;13429:81;;;;-1:-1:-1;;;13429:81:0;;;;;;;:::i;:::-;13529:18;13540:6;13529:10;:18::i;:::-;13521:60;;;;-1:-1:-1;;;13521:60:0;;;;;;;:::i;:::-;13655:12;13669:23;13696:6;-1:-1:-1;;;;;13696:11:0;13716:5;13724:4;13696:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13654:75;;;;13747:52;13765:7;13774:10;13786:12;13747:17;:52::i;:::-;13740:59;13277:530;-1:-1:-1;;;;;;;13277:530:0:o;29388:568::-;29444:6;29688;29684:47;;-1:-1:-1;29718:1:0;29711:8;;29684:47;29753:1;-1:-1:-1;;29753:7:0;:27;;;;;-1:-1:-1;;;29764:1:0;:16;29753:27;29751:30;29743:82;;;;-1:-1:-1;;;29743:82:0;;;;;;;:::i;:::-;29849:5;;;29853:1;29849;:5;:1;29873:5;;;;;:10;29865:62;;;;-1:-1:-1;;;29865:62:0;;;;;;;:::i;30430:271::-;30486:6;30513;30505:51;;;;-1:-1:-1;;;30505:51:0;;;;;;;:::i;:::-;30577:1;-1:-1:-1;;30577:7:0;:27;;;;;-1:-1:-1;;;30588:1:0;:16;30577:27;30575:30;30567:76;;;;-1:-1:-1;;;30567:76:0;;;;;;;:::i;:::-;30656:8;30671:1;30667;:5;;;;;;;30430:271;-1:-1:-1;;;;30430:271:0:o;9307:422::-;9674:20;9713:8;;;9307:422::o;14813:742::-;14928:12;14957:7;14953:595;;;-1:-1:-1;14988:10:0;14981:17;;14953:595;15102:17;;:21;15098:439;;15365:10;15359:17;15426:15;15413:10;15409:2;15405:19;15398:44;15313:148;15508:12;15501:20;;-1:-1:-1;;;15501:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;:::o;996:320::-;;1110:4;1098:9;1093:3;1089:19;1085:30;1082:2;;;-1:-1;;1118:12;1082:2;1146:20;1110:4;1146:20;:::i;:::-;2163;;1220:75;;-1:-1;1137:29;1076:240;-1:-1;1076:240::o;1352:342::-;;1477:4;1465:9;1460:3;1456:19;1452:30;1449:2;;;-1:-1;;1485:12;1449:2;1513:20;1477:4;1513:20;:::i;:::-;2311:13;;1587:86;;-1:-1;1504:29;1443:251;-1:-1;1443:251::o;2374:241::-;;2478:2;2466:9;2457:7;2453:23;2449:32;2446:2;;;-1:-1;;2484:12;2446:2;85:6;72:20;97:33;124:5;97:33;:::i;2622:366::-;;;2743:2;2731:9;2722:7;2718:23;2714:32;2711:2;;;-1:-1;;2749:12;2711:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2801:63;-1:-1;2901:2;2940:22;;72:20;97:33;72:20;97:33;:::i;:::-;2909:63;;;;2705:283;;;;;:::o;2995:257::-;;3107:2;3095:9;3086:7;3082:23;3078:32;3075:2;;;-1:-1;;3113:12;3075:2;223:6;217:13;32385:5;30136:13;30129:21;32363:5;32360:32;32350:2;;-1:-1;;32396:12;3259:313;;3399:2;3387:9;3378:7;3374:23;3370:32;3367:2;;;-1:-1;;3405:12;3367:2;386:6;380:13;398:58;450:5;398:58;:::i;3863:577::-;;;;4044:2;4032:9;4023:7;4019:23;4015:32;4012:2;;;-1:-1;;4050:12;4012:2;566:6;553:20;578:51;623:5;578:51;:::i;:::-;4102:81;-1:-1;4220:2;4259:22;;72:20;97:33;72:20;97:33;:::i;:::-;4228:63;-1:-1;4346:78;4416:7;4328:2;4392:22;;4346:78;:::i;:::-;4336:88;;4006:434;;;;;:::o;4447:452::-;;;4611:2;4599:9;4590:7;4586:23;4582:32;4579:2;;;-1:-1;;4617:12;4579:2;566:6;553:20;578:51;623:5;578:51;:::i;:::-;4669:81;-1:-1;4805:78;4875:7;4787:2;4851:22;;4805:78;:::i;:::-;4795:88;;4573:326;;;;;:::o;5222:313::-;;5362:2;5350:9;5341:7;5337:23;5333:32;5330:2;;;-1:-1;;5368:12;5330:2;5430:89;5511:7;5487:22;5430:89;:::i;5542:499::-;;;5724:2;5712:9;5703:7;5699:23;5695:32;5692:2;;;-1:-1;;5730:12;5692:2;5792:89;5873:7;5849:22;5792:89;:::i;:::-;5782:99;;5936:89;6017:7;5918:2;5997:9;5993:22;5936:89;:::i;6380:263::-;;6495:2;6483:9;6474:7;6470:23;6466:32;6463:2;;;-1:-1;;6501:12;6463:2;-1:-1;2311:13;;6457:186;-1:-1;6457:186::o;15593:271::-;;7079:5;29477:12;7190:52;7235:6;7230:3;7223:4;7216:5;7212:16;7190:52;:::i;:::-;7254:16;;;;;15727:137;-1:-1;;15727:137::o;15871:222::-;-1:-1;;;;;30662:54;;;;6870:37;;15998:2;15983:18;;15969:124::o;16345:349::-;-1:-1;;;;;30662:54;;;;6729:58;;16680:2;16665:18;;7691:36;16508:2;16493:18;;16479:215::o;16701:444::-;-1:-1;;;;;30662:54;;;6870:37;;30662:54;;;;17048:2;17033:18;;6870:37;17131:2;17116:18;;7691:36;;;;16884:2;16869:18;;16855:290::o;18034:325::-;7691:36;;;18345:2;18330:18;;7691:36;18185:2;18170:18;;18156:203::o;18366:310::-;;18513:2;18534:17;18527:47;8001:5;29477:12;29916:6;18513:2;18502:9;18498:18;29904:19;8095:52;8140:6;29944:14;18502:9;29944:14;18513:2;8121:5;8117:16;8095:52;:::i;:::-;32159:7;32143:14;-1:-1;;32139:28;8159:39;;;;29944:14;8159:39;;18484:192;-1:-1;;18484:192::o;18683:416::-;18883:2;18897:47;;;8435:2;18868:18;;;29904:19;-1:-1;;;29944:14;;;8451:41;8511:12;;;18854:245::o;19106:416::-;19306:2;19320:47;;;8762:1;19291:18;;;29904:19;-1:-1;;;29944:14;;;8777:31;8827:12;;;19277:245::o;19529:416::-;19729:2;19743:47;;;9078:2;19714:18;;;29904:19;9114:34;29944:14;;;9094:55;-1:-1;;;9169:12;;;9162:30;9211:12;;;19700:245::o;19952:416::-;20152:2;20166:47;;;9462:2;20137:18;;;29904:19;9498:29;29944:14;;;9478:50;9547:12;;;20123:245::o;20375:416::-;20575:2;20589:47;;;9798:2;20560:18;;;29904:19;9834:34;29944:14;;;9814:55;-1:-1;;;9889:12;;;9882:25;9926:12;;;20546:245::o;20798:416::-;20998:2;21012:47;;;10177:2;20983:18;;;29904:19;-1:-1;;;29944:14;;;10193:36;10248:12;;;20969:245::o;21221:416::-;21421:2;21435:47;;;10499:2;21406:18;;;29904:19;10535:34;29944:14;;;10515:55;-1:-1;;;10590:12;;;10583:30;10632:12;;;21392:245::o;21644:416::-;21844:2;21858:47;;;10883:2;21829:18;;;29904:19;-1:-1;;;29944:14;;;10899:34;10952:12;;;21815:245::o;22067:416::-;22267:2;22281:47;;;11203:2;22252:18;;;29904:19;11239:34;29944:14;;;11219:55;-1:-1;;;11294:12;;;11287:38;11344:12;;;22238:245::o;22490:416::-;22690:2;22704:47;;;11595:2;22675:18;;;29904:19;11631:34;29944:14;;;11611:55;-1:-1;;;11686:12;;;11679:25;11723:12;;;22661:245::o;22913:416::-;23113:2;23127:47;;;11974:2;23098:18;;;29904:19;-1:-1;;;29944:14;;;11990:33;12042:12;;;23084:245::o;23336:416::-;23536:2;23550:47;;;23521:18;;;29904:19;12329:34;29944:14;;;12309:55;12383:12;;;23507:245::o;23759:416::-;23959:2;23973:47;;;12634:2;23944:18;;;29904:19;12670:34;29944:14;;;12650:55;-1:-1;;;12725:12;;;12718:31;12768:12;;;23930:245::o;24182:416::-;24382:2;24396:47;;;13019:2;24367:18;;;29904:19;13055:31;29944:14;;;13035:52;13106:12;;;24353:245::o;24605:416::-;24805:2;24819:47;;;13357:2;24790:18;;;29904:19;13393:34;29944:14;;;13373:55;-1:-1;;;13448:12;;;13441:28;13488:12;;;24776:245::o;25028:416::-;25228:2;25242:47;;;13739:2;25213:18;;;29904:19;13775:34;29944:14;;;13755:55;-1:-1;;;13830:12;;;13823:34;13876:12;;;25199:245::o;25451:416::-;25651:2;25665:47;;;14127:2;25636:18;;;29904:19;-1:-1;;;29944:14;;;14143:38;14200:12;;;25622:245::o;25874:416::-;26074:2;26088:47;;;26059:18;;;29904:19;14487:34;29944:14;;;14467:55;14541:12;;;26045:245::o;26297:322::-;14828:23;;7691:36;;26474:2;26459:18;;26445:174::o;26626:533::-;14828:23;;7691:36;;14828:23;27145:2;27130:18;;7691:36;26881:2;26866:18;;26852:307::o;28107:222::-;7691:36;;;28234:2;28219:18;;28205:124::o;28676:444::-;7691:36;;;29023:2;29008:18;;7691:36;;;;29106:2;29091:18;;7691:36;28859:2;28844:18;;28830:290::o;29127:256::-;29189:2;29183:9;29215:17;;;29290:18;29275:34;;29311:22;;;29272:62;29269:2;;;29347:1;;29337:12;29269:2;29189;29356:22;29167:216;;-1:-1;29167:216::o;31799:268::-;31864:1;31871:101;31885:6;31882:1;31879:13;31871:101;;;31952:11;;;31946:18;31933:11;;;31926:39;31907:2;31900:10;31871:101;;;31987:6;31984:1;31981:13;31978:2;;;-1:-1;;31864:1;32034:16;;32027:27;31848:219::o;32180:117::-;-1:-1;;;;;30662:54;;32239:35;;32229:2;;32288:1;;32278:12

Swarm Source

ipfs://72c561004f49416bb3a894120bf84757d22f1515475124aaf604dd8d723a8383
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading