Contract 0x708C17D0901B76cc5CF8F67e1a2E198077FD8641

 
Txn Hash
Block
From
To
Value [Txn Fee]
0x717ffe0b2c66485dcc7a4a8519b5079c385c22c0b2bdd1e7b6e8a317203e9d882199102021-08-17 13:24:5631 days 6 hrs ago0x904b5993fc92979eeedc19ccc58bed6b7216667c IN  Contract Creation0 ETH0.034411327938 ETH
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Reader

Compiler Version
v0.7.4+commit.3f05b770

Optimization Enabled:
Yes with 1000 runs

Other Settings:
default evmVersion, GNU GPLv2 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at arbiscan.io on 2021-08-31
*/

pragma solidity 0.7.4;
pragma experimental ABIEncoderV2;


library Address {
    
    function isContract(address account) internal view returns (bool) {
        
        
        

        uint256 size;
        
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

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

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

        
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        
        (bool success, bytes memory returndata) = target.delegatecall(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 {
            
            if (returndata.length > 0) {
                

                
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library EnumerableSetUpgradeable {
    
    
    
    
    
    
    
    

    struct Set {
        
        bytes32[] _values;

        
        
        mapping (bytes32 => uint256) _indexes;
    }

    
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            
            
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { 
            
            
            

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            
            

            bytes32 lastvalue = set._values[lastIndex];

            
            set._values[toDeleteIndex] = lastvalue;
            
            set._indexes[lastvalue] = toDeleteIndex + 1; 

            
            set._values.pop();

            
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    

    struct Bytes32Set {
        Set _inner;
    }

    
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    

    struct AddressSet {
        Set _inner;
    }

    
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    

    struct UintSet {
        Set _inner;
    }

    
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

enum PerpetualState {
    INVALID,
    INITIALIZING,
    NORMAL,
    EMERGENCY,
    CLEARED
}

enum OrderType {
    LIMIT,
    MARKET,
    STOP
}

struct Option {
    int256 value;
    int256 minValue;
    int256 maxValue;
}

struct OraclePriceData {
    int256 price;
    uint256 time;
}

struct MarginAccount {
    int256 cash;
    int256 position;
    int256 targetLeverage;
}

struct Order {
    address trader;
    address broker;
    address relayer;
    address referrer;
    address liquidityPool;
    int256 minTradeAmount;
    int256 amount;
    int256 limitPrice;
    int256 triggerPrice;
    uint256 chainID;
    uint64 expiredAt;
    uint32 perpetualIndex;
    uint32 brokerFeeLimit;
    uint32 flags;
    uint32 salt;
}

struct LiquidityPoolStorage {
    bool isRunning;
    bool isFastCreationEnabled;
    
    address creator;
    address operator;
    address transferringOperator;
    address governor;
    address shareToken;
    address accessController;
    bool reserved3; 
    uint256 scaler;
    uint256 collateralDecimals;
    address collateralToken;
    
    int256 poolCash;
    uint256 fundingTime;
    uint256 reserved5;
    uint256 operatorExpiration;
    mapping(address => int256) reserved1;
    bytes32[] reserved2;
    
    uint256 perpetualCount;
    mapping(uint256 => PerpetualStorage) perpetuals;
    
    int256 insuranceFundCap;
    int256 insuranceFund;
    int256 donatedInsuranceFund;
    address reserved4;
    
    bytes32[16] reserved;
}

struct PerpetualStorage {
    uint256 id;
    PerpetualState state;
    address oracle;
    int256 totalCollateral;
    int256 openInterest;
    
    OraclePriceData indexPriceData;
    OraclePriceData markPriceData;
    OraclePriceData settlementPriceData;
    
    int256 fundingRate;
    int256 unitAccumulativeFunding;
    
    int256 initialMarginRate;
    int256 maintenanceMarginRate;
    int256 operatorFeeRate;
    int256 lpFeeRate;
    int256 referralRebateRate;
    int256 liquidationPenaltyRate;
    int256 keeperGasReward;
    int256 insuranceFundRate;
    int256 reserved1;
    int256 maxOpenInterestRate;
    
    Option halfSpread;
    Option openSlippageFactor;
    Option closeSlippageFactor;
    Option fundingRateLimit;
    Option fundingRateFactor;
    Option ammMaxLeverage;
    Option maxClosePriceDiscount;
    
    uint256 totalAccount;
    int256 totalMarginWithoutPosition;
    int256 totalMarginWithPosition;
    int256 redemptionRateWithoutPosition;
    int256 redemptionRateWithPosition;
    EnumerableSetUpgradeable.AddressSet activeAccounts;
    
    int256 reserved2;
    int256 reserved3;
    
    mapping(address => MarginAccount) marginAccounts;
    Option defaultTargetLeverage;
    
    address reserved4;
    EnumerableSetUpgradeable.AddressSet ammKeepers;
    EnumerableSetUpgradeable.AddressSet reserved5;
    
    bytes32[12] reserved;
}

interface IPerpetual {
    
    function deposit(
        uint256 perpetualIndex,
        address trader,
        int256 amount
    ) external;

    
    function withdraw(
        uint256 perpetualIndex,
        address trader,
        int256 amount
    ) external;

    
    function settle(uint256 perpetualIndex, address trader) external;

    
    function clear(uint256 perpetualIndex) external;

    
    function trade(
        uint256 perpetualIndex,
        address trader,
        int256 amount,
        int256 limitPrice,
        uint256 deadline,
        address referrer,
        uint32 flags
    ) external returns (int256);

    
    function brokerTrade(bytes memory orderData, int256 amount) external returns (int256);

    
    function liquidateByAMM(uint256 perpetualIndex, address trader)
        external
        returns (int256 liquidationAmount);

    
    function liquidateByTrader(
        uint256 perpetualIndex,
        address liquidator,
        address trader,
        int256 amount,
        int256 limitPrice,
        uint256 deadline
    ) external returns (int256 liquidationAmount);
}

interface ILiquidityPool {
    
    function initialize(
        address operator,
        address collateral,
        uint256 collateralDecimals,
        address governor,
        bytes calldata initData
    ) external;

    
    function runLiquidityPool() external;

    
    function forceToSyncState() external;

    
    function addLiquidity(int256 cashToAdd) external;

    
    function removeLiquidity(int256 shareToRemove, int256 cashToReturn) external;
}

interface ILiquidityPoolGetter {
    
    function getLiquidityPoolInfo()
        external
        view
        returns (
            bool isRunning,
            bool isFastCreationEnabled,
            
            
            
            
            
            
            
            address[7] memory addresses,
            
            
            
            
            
            int256[5] memory intNums,
            
            
            
            
            uint256[4] memory uintNums
        );

    
    function getPerpetualInfo(uint256 perpetualIndex)
        external
        view
        returns (
            PerpetualState state,
            address oracle,
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            int256[39] memory nums
        );

    
    function getMarginAccount(uint256 perpetualIndex, address trader)
        external
        view
        returns (
            int256 cash,
            int256 position,
            int256 availableMargin,
            int256 margin,
            int256 settleableMargin,
            bool isInitialMarginSafe,
            bool isMaintenanceMarginSafe,
            bool isMarginSafe, 
            int256 targetLeverage
        );

    
    function getActiveAccountCount(uint256 perpetualIndex) external view returns (uint256);

    
    function listActiveAccounts(
        uint256 perpetualIndex,
        uint256 begin,
        uint256 end
    ) external view returns (address[] memory result);

    
    function getClearProgress(uint256 perpetualIndex)
        external
        view
        returns (uint256 left, uint256 total);

    
    function getPoolMargin() external view returns (int256 poolMargin, bool isSafe);

    
    function queryTrade(
        uint256 perpetualIndex,
        address trader,
        int256 amount,
        address referrer,
        uint32 flags
    )
        external
        returns (
            int256 tradePrice,
            int256 totalFee,
            int256 cost
        );

    
    function queryAddLiquidity(int256 cashToAdd, int256 shareToMint)
        external
        view
        returns (int256 cashToAddResult, int256 shareToMintResult);

    
    function queryRemoveLiquidity(int256 shareToRemove, int256 cashToReturn)
        external
        view
        returns (int256 shareToRemoveResult, int256 cashToReturnResult);
}

interface ILiquidityPoolGovernance {
    function setEmergencyState(uint256 perpetualIndex) external;
}

interface ILiquidityPoolFull is
    IPerpetual,
    ILiquidityPool,
    ILiquidityPoolGetter,
    ILiquidityPoolGovernance
{}

interface IAccessControl {
    function grantPrivilege(address trader, uint256 privilege) external;

    function revokePrivilege(address trader, uint256 privilege) external;

    function isGranted(
        address owner,
        address trader,
        uint256 privilege
    ) external view returns (bool);
}

interface IProxyAdmin {
    function getProxyImplementation(address proxy) external view returns (address);

    
    function upgrade(address proxy, address implementation) external;

    
    function upgradeAndCall(
        address proxy,
        address implementation,
        bytes memory data
    ) external payable;
}

interface IPoolCreator {
    function upgradeAdmin() external view returns (IProxyAdmin proxyAdmin);

    
    function createLiquidityPool(
        address collateral,
        uint256 collateralDecimals,
        int256 nonce,
        bytes calldata initData
    ) external returns (address liquidityPool, address governor);

    
    function upgradeToAndCall(
        bytes32 targetVersionKey,
        bytes memory dataForLiquidityPool,
        bytes memory dataForGovernor
    ) external;

    
    function isUniverseSettled() external view returns (bool);
}

interface ITracer {
    
    function activatePerpetualFor(address trader, uint256 perpetualIndex) external returns (bool);

    
    function deactivatePerpetualFor(address trader, uint256 perpetualIndex) external returns (bool);

    
    function registerOperatorOfLiquidityPool(address liquidityPool, address operator) external;
}

interface IVersionControl {
    function owner() external view returns (address);

    function getLatestVersion() external view returns (bytes32 latestVersionKey);

    
    function getVersion(bytes32 versionKey)
        external
        view
        returns (
            address liquidityPoolTemplate,
            address governorTemplate,
            uint256 compatibility
        );

    
    function getAppliedVersionKey(address liquidityPool, address governor)
        external
        view
        returns (bytes32 appliedVersionKey);

    
    function isVersionKeyValid(bytes32 versionKey) external view returns (bool isValid);

    
    function isVersionCompatible(bytes32 targetVersionKey, bytes32 baseVersionKey)
        external
        view
        returns (bool isCompatible);

    
    function listAvailableVersions(uint256 begin, uint256 end)
        external
        view
        returns (bytes32[] memory versionKeys);
}

interface IVariables {
    function owner() external view returns (address);

    
    function getVault() external view returns (address);

    
    function getVaultFeeRate() external view returns (int256);

    
    function getAccessController() external view returns (address);

    
    function getSymbolService() external view returns (address);

    
    function setVault(address newVault) external;

    
    function getMCBToken() external pure returns (address);

    
    function setVaultFeeRate(int256 newVaultFeeRate) external;
}

interface IKeeperWhitelist {
    
    function addKeeper(address keeper) external;

    
    function removeKeeper(address keeper) external;

    
    function isKeeper(address keeper) external view returns (bool);
}

interface IPoolCreatorFull is
    IPoolCreator,
    IVersionControl,
    ITracer,
    IVariables,
    IAccessControl,
    IKeeperWhitelist
{
    
    function owner() external view override(IVersionControl, IVariables) returns (address);
}

interface IOracle {
    
    function isMarketClosed() external returns (bool);

    
    function isTerminated() external returns (bool);

    
    function collateral() external view returns (string memory);

    
    function underlyingAsset() external view returns (string memory);

    
    function priceTWAPLong() external returns (int256 newPrice, uint256 newTimestamp);

    
    function priceTWAPShort() external returns (int256 newPrice, uint256 newTimestamp);
}

interface ISymbolService {
    function isWhitelistedFactory(address factory) external view returns (bool);

    function addWhitelistedFactory(address factory) external;

    function removeWhitelistedFactory(address factory) external;

    function getPerpetualUID(uint256 symbol)
        external
        view
        returns (address liquidityPool, uint256 perpetualIndex);

    function getSymbols(address liquidityPool, uint256 perpetualIndex)
        external
        view
        returns (uint256[] memory symbols);

    function allocateSymbol(address liquidityPool, uint256 perpetualIndex) external;

    function assignReservedSymbol(
        address liquidityPool,
        uint256 perpetualIndex,
        uint256 symbol
    ) external;
}

library SafeMathUpgradeable {
    
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        
        
        
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

library SignedSafeMathUpgradeable {
    int256 constant private _INT256_MIN = -2**255;

    
    function mul(int256 a, int256 b) internal pure returns (int256) {
        
        
        
        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;
    }

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

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

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

library Constant {
    address internal constant INVALID_ADDRESS = address(0);

    int256 internal constant SIGNED_ONE = 10**18;
    uint256 internal constant UNSIGNED_ONE = 10**18;

    uint256 internal constant PRIVILEGE_DEPOSIT = 0x1;
    uint256 internal constant PRIVILEGE_WITHDRAW = 0x2;
    uint256 internal constant PRIVILEGE_TRADE = 0x4;
    uint256 internal constant PRIVILEGE_LIQUIDATE = 0x8;
    uint256 internal constant PRIVILEGE_GUARD =
        PRIVILEGE_DEPOSIT | PRIVILEGE_WITHDRAW | PRIVILEGE_TRADE | PRIVILEGE_LIQUIDATE;
    
    uint256 internal constant SET_ALL_PERPETUALS_TO_EMERGENCY_STATE =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
}

library EnumerableSet {
    
    
    
    
    
    
    
    

    struct Set {
        
        bytes32[] _values;

        
        
        mapping (bytes32 => uint256) _indexes;
    }

    
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            
            
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { 
            
            
            

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            
            

            bytes32 lastvalue = set._values[lastIndex];

            
            set._values[toDeleteIndex] = lastvalue;
            
            set._indexes[lastvalue] = toDeleteIndex + 1; 

            
            set._values.pop();

            
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    

    struct Bytes32Set {
        Set _inner;
    }

    
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    

    struct AddressSet {
        Set _inner;
    }

    
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    

    struct UintSet {
        Set _inner;
    }

    
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

enum Round {
    CEIL,
    FLOOR
}

library SafeMathExt {
    using SafeMathUpgradeable for uint256;
    using SignedSafeMathUpgradeable for int256;

    
    function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x.mul(y).add(Constant.UNSIGNED_ONE / 2) / Constant.UNSIGNED_ONE;
    }

    
    function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x.mul(Constant.UNSIGNED_ONE).add(y / 2).div(y);
    }

    
    function wfrac(
        uint256 x,
        uint256 y,
        uint256 z
    ) internal pure returns (uint256 r) {
        r = x.mul(y).add(z / 2).div(z);
    }

    
    function wmul(int256 x, int256 y) internal pure returns (int256 z) {
        z = roundHalfUp(x.mul(y), Constant.SIGNED_ONE) / Constant.SIGNED_ONE;
    }

    
    function wdiv(int256 x, int256 y) internal pure returns (int256 z) {
        if (y < 0) {
            y = neg(y);
            x = neg(x);
        }
        z = roundHalfUp(x.mul(Constant.SIGNED_ONE), y).div(y);
    }

    
    function wfrac(
        int256 x,
        int256 y,
        int256 z
    ) internal pure returns (int256 r) {
        int256 t = x.mul(y);
        if (z < 0) {
            z = neg(z);
            t = neg(t);
        }
        r = roundHalfUp(t, z).div(z);
    }

    function wmul(
        int256 x,
        int256 y,
        Round round
    ) internal pure returns (int256 z) {
        z = div(x.mul(y), Constant.SIGNED_ONE, round);
    }

    function wdiv(
        int256 x,
        int256 y,
        Round round
    ) internal pure returns (int256 z) {
        z = div(x.mul(Constant.SIGNED_ONE), y, round);
    }

    function wfrac(
        int256 x,
        int256 y,
        int256 z,
        Round round
    ) internal pure returns (int256 r) {
        int256 t = x.mul(y);
        r = div(t, z, round);
    }

    function abs(int256 x) internal pure returns (int256) {
        return x >= 0 ? x : neg(x);
    }

    function neg(int256 a) internal pure returns (int256) {
        return SignedSafeMathUpgradeable.sub(int256(0), a);
    }

    
    function roundHalfUp(int256 x, int256 y) internal pure returns (int256) {
        require(y > 0, "roundHalfUp only supports y > 0");
        if (x >= 0) {
            return x.add(y / 2);
        }
        return x.sub(y / 2);
    }

    
    function div(
        int256 x,
        int256 y,
        Round round
    ) internal pure returns (int256 divResult) {
        require(y != 0, "division by zero");
        divResult = x.div(y);
        if (x % y == 0) {
            return divResult;
        }
        bool isSameSign = Utils.hasTheSameSign(x, y);
        if (round == Round.CEIL && isSameSign) {
            divResult = divResult.add(1);
        }
        if (round == Round.FLOOR && !isSameSign) {
            divResult = divResult.sub(1);
        }
    }

    function max(int256 a, int256 b) internal pure returns (int256) {
        return a >= b ? a : b;
    }

    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

library Utils {
    using SafeMathExt for int256;
    using SafeMathExt for uint256;
    using SafeMathUpgradeable for uint256;
    using SignedSafeMathUpgradeable for int256;
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;

    
    function hasTheSameSign(int256 x, int256 y) internal pure returns (bool) {
        if (x == 0 || y == 0) {
            return true;
        }
        return (x ^ y) >> 255 == 0;
    }

    
    function hasOpenedPosition(int256 amount, int256 delta) internal pure returns (bool) {
        if (amount == 0) {
            return false;
        }
        return Utils.hasTheSameSign(amount, delta);
    }

    
    function splitAmount(int256 amount, int256 delta) internal pure returns (int256, int256) {
        if (Utils.hasTheSameSign(amount, delta)) {
            return (0, delta);
        } else if (amount.abs() >= delta.abs()) {
            return (delta, 0);
        } else {
            return (amount.neg(), amount.add(delta));
        }
    }

    
    function isOpen(int256 amount, int256 delta) internal pure returns (bool) {
        return Utils.hasTheSameSign(amount, delta) || amount.abs() < delta.abs();
    }

    
    function chainID() internal pure returns (uint256 id) {
        assembly {
            id := chainid()
        }
    }

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    function toArray(
        EnumerableSetUpgradeable.AddressSet storage set,
        uint256 begin,
        uint256 end
    ) internal view returns (address[] memory result) {
        require(end > begin, "begin should be lower than end");
        uint256 length = set.length();
        if (begin >= length) {
            return result;
        }
        uint256 safeEnd = end.min(length);
        result = new address[](safeEnd.sub(begin));
        for (uint256 i = begin; i < safeEnd; i++) {
            result[i.sub(begin)] = set.at(i);
        }
        return result;
    }

    function toArray(
        EnumerableSetUpgradeable.Bytes32Set storage set,
        uint256 begin,
        uint256 end
    ) internal view returns (bytes32[] memory result) {
        require(end > begin, "begin should be lower than end");
        uint256 length = set.length();
        if (begin >= length) {
            return result;
        }
        uint256 safeEnd = end.min(length);
        result = new bytes32[](safeEnd.sub(begin));
        for (uint256 i = begin; i < safeEnd; i++) {
            result[i.sub(begin)] = set.at(i);
        }
        return result;
    }
}

interface IInverseStateService {
    function isInverse(address liquidityPool, uint256 perpetualIndex) external view returns (bool);
}

contract Reader {
    using SafeMathExt for uint256;
    using Address for address;

    IInverseStateService public immutable inverseStateService;

    struct LiquidityPoolReaderResult {
        bool isRunning;
        bool isFastCreationEnabled;
        
        address[7] addresses;
        int256[5] intNums;
        uint256[4] uintNums;
        PerpetualReaderResult[] perpetuals;
        bool isAMMMaintenanceSafe;
    }

    struct PerpetualReaderResult {
        PerpetualState state;
        address oracle;
        
        int256[39] nums;
        uint256 symbol; 
        string underlyingAsset;
        bool isMarketClosed;
        bool isTerminated;
        int256 ammCashBalance;
        int256 ammPositionAmount;
        bool isInversePerpetual;
    }

    struct AccountReaderResult {
        int256 cash;
        int256 position;
        int256 availableMargin;
        int256 margin;
        int256 settleableMargin;
        bool isInitialMarginSafe;
        bool isMaintenanceMarginSafe;
        bool isMarginSafe;
        int256 targetLeverage;
    }

    struct AccountsResult {
        address account;
        int256 position;
        int256 margin;
        bool isSafe;
    }

    constructor(address inverseStateService_) {
        require(inverseStateService_.isContract(), "inverseStateService must be contract");
        inverseStateService = IInverseStateService(inverseStateService_);
    }

    
    function getAccountStorage(
        address liquidityPool,
        uint256 perpetualIndex,
        address account
    ) public returns (bool isSynced, AccountReaderResult memory accountStorage) {
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        (bool success, bytes memory data) = liquidityPool.call(
            abi.encodeWithSignature("getMarginAccount(uint256,address)", perpetualIndex, account)
        );
        require(success, "fail to retrieve margin account");
        accountStorage = _parseMarginAccount(data);
    }

    
    function isAMMMaintenanceSafe(address liquidityPool) public returns (bool) {
        (, , , , uint256[4] memory uintNums) = ILiquidityPoolFull(liquidityPool)
            .getLiquidityPoolInfo();
        
        if (uintNums[1] == 0) {
            return true;
        }
        try
            ILiquidityPoolGovernance(liquidityPool).setEmergencyState(
                Constant.SET_ALL_PERPETUALS_TO_EMERGENCY_STATE
            )
        {
            return false;
        } catch {
            return true;
        }
    }

    function _parseMarginAccount(bytes memory data)
        internal
        pure
        returns (AccountReaderResult memory accountStorage)
    {
        require(data.length % 0x20 == 0, "malformed input data");
        assembly {
            let len := mload(data)
            let src := add(data, 0x20)
            let dst := accountStorage
            for {
                let end := add(src, len)
            } lt(src, end) {
                src := add(src, 0x20)
                dst := add(dst, 0x20)
            } {
                mstore(dst, mload(src))
            }
        }
    }

    
    function getPoolMargin(address liquidityPool)
        public
        returns (
            bool isSynced,
            int256 poolMargin,
            bool isSafe
        )
    {
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        (poolMargin, isSafe) = ILiquidityPoolFull(liquidityPool).getPoolMargin();
    }

    
    function queryTrade(
        address liquidityPool,
        uint256 perpetualIndex,
        address trader,
        int256 amount,
        address referrer,
        uint32 flags
    )
        external
        returns (
            bool isSynced,
            int256 tradePrice,
            int256 totalFee,
            int256 cost
        )
    {
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        (tradePrice, totalFee, cost) = ILiquidityPoolFull(liquidityPool).queryTrade(
            perpetualIndex,
            trader,
            amount,
            referrer,
            flags
        );
    }

    
    function getLiquidityPoolStorage(address liquidityPool)
        public
        returns (bool isSynced, LiquidityPoolReaderResult memory pool)
    {
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        
        (
            pool.isRunning,
            pool.isFastCreationEnabled,
            pool.addresses,
            pool.intNums,
            pool.uintNums
        ) = ILiquidityPoolFull(liquidityPool).getLiquidityPoolInfo();
        
        uint256 perpetualCount = pool.uintNums[1];
        address symbolService = IPoolCreatorFull(pool.addresses[0]).getSymbolService();
        pool.perpetuals = new PerpetualReaderResult[](perpetualCount);
        for (uint256 i = 0; i < perpetualCount; i++) {
            getPerpetual(pool.perpetuals[i], symbolService, liquidityPool, i);
        }
        
        pool.isAMMMaintenanceSafe = true;
        if (perpetualCount > 0) {
            try
                ILiquidityPoolGovernance(liquidityPool).setEmergencyState(
                    Constant.SET_ALL_PERPETUALS_TO_EMERGENCY_STATE
                )
            {
                pool.isAMMMaintenanceSafe = false;
            } catch {}
        }
    }

    function getPerpetual(
        PerpetualReaderResult memory perp,
        address symbolService,
        address liquidityPool,
        uint256 perpetualIndex
    ) private {
        
        (perp.state, perp.oracle, perp.nums) = ILiquidityPoolFull(liquidityPool).getPerpetualInfo(
            perpetualIndex
        );
        
        perp.symbol = getMinSymbol(symbolService, liquidityPool, perpetualIndex);
        
        perp.underlyingAsset = IOracle(perp.oracle).underlyingAsset();
        perp.isMarketClosed = IOracle(perp.oracle).isMarketClosed();
        perp.isTerminated = IOracle(perp.oracle).isTerminated();
        
        (perp.ammCashBalance, perp.ammPositionAmount, , , , , , , ) = ILiquidityPoolFull(
            liquidityPool
        ).getMarginAccount(perpetualIndex, liquidityPool);
        
        perp.isInversePerpetual = inverseStateService.isInverse(liquidityPool, perpetualIndex);
    }

    function readIndexPrices(address[] memory oracles)
        public
        returns (bool[] memory isSuccess, int256[] memory indexPrices, uint256[] memory timestamps)
    {
        isSuccess = new bool[](oracles.length);
        indexPrices = new int256[](oracles.length);
        timestamps = new uint256[](oracles.length);
        for (uint256 i = 0; i < oracles.length; i++) {
            if (!oracles[i].isContract()) {
                continue;
            }
            try IOracle(oracles[i]).priceTWAPShort() returns (int256 indexPrice, uint256 timestamp) {
                isSuccess[i] = true;
                indexPrices[i] = indexPrice;
                timestamps[i] = timestamp;
            } catch {}
        }
    }

    function getMinSymbol(
        address symbolService,
        address liquidityPool,
        uint256 perpetualIndex
    ) private view returns (uint256) {
        uint256[] memory symbols;
        symbols = ISymbolService(symbolService).getSymbols(liquidityPool, perpetualIndex);
        uint256 symbolLength = symbols.length;
        require(symbolLength >= 1, "symbol not found");
        uint256 minSymbol = type(uint256).max;
        for (uint256 i = 0; i < symbolLength; i++) {
            minSymbol = minSymbol.min(symbols[i]);
        }
        return minSymbol;
    }

    
    function getAccountsInfo(
        address liquidityPool,
        uint256 perpetualIndex,
        uint256 begin,
        uint256 end
    ) public returns (bool isSynced, AccountsResult[] memory result) {
        address[] memory accounts = ILiquidityPoolFull(liquidityPool).listActiveAccounts(
            perpetualIndex,
            begin,
            end
        );
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        result = new AccountsResult[](accounts.length);
        for (uint256 i = 0; i < accounts.length; i++) {
            int256 margin;
            int256 position;
            bool isMaintenanceMarginSafe;
            (, position, , margin, , , isMaintenanceMarginSafe, , ) = ILiquidityPoolFull(
                liquidityPool
            ).getMarginAccount(perpetualIndex, accounts[i]);
            result[i].account = accounts[i];
            result[i].position = position;
            result[i].margin = margin;
            result[i].isSafe = isMaintenanceMarginSafe;
        }
    }

    
    function queryAddLiquidity(
        address liquidityPool,
        int256 cashToAdd,
        int256 shareToMint
    )
        public
        returns (
            bool isSynced,
            int256 cashToAddResult,
            int256 shareToMintResult
        )
    {
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        (cashToAddResult, shareToMintResult) = ILiquidityPoolFull(liquidityPool).queryAddLiquidity(
            cashToAdd,
            shareToMint
        );
    }

    
    function queryRemoveLiquidity(
        address liquidityPool,
        int256 shareToRemove,
        int256 cashToReturn
    )
        public
        returns (
            bool isSynced,
            int256 shareToRemoveResult,
            int256 cashToReturnResult
        )
    {
        try ILiquidityPool(liquidityPool).forceToSyncState() {
            isSynced = true;
        } catch {
            isSynced = false;
        }
        (shareToRemoveResult, cashToReturnResult) = ILiquidityPoolFull(liquidityPool)
            .queryRemoveLiquidity(shareToRemove, cashToReturn);
    }
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"inverseStateService_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"},{"internalType":"uint256","name":"perpetualIndex","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"getAccountStorage","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"components":[{"internalType":"int256","name":"cash","type":"int256"},{"internalType":"int256","name":"position","type":"int256"},{"internalType":"int256","name":"availableMargin","type":"int256"},{"internalType":"int256","name":"margin","type":"int256"},{"internalType":"int256","name":"settleableMargin","type":"int256"},{"internalType":"bool","name":"isInitialMarginSafe","type":"bool"},{"internalType":"bool","name":"isMaintenanceMarginSafe","type":"bool"},{"internalType":"bool","name":"isMarginSafe","type":"bool"},{"internalType":"int256","name":"targetLeverage","type":"int256"}],"internalType":"struct Reader.AccountReaderResult","name":"accountStorage","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"},{"internalType":"uint256","name":"perpetualIndex","type":"uint256"},{"internalType":"uint256","name":"begin","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"}],"name":"getAccountsInfo","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"int256","name":"position","type":"int256"},{"internalType":"int256","name":"margin","type":"int256"},{"internalType":"bool","name":"isSafe","type":"bool"}],"internalType":"struct Reader.AccountsResult[]","name":"result","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"}],"name":"getLiquidityPoolStorage","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"components":[{"internalType":"bool","name":"isRunning","type":"bool"},{"internalType":"bool","name":"isFastCreationEnabled","type":"bool"},{"internalType":"address[7]","name":"addresses","type":"address[7]"},{"internalType":"int256[5]","name":"intNums","type":"int256[5]"},{"internalType":"uint256[4]","name":"uintNums","type":"uint256[4]"},{"components":[{"internalType":"enum PerpetualState","name":"state","type":"uint8"},{"internalType":"address","name":"oracle","type":"address"},{"internalType":"int256[39]","name":"nums","type":"int256[39]"},{"internalType":"uint256","name":"symbol","type":"uint256"},{"internalType":"string","name":"underlyingAsset","type":"string"},{"internalType":"bool","name":"isMarketClosed","type":"bool"},{"internalType":"bool","name":"isTerminated","type":"bool"},{"internalType":"int256","name":"ammCashBalance","type":"int256"},{"internalType":"int256","name":"ammPositionAmount","type":"int256"},{"internalType":"bool","name":"isInversePerpetual","type":"bool"}],"internalType":"struct Reader.PerpetualReaderResult[]","name":"perpetuals","type":"tuple[]"},{"internalType":"bool","name":"isAMMMaintenanceSafe","type":"bool"}],"internalType":"struct Reader.LiquidityPoolReaderResult","name":"pool","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"}],"name":"getPoolMargin","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"internalType":"int256","name":"poolMargin","type":"int256"},{"internalType":"bool","name":"isSafe","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"inverseStateService","outputs":[{"internalType":"contract IInverseStateService","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"}],"name":"isAMMMaintenanceSafe","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"},{"internalType":"int256","name":"cashToAdd","type":"int256"},{"internalType":"int256","name":"shareToMint","type":"int256"}],"name":"queryAddLiquidity","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"internalType":"int256","name":"cashToAddResult","type":"int256"},{"internalType":"int256","name":"shareToMintResult","type":"int256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"},{"internalType":"int256","name":"shareToRemove","type":"int256"},{"internalType":"int256","name":"cashToReturn","type":"int256"}],"name":"queryRemoveLiquidity","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"internalType":"int256","name":"shareToRemoveResult","type":"int256"},{"internalType":"int256","name":"cashToReturnResult","type":"int256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"liquidityPool","type":"address"},{"internalType":"uint256","name":"perpetualIndex","type":"uint256"},{"internalType":"address","name":"trader","type":"address"},{"internalType":"int256","name":"amount","type":"int256"},{"internalType":"address","name":"referrer","type":"address"},{"internalType":"uint32","name":"flags","type":"uint32"}],"name":"queryTrade","outputs":[{"internalType":"bool","name":"isSynced","type":"bool"},{"internalType":"int256","name":"tradePrice","type":"int256"},{"internalType":"int256","name":"totalFee","type":"int256"},{"internalType":"int256","name":"cost","type":"int256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"oracles","type":"address[]"}],"name":"readIndexPrices","outputs":[{"internalType":"bool[]","name":"isSuccess","type":"bool[]"},{"internalType":"int256[]","name":"indexPrices","type":"int256[]"},{"internalType":"uint256[]","name":"timestamps","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"}]

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

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

000000000000000000000000129ad040bd127c00d6de9051b3cfe9f3e36453d3

-----Decoded View---------------
Arg [0] : inverseStateService_ (address): 0x129ad040bd127c00d6de9051b3cfe9f3e36453d3

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000129ad040bd127c00d6de9051b3cfe9f3e36453d3


Deployed ByteCode Sourcemap

35430:10499:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39200:733;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;35523:57;;;:::i;:::-;;;;;;;:::i;45322:604::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;38758:428::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;37586:541::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39947:1297::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;43558:1135::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;44707:601::-;;;;;;:::i;:::-;;:::i;42202:745::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;36919:653::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;39200:733::-;39441:13;39469:17;39501:15;39531:11;39589:13;-1:-1:-1;;;;;39574:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39570:145;;39698:5;39687:16;;39570:145;;;39649:4;39638:15;;39570:145;39756:169;;;;;-1:-1:-1;;;;;39756:44:0;;;;;:169;;39815:14;;39844:6;;39865;;39886:8;;39909:5;;39756:169;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39200:733;;39725:200;;-1:-1:-1;39725:200:0;-1:-1:-1;39725:200:0;;-1:-1:-1;39200:733:0;;-1:-1:-1;;;;;;39200:733:0:o;35523:57::-;;;:::o;45322:604::-;45500:13;45528:26;45569:25;45641:13;-1:-1:-1;;;;;45626:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45622:145;;45750:5;45739:16;;45622:145;;;45701:4;45690:15;;45622:145;45821:97;;;;;-1:-1:-1;;;;;45821:68:0;;;;;:97;;45890:13;;45905:12;;45821:97;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45322:604;;45777:141;;-1:-1:-1;45777:141:0;;-1:-1:-1;45322:604:0;;-1:-1:-1;;;45322:604:0:o;38758:428::-;38852:13;38880:17;38912:11;38970:13;-1:-1:-1;;;;;38955:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38951:145;;39079:5;39068:16;;38951:145;;;39030:4;39019:15;;38951:145;39148:13;-1:-1:-1;;;;;39129:47:0;;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38758:428;;39106:72;;-1:-1:-1;38758:428:0;-1:-1:-1;;38758:428:0:o;37586:541::-;37655:4;37681:26;;:::i;:::-;37730:13;-1:-1:-1;;;;;37711:68:0;;:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;37672:109;;;;;;37806:8;37815:1;37806:11;;;;;;;;;;;37802:60;;37846:4;37839:11;;;;;37802:60;37889:137;;-1:-1:-1;;;37889:137:0;;-1:-1:-1;;;;;37889:57:0;;;;;:137;;-1:-1:-1;;24730:66:0;37889:137;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37872:248;;38104:4;38097:11;;;;;37872:248;38058:5;38051:12;;;37586:541;;;;:::o;39947:1297::-;40037:13;40052:37;;:::i;:::-;40126:13;-1:-1:-1;;;;;40111:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40107:145;;40235:5;40224:16;;40107:145;;;40186:4;40175:15;;40107:145;40459:13;-1:-1:-1;;;;;40440:54:0;;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40413:13;;;40272:224;;;40386:12;;;40272:224;;;;40357:14;;;;40272:224;;;;;;-1:-1:-1;40316:26:0;;;40272:224;;;;;;;;;40542:16;;;40610:17;;40593:54;;;;;;;40542:16;;-1:-1:-1;;;;;;;40593:52:0;;;;;;:54;;;;;-1:-1:-1;40593:54:0;;;;;;:52;:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40569:78;;40704:14;40676:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;40658:15:0;;;:61;40735:9;40730:137;40754:14;40750:1;:18;40730:137;;;40790:65;40803:4;:15;;;40819:1;40803:18;;;;;;;;;;;;;;40823:13;40838;40853:1;40790:12;:65::i;:::-;40770:3;;40730:137;;;-1:-1:-1;40915:4:0;40887:25;;;:32;40934:18;;40930:307;;40990:145;;-1:-1:-1;;;40990:145:0;;-1:-1:-1;;;;;40990:57:0;;;;;:145;;-1:-1:-1;;24730:66:0;40990:145;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40969:257;;;;;41196:5;41168:25;;;:33;40969:257;39947:1297;;;;;:::o;43558:1135::-;43717:13;43732:30;43775:25;43822:13;-1:-1:-1;;;;;43803:52:0;;43870:14;43899:5;43919:3;43803:130;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43803:130:0;;;;;;;;;;;;:::i;:::-;43775:158;;43963:13;-1:-1:-1;;;;;43948:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43944:145;;44072:5;44061:16;;43944:145;;;44023:4;44012:15;;43944:145;44129:8;:15;44108:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;44099:46;;44161:9;44156:530;44180:8;:15;44176:1;:19;44156:530;;;44217:13;44245:15;44275:28;44413:13;-1:-1:-1;;;;;44376:82:0;;44459:14;44475:8;44484:1;44475:11;;;;;;;;;;;;;;44376:111;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;44522:11:0;;44318:169;;-1:-1:-1;44318:169:0;;-1:-1:-1;44318:169:0;;-1:-1:-1;44522:8:0;;-1:-1:-1;44531:1:0;;-1:-1:-1;;44522:11:0;;;-1:-1:-1;44522:11:0;;;;;;;;;;44502:6;44509:1;44502:9;;;;;;;;;;;;;;:17;;:31;-1:-1:-1;;;;;44502:31:0;;;-1:-1:-1;;;;;44502:31:0;;;;;44569:8;44548:6;44555:1;44548:9;;;;;;;;;;;;;;:18;;:29;;;;;44611:6;44592;44599:1;44592:9;;;;;;;;;;;;;;:16;;:25;;;;;44651:23;44632:6;44639:1;44632:9;;;;;;;;;;;;;;;;;;:42;;;:16;;;;:42;-1:-1:-1;;;44197:3:0;;44156:530;;;;43558:1135;;;;;;;;:::o;44707:601::-;44877:13;44905:22;44942:24;45013:13;-1:-1:-1;;;;;44998:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44994:145;;45122:5;45111:16;;44994:145;;;45073:4;45062:15;;44994:145;45188:112;;;;;-1:-1:-1;;;;;45188:51:0;;;;;:112;;45254:9;;45278:11;;45188:112;;;:::i;42202:745::-;42287:23;42312:27;42341;42409:7;:14;42398:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42398:26:0;;42386:38;;42462:7;:14;42449:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42449:28:0;;42435:42;;42515:7;:14;42501:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42501:29:0;;42488:42;;42546:9;42541:399;42565:7;:14;42561:1;:18;42541:399;;;42606:23;:7;42614:1;42606:10;;;;;;;;;;;;;;-1:-1:-1;;;;;42606:21:0;;:23::i;:::-;42601:73;;42650:8;;42601:73;42700:7;42708:1;42700:10;;;;;;;;;;;;;;-1:-1:-1;;;;;42692:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42692:36:0;;;;;;;;-1:-1:-1;;42692:36:0;;;;;;;;;;;;:::i;:::-;;;42688:241;;;;;42810:4;42795:9;42805:1;42795:12;;;;;;;;;;;;;:19;;;;;;;;;;;42850:10;42833:11;42845:1;42833:14;;;;;;;;;;;;;:27;;;;;42895:9;42879:10;42890:1;42879:13;;;;;;;;;;;;;:25;;;;;42729:191;;42688:241;42581:3;;42541:399;;;;42202:745;;;;;:::o;36919:653::-;37060:13;37075:41;;:::i;:::-;37148:13;-1:-1:-1;;;;;37133:46:0;;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37129:145;;37257:5;37246:16;;37129:145;;;37208:4;37197:15;;37129:145;37285:12;37299:17;37320:13;-1:-1:-1;;;;;37320:18:0;37414:14;37430:7;37353:85;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;37353:85:0;;;;;;;;;;;;;;;;-1:-1:-1;;;37353:85:0;;;37320:129;;;37353:85;37320:129;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37284:165;;;;37468:7;37460:51;;;;-1:-1:-1;;;37460:51:0;;;;;;;:::i;:::-;;;;;;;;;37539:25;37559:4;37539:19;:25::i;:::-;37522:42;;36919:653;;;;;;;;:::o;92:216::-;253:20;292:8;;;92:216::o;41252:942::-;41490:90;;;;;-1:-1:-1;;;;;41490:50:0;;;;;:90;;41555:14;;41490:90;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41477:9;;;41451:129;;;-1:-1:-1;;;;;41451:129:0;;41464:11;;;41451:129;41452:4;41451:129;;;;;;;;;;;;;;;;;;;;;;;41615:58;41628:13;41643;41658:14;41615:12;:58::i;:::-;41601:4;:11;;:72;;;;;41725:4;:11;;;-1:-1:-1;;;;;41717:36:0;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;41717:38:0;;;;;;;;;;;;:::i;:::-;41694:4;:20;;:61;;;;41796:4;:11;;;-1:-1:-1;;;;;41788:35:0;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41766:59;;:19;;;:59;41864:11;;;;;41856:35;;;;;;;;-1:-1:-1;;;;;41856:33:0;;;;;;:35;;;;;;;;;;;:33;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41836:55;;:17;;;:55;41974:105;;-1:-1:-1;;;41974:105:0;;-1:-1:-1;;;;;41974:74:0;;;;;:105;;42049:14;;42007:13;;41974:105;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;41934:22:0;;;41912:167;;;;-1:-1:-1;;;41913:19:0;;;41912:167;42126:60;;;;;-1:-1:-1;;;;;42126:19:0;:29;;;;:60;;42156:13;;42171:14;;42126:60;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42100:86;;:23;;;;:86;;;;-1:-1:-1;;;41252:942:0:o;38135:609::-;38233:41;;:::i;:::-;38314:4;38300;:11;:18;;;;;;:23;38292:56;;;;-1:-1:-1;;;38292:56:0;;;;;;;:::i;:::-;38400:4;38394:11;38440:4;38434;38430:15;38470:14;38541:3;38536;38532:13;38498:228;38569:3;38564;38561:12;38498:228;;;38700:10;;38688:23;;38609:4;38600:14;;;;38639;;;;38498:228;;;38502:58;;;;38368:369;;;:::o;42955:589::-;43103:7;43123:24;43183:13;-1:-1:-1;;;;;43168:40:0;;43209:13;43224:14;43168:71;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43168:71:0;;;;;;;;;;;;:::i;:::-;43273:14;;43158:81;;-1:-1:-1;43322:1:0;43306:17;;;43298:46;;;;-1:-1:-1;;;43298:46:0;;;;;;;:::i;:::-;-1:-1:-1;;43355:17:0;43403:107;43427:12;43423:1;:16;43403:107;;;43473:25;43487:7;43495:1;43487:10;;;;;;;;;;;;;;43473:9;:13;;:25;;;;:::i;:::-;43461:37;-1:-1:-1;43441:3:0;;43403:107;;;-1:-1:-1;43527:9:0;42955:589;-1:-1:-1;;;;;;42955:589:0:o;32373:106::-;32431:7;32462:1;32458;:5;:13;;32470:1;32458:13;;;32466:1;32458:13;32451:20;32373:106;-1:-1:-1;;;32373:106:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:691:1:-;;132:3;125:4;117:6;113:17;109:27;99:2;;154:5;147;140:20;99:2;191;185:9;233:3;225:6;221:16;303:6;291:10;288:22;267:18;255:10;252:34;249:62;246:2;;;314:9;246:2;341;334:22;374:6;-1:-1:-1;374:6:1;426;459:3;447:16;;444:25;-1:-1:-1;441:2:1;;;482:1;479;472:12;441:2;504:1;514:185;528:4;525:1;522:11;514:185;;;587:10;;575:23;;621:4;645:12;;;;677;;;;548:1;541:9;514:185;;;518:3;;;89:616;;;;:::o;710:692::-;;829:3;822:4;814:6;810:17;806:27;796:2;;851:5;844;837:20;796:2;888;882:9;930:3;922:6;918:16;1000:6;988:10;985:22;964:18;952:10;949:34;946:62;943:2;;;1011:9;943:2;1038;1031:22;1071:6;-1:-1:-1;1071:6:1;1123;1156:3;1144:16;;1141:25;-1:-1:-1;1138:2:1;;;1179:1;1176;1169:12;1138:2;1201:1;1211:185;1225:4;1222:1;1219:11;1211:185;;;1284:10;;1272:23;;1318:4;1342:12;;;;1374;;;;1245:1;1238:9;1211:185;;1407:166;1485:13;;1534;;1527:21;1517:32;;1507:2;;1563:1;1560;1553:12;1578:259;;1690:2;1678:9;1669:7;1665:23;1661:32;1658:2;;;1711:6;1703;1696:22;1658:2;1755:9;1742:23;1774:33;1801:5;1774:33;:::i;1842:263::-;;1965:2;1953:9;1944:7;1940:23;1936:32;1933:2;;;1986:6;1978;1971:22;1933:2;2023:9;2017:16;2042:33;2069:5;2042:33;:::i;2110:393::-;;;;2254:2;2242:9;2233:7;2229:23;2225:32;2222:2;;;2275:6;2267;2260:22;2222:2;2319:9;2306:23;2338:33;2365:5;2338:33;:::i;:::-;2390:5;2442:2;2427:18;;2414:32;;-1:-1:-1;2493:2:1;2478:18;;;2465:32;;2212:291;-1:-1:-1;;;2212:291:1:o;2508:470::-;;;;2654:2;2642:9;2633:7;2629:23;2625:32;2622:2;;;2675:6;2667;2660:22;2622:2;2719:9;2706:23;2738:33;2765:5;2738:33;:::i;:::-;2790:5;-1:-1:-1;2842:2:1;2827:18;;2814:32;;-1:-1:-1;2898:2:1;2883:18;;2870:32;2911:35;2870:32;2911:35;:::i;:::-;2965:7;2955:17;;;2612:366;;;;;:::o;2983:865::-;;;;;;;3178:3;3166:9;3157:7;3153:23;3149:33;3146:2;;;3200:6;3192;3185:22;3146:2;3244:9;3231:23;3263:33;3290:5;3263:33;:::i;:::-;3315:5;-1:-1:-1;3367:2:1;3352:18;;3339:32;;-1:-1:-1;3423:2:1;3408:18;;3395:32;3436:35;3395:32;3436:35;:::i;:::-;3490:7;-1:-1:-1;3544:2:1;3529:18;;3516:32;;-1:-1:-1;3600:3:1;3585:19;;3572:33;3614:35;3572:33;3614:35;:::i;:::-;3668:7;-1:-1:-1;3727:3:1;3712:19;;3699:33;3776:10;3763:24;;3751:37;;3741:2;;3807:6;3799;3792:22;3741:2;3835:7;3825:17;;;3136:712;;;;;;;;:::o;3853:464::-;;;;;4016:3;4004:9;3995:7;3991:23;3987:33;3984:2;;;4038:6;4030;4023:22;3984:2;4082:9;4069:23;4101:33;4128:5;4101:33;:::i;:::-;4153:5;4205:2;4190:18;;4177:32;;-1:-1:-1;4256:2:1;4241:18;;4228:32;;4307:2;4292:18;4279:32;;-1:-1:-1;3974:343:1;-1:-1:-1;;;3974:343:1:o;4322:1050::-;;4437:2;4480;4468:9;4459:7;4455:23;4451:32;4448:2;;;4501:6;4493;4486:22;4448:2;4546:9;4533:23;4579:18;4571:6;4568:30;4565:2;;;4616:6;4608;4601:22;4565:2;4644:22;;4697:4;4689:13;;4685:27;-1:-1:-1;4675:2:1;;4731:6;4723;4716:22;4675:2;4776;4763:16;4799:69;4814:53;4860:6;4814:53;:::i;:::-;4799:69;:::i;:::-;4902:19;;;4937:12;;;;4969:11;;;5007:15;;;4999:24;;4995:33;;4992:46;-1:-1:-1;4989:2:1;;;5056:6;5048;5041:22;4989:2;5083:6;5074:15;;5098:244;5112:6;5109:1;5106:13;5098:244;;;5187:3;5174:17;5204:33;5231:5;5204:33;:::i;:::-;5250:18;;5134:1;5127:9;;;;;5288:12;;;;5320;;5098:244;;;-1:-1:-1;5361:5:1;4417:955;-1:-1:-1;;;;;;;4417:955:1:o;5377:1040::-;;5503:2;5546;5534:9;5525:7;5521:23;5517:32;5514:2;;;5567:6;5559;5552:22;5514:2;5605:9;5599:16;5638:18;5630:6;5627:30;5624:2;;;5675:6;5667;5660:22;5624:2;5703:22;;5756:4;5748:13;;5744:27;-1:-1:-1;5734:2:1;;5790:6;5782;5775:22;5734:2;5828;5822:9;5851:69;5866:53;5912:6;5866:53;:::i;5851:69::-;5954:19;;;5989:12;;;;6021:11;;;6059:15;;;6051:24;;6047:33;;6044:46;-1:-1:-1;6041:2:1;;;6108:6;6100;6093:22;6041:2;6135:6;6126:15;;6150:237;6164:6;6161:1;6158:13;6150:237;;;6232:3;6226:10;6249:33;6276:5;6249:33;:::i;:::-;6295:18;;6186:1;6179:9;;;;;6333:12;;;;6365;;6150:237;;6422:963;;6548:2;6591;6579:9;6570:7;6566:23;6562:32;6559:2;;;6612:6;6604;6597:22;6559:2;6650:9;6644:16;6683:18;6675:6;6672:30;6669:2;;;6720:6;6712;6705:22;6669:2;6748:22;;6801:4;6793:13;;6789:27;-1:-1:-1;6779:2:1;;6835:6;6827;6820:22;6779:2;6873;6867:9;6896:69;6911:53;6957:6;6911:53;:::i;6896:69::-;6999:19;;;7034:12;;;;7066:11;;;7104:15;;;7096:24;;7092:33;;7089:46;-1:-1:-1;7086:2:1;;;7153:6;7145;7138:22;7086:2;7180:6;7171:15;;7195:160;7209:6;7206:1;7203:13;7195:160;;;7270:10;;7258:23;;7231:1;7224:9;;;;;7301:12;;;;7333;;7195:160;;7390:214;;7510:2;7498:9;7489:7;7485:23;7481:32;7478:2;;;7531:6;7523;7516:22;7478:2;7559:39;7588:9;7559:39;:::i;7609:1161::-;;;;;;7862:3;7850:9;7841:7;7837:23;7833:33;7830:2;;;7884:6;7876;7869:22;7830:2;7912:39;7941:9;7912:39;:::i;:::-;7902:49;;7970:2;7991:48;8035:2;8024:9;8020:18;7991:48;:::i;:::-;7981:58;;8082:7;8077:2;8066:9;8062:18;8058:32;8048:2;;8109:6;8101;8094:22;8048:2;8138:19;8153:3;8138:19;:::i;:::-;8179:3;8217:2;8206:9;8202:18;8254:3;8243:9;8239:19;8277:7;8273:2;8270:15;8267:2;;;8303:6;8295;8288:22;8267:2;8330:6;8345:235;8359:4;8356:1;8353:11;8345:235;;;8425:3;8419:10;8442:33;8469:5;8442:33;:::i;:::-;8488:18;;8526:12;;;;8558;;;;8379:1;8372:9;8345:235;;;8349:3;8599:5;8589:15;;8623:52;8667:7;8663:2;8623:52;:::i;:::-;8613:62;;;;;;;8694:70;8756:7;8750:3;8739:9;8735:19;8694:70;:::i;:::-;8684:80;;7820:950;;;;;;;;:::o;8775:985::-;;;;8951:4;8996:2;8984:9;8975:7;8971:23;8967:32;8964:2;;;9017:6;9009;9002:22;8964:2;9054:9;9048:16;9093:1;9086:5;9083:12;9073:2;;9114:6;9106;9099:22;9073:2;9142:5;9132:15;;;9166:2;9213;9202:9;9198:18;9192:25;9226:35;9253:7;9226:35;:::i;:::-;9280:7;-1:-1:-1;9325:2:1;9310:18;;9306:32;-1:-1:-1;9296:2:1;;9357:6;9349;9342:22;9296:2;9386:20;9401:4;9386:20;:::i;:::-;9428:3;9466:2;9455:9;9451:18;9504:7;9499:2;9488:9;9484:18;9481:31;9478:2;;;9530:6;9522;9515:22;9478:2;9557:6;9548:15;;9572:158;9586:4;9583:1;9580:11;9572:158;;;9645:10;;9633:23;;9606:1;9599:9;;;;;9676:12;;;;9708;;9572:158;;;9576:3;9749:5;9739:15;;;;;;8931:829;;;;;:::o;9765:274::-;;;9901:2;9889:9;9880:7;9876:23;9872:32;9869:2;;;9922:6;9914;9907:22;9869:2;9956:9;9950:16;9940:26;;9985:48;10029:2;10018:9;10014:18;9985:48;:::i;:::-;9975:58;;9859:180;;;;;:::o;10044:253::-;;;10182:2;10170:9;10161:7;10157:23;10153:32;10150:2;;;10203:6;10195;10188:22;10150:2;-1:-1:-1;;10231:16:1;;10287:2;10272:18;;;10266:25;10231:16;;10266:25;;-1:-1:-1;10140:157:1:o;10302:313::-;;;;10456:2;10444:9;10435:7;10431:23;10427:32;10424:2;;;10477:6;10469;10462:22;10424:2;10511:9;10505:16;10495:26;;10561:2;10550:9;10546:18;10540:25;10530:35;;10605:2;10594:9;10590:18;10584:25;10574:35;;10414:201;;;;;:::o;10620:742::-;;;;;;;;;;10864:3;10852:9;10843:7;10839:23;10835:33;10832:2;;;10886:6;10878;10871:22;10832:2;10920:9;10914:16;10904:26;;10970:2;10959:9;10955:18;10949:25;10939:35;;11014:2;11003:9;10999:18;10993:25;10983:35;;11058:2;11047:9;11043:18;11037:25;11027:35;;11102:3;11091:9;11087:19;11081:26;11071:36;;11126:49;11170:3;11159:9;11155:19;11126:49;:::i;:::-;11116:59;;11194:49;11238:3;11227:9;11223:19;11194:49;:::i;:::-;11184:59;;11262:49;11306:3;11295:9;11291:19;11262:49;:::i;:::-;11252:59;;11351:3;11340:9;11336:19;11330:26;11320:36;;10822:540;;;;;;;;;;;:::o;11626:760::-;;11759:2;11747:9;11738:7;11734:23;11730:32;11727:2;;;11780:6;11772;11765:22;11727:2;11818:9;11812:16;11847:18;11888:2;11880:6;11877:14;11874:2;;;11909:6;11901;11894:22;11874:2;11952:6;11941:9;11937:22;11927:32;;11997:7;11990:4;11986:2;11982:13;11978:27;11968:2;;12024:6;12016;12009:22;11968:2;12062;12056:9;12088:2;12080:6;12077:14;12074:2;;;12094:9;12074:2;12127:56;12173:2;12150:17;;-1:-1:-1;;12146:31:1;12179:2;12142:40;12127:56;:::i;:::-;12114:69;;12206:6;12199:5;12192:21;12254:7;12249:2;12240:6;12236:2;12232:15;12228:24;12225:37;12222:2;;;12280:6;12272;12265:22;12222:2;12298:58;12349:6;12344:2;12337:5;12333:14;12328:2;12324;12320:11;12298:58;:::i;:::-;-1:-1:-1;12375:5:1;11717:669;-1:-1:-1;;;;11717:669:1:o;12391:129::-;-1:-1:-1;;;;;12459:54:1;12447:67;;12437:83::o;12525:380::-;12623:5;12646:1;12656:243;12670:4;12667:1;12664:11;12656:243;;;12733:13;;-1:-1:-1;;;;;12729:62:1;12717:75;;12815:4;12839:12;;;;12874:15;;;;12690:1;12683:9;12656:243;;;12660:3;;12580:325;;:::o;12910:330::-;13007:5;13030:1;13040:194;13054:4;13051:1;13048:11;13040:194;;;13113:13;;13101:26;;13150:4;13174:12;;;;13209:15;;;;13074:1;13067:9;13040:194;;13245:341;13353:5;13376:1;13386:194;13400:4;13397:1;13394:11;13386:194;;;13459:13;;13447:26;;13496:4;13520:12;;;;13555:15;;;;13420:1;13413:9;13386:194;;13591:1703;;13703:3;13735:5;13729:12;13762:6;13757:3;13750:19;13788:4;13817:2;13812:3;13808:12;13801:19;;13874:2;13868;13860:6;13856:15;13849:5;13845:27;13841:36;13911:2;13904:5;13900:14;13932:3;13944:1324;13958:6;13955:1;13952:13;13944:1324;;;14045:2;14041:7;14033:5;14027:4;14023:16;14019:30;14014:3;14007:43;14079:6;14073:13;14109:6;14128:50;14173:4;14168:2;14162:9;14128:50;:::i;:::-;14225:2;14221;14217:11;14211:18;14242:49;14287:2;14281:4;14277:13;14263:12;14242:49;:::i;:::-;;14314:4;14367:2;14363;14359:11;14353:18;14384:59;14439:2;14433:4;14429:13;14413:14;14384:59;:::i;:::-;;;14496:4;14492:2;14488:13;14482:20;14473:6;14467:4;14463:17;14456:47;14552:4;14548:2;14544:13;14538:20;14597:2;14588:6;14582:4;14578:17;14571:29;14627:50;14673:2;14667:4;14663:13;14647:14;14627:50;:::i;:::-;14613:64;;;14726:4;14722:2;14718:13;14712:20;14745:52;14789:6;14783:4;14779:17;14763:14;14745:52;:::i;:::-;;14846:4;14842:2;14838:13;14832:20;14865:52;14909:6;14903:4;14899:17;14883:14;14865:52;:::i;:::-;;14970:4;14966:2;14962:13;14956:20;14947:6;14941:4;14937:17;14930:47;15030:6;15026:2;15022:15;15016:22;15007:6;15001:4;14997:17;14990:49;15088:6;15084:2;15080:15;15074:22;15052:44;;15109:52;15153:6;15147:4;15143:17;15127:14;15109:52;:::i;:::-;15246:12;;;;15182:6;-1:-1:-1;;15211:15:1;;;;13980:1;13973:9;13944:1324;;;-1:-1:-1;15284:4:1;;13680:1614;-1:-1:-1;;;;;;;13680:1614:1:o;15299:331::-;15397:5;15420:1;15430:194;15444:4;15441:1;15438:11;15430:194;;;15503:13;;15491:26;;15540:4;15564:12;;;;15599:15;;;;15464:1;15457:9;15430:194;;15635:443;;15732:5;15726:12;15759:6;15754:3;15747:19;15785:4;15814:2;15809:3;15805:12;15798:19;;15851:2;15844:5;15840:14;15872:3;15884:169;15898:6;15895:1;15892:13;15884:169;;;15959:13;;15947:26;;15993:12;;;;16028:15;;;;15920:1;15913:9;15884:169;;;-1:-1:-1;16069:3:1;;15702:376;-1:-1:-1;;;;;15702:376:1:o;16083:93::-;16155:13;16148:21;16136:34;;16126:50::o;16181:139::-;16270:1;16263:5;16260:12;16250:2;;16276:9;16250:2;16296:18;;16240:80::o;16325:260::-;;16407:5;16401:12;16434:6;16429:3;16422:19;16450:63;16506:6;16499:4;16494:3;16490:14;16483:4;16476:5;16472:16;16450:63;:::i;:::-;16567:2;16546:15;-1:-1:-1;;16542:29:1;16533:39;;;;16574:4;16529:50;;16377:208;-1:-1:-1;;16377:208:1:o;16590:274::-;;16757:6;16751:13;16773:53;16819:6;16814:3;16807:4;16799:6;16795:17;16773:53;:::i;:::-;16842:16;;;;;16727:137;-1:-1:-1;;16727:137:1:o;16869:297::-;-1:-1:-1;;;;;17061:55:1;;;;17043:74;;17148:2;17133:18;;17126:34;17031:2;17016:18;;16998:168::o;17171:1347::-;17509:2;17521:21;;;17591:13;;17494:18;;;17613:22;;;17171:1347;;17689:4;;17666:3;17651:19;;;17716:15;;;17171:1347;17762:185;17776:6;17773:1;17770:13;17762:185;;;17851:13;;17844:21;17837:29;17825:42;;17887:12;;;;17922:15;;;;17798:1;17791:9;17762:185;;;-1:-1:-1;;;17983:19:1;;;17963:18;;;17956:47;18053:13;;18075:21;;;18151:15;;;;18114:12;;;18186:4;18199:189;18215:8;18210:3;18207:17;18199:189;;;18284:15;;18270:30;;18361:17;;;;18322:14;;;;18243:1;18234:11;18199:189;;;18203:3;;18435:9;18428:5;18424:21;18419:2;18408:9;18404:18;18397:49;18463;18506:5;18498:6;18463:49;:::i;:::-;18455:57;17470:1048;-1:-1:-1;;;;;;;;17470:1048:1:o;18523:187::-;18688:14;;18681:22;18663:41;;18651:2;18636:18;;18618:92::o;18715:1080::-;;18972:2;19012;19001:9;18997:18;19056:6;19049:14;19042:22;19031:9;19024:41;19084:2;19122;19117;19106:9;19102:18;19095:30;19145:6;19180;19174:13;19211:6;19203;19196:22;19237:2;19227:12;;19270:2;19259:9;19255:18;19248:25;;19308:2;19300:6;19296:15;19329:4;19342:427;19356:6;19353:1;19350:13;19342:427;;;19415:13;;19457:9;;-1:-1:-1;;;;;19453:58:1;19441:71;;19552:11;;;19546:18;19532:12;;;19525:40;19605:11;;;19599:18;19585:12;;;19578:40;19672:11;;19666:18;19659:26;19652:34;19638:12;;;19631:56;19716:4;19707:14;;;;19744:15;;;;19378:1;19371:9;19342:427;;;-1:-1:-1;19786:3:1;;18952:843;-1:-1:-1;;;;;;;;;18952:843:1:o;19800:337::-;20013:14;;20006:22;19988:41;;20060:2;20045:18;;20038:34;;;;20115:14;20108:22;20103:2;20088:18;;20081:50;19976:2;19961:18;;19943:194::o;20142:325::-;20359:14;;20352:22;20334:41;;20406:2;20391:18;;20384:34;;;;20449:2;20434:18;;20427:34;20322:2;20307:18;;20289:178::o;20472:395::-;20716:14;;20709:22;20691:41;;20763:2;20748:18;;20741:34;;;;20806:2;20791:18;;20784:34;20849:2;20834:18;;20827:34;20678:3;20663:19;;20645:222::o;20872:927::-;;21102:3;21091:9;21087:19;21079:27;;21147:6;21140:14;21133:22;21122:9;21115:41;21198:6;21192:13;21187:2;21176:9;21172:18;21165:41;21260:2;21252:6;21248:15;21242:22;21237:2;21226:9;21222:18;21215:50;21319:2;21311:6;21307:15;21301:22;21296:2;21285:9;21281:18;21274:50;21379:2;21371:6;21367:15;21361:22;21355:3;21344:9;21340:19;21333:51;21439:3;21431:6;21427:16;21421:23;21415:3;21404:9;21400:19;21393:52;21514:3;21506:6;21502:16;21496:23;21489:31;21482:39;21476:3;21465:9;21461:19;21454:68;21591:3;21583:6;21579:16;21573:23;21566:31;21559:39;21553:3;21542:9;21538:19;21531:68;21646:3;21638:6;21634:16;21628:23;21670:3;21682:51;21729:2;21718:9;21714:18;21700:12;21682:51;:::i;:::-;21788:2;21780:6;21776:15;21770:22;21764:3;21753:9;21749:19;21742:51;;;21069:730;;;;;:::o;21804:1213::-;;22055:6;22048:14;22041:22;22030:9;22023:41;22100:2;22095;22084:9;22080:18;22073:30;22159:6;22153:13;22146:21;22139:29;22134:2;22123:9;22119:18;22112:57;22237:2;22229:6;22225:15;22219:22;22212:30;22205:38;22200:2;22189:9;22185:18;22178:66;22291:2;22283:6;22279:15;22273:22;22304:64;22363:3;22352:9;22348:19;22334:12;22304:64;:::i;:::-;;22417:2;22409:6;22405:15;22399:22;22430:76;22501:3;22490:9;22486:19;22470:14;22430:76;:::i;:::-;;22555:3;22547:6;22543:16;22537:23;22569:66;22630:3;22619:9;22615:19;22599:14;22569:66;:::i;:::-;-1:-1:-1;22684:4:1;22672:17;;22666:24;22709:6;22731:18;;;22724:30;22777:93;22865:3;22850:19;;22666:24;22777:93;:::i;:::-;22763:107;;22919:4;22911:6;22907:17;22901:24;22934:54;22983:3;22972:9;22968:19;22952:14;22934:54;:::i;23022:255::-;-1:-1:-1;;;;;23215:55:1;;;;23197:74;;23185:2;23170:18;;23152:125::o;23282:244::-;23452:25;;;23508:2;23493:18;;23486:34;23440:2;23425:18;;23407:119::o;23531:355::-;23733:2;23715:21;;;23772:2;23752:18;;;23745:30;23811:33;23806:2;23791:18;;23784:61;23877:2;23862:18;;23705:181::o;23891:344::-;24093:2;24075:21;;;24132:2;24112:18;;;24105:30;24171:22;24166:2;24151:18;;24144:50;24226:2;24211:18;;24065:170::o;24240:340::-;24442:2;24424:21;;;24481:2;24461:18;;;24454:30;24520:18;24515:2;24500:18;;24493:46;24571:2;24556:18;;24414:166::o;24585:177::-;24731:25;;;24719:2;24704:18;;24686:76::o;24767:297::-;24941:25;;;-1:-1:-1;;;;;25002:55:1;24997:2;24982:18;;24975:83;24929:2;24914:18;;24896:168::o;25069:555::-;25324:25;;;-1:-1:-1;;;;;25446:15:1;;;25441:2;25426:18;;25419:43;25493:2;25478:18;;25471:34;;;;25541:15;;;25536:2;25521:18;;25514:43;25606:10;25594:23;25588:3;25573:19;;25566:52;25311:3;25296:19;;25278:346::o;25629:319::-;25831:25;;;25887:2;25872:18;;25865:34;;;;25930:2;25915:18;;25908:34;25819:2;25804:18;;25786:162::o;25953:242::-;26023:2;26017:9;26053:17;;;26100:18;26085:34;;26121:22;;;26082:62;26079:2;;;26147:9;26079:2;26174;26167:22;25997:198;;-1:-1:-1;25997:198:1:o;26200:183::-;;26299:18;26291:6;26288:30;26285:2;;;26321:9;26285:2;-1:-1:-1;26372:4:1;26353:17;;;26349:28;;26275:108::o;26388:258::-;26460:1;26470:113;26484:6;26481:1;26478:13;26470:113;;;26560:11;;;26554:18;26541:11;;;26534:39;26506:2;26499:10;26470:113;;;26601:6;26598:1;26595:13;26592:2;;;-1:-1:-1;;26636:1:1;26618:16;;26611:27;26441:205::o;26651:156::-;-1:-1:-1;;;;;26732:5:1;26728:54;26721:5;26718:65;26708:2;;26797:1;26794;26787:12;26708:2;26698:109;:::o

Swarm Source

ipfs://338969e2747d50a47e08b9880025a69ac5102b0195fcb6ae3e3ee2f752043f1b
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.