@nradko/metric-omm-sdk-v1 0.1.1 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @nradko/metric-omm-sdk-v1
 
-TypeScript SDK for **v1** Metric OMM contracts: **Swapper**, **LiquidityAdder**, pool `addLiquidity` / `removeLiquidity`, and factory-backed reads.
+TypeScript SDK for **v1** Metric OMM contracts: **Swapper**, **LiquidityAdder**, pool `addLiquidity` / `removeLiquidity`, **extensions**, and factory-backed reads.
 
-Pinned to the same commits as [`dev_metric-deploy/versions.env`](../../../dev_metric-deploy/versions.env).
+Pinned **metric-periphery** `cc8fef9781fba405cfd1945fe6bf49a00da132bb` (core via periphery `lib/metric-core`).
 
 ## Installation
 
@@ -16,18 +16,25 @@ Or via the combined package:
 import { v1 } from "@nradko/metric-omm-sdk";
 ```
 
-## Ethereum mainnet addresses
+## Ethereum mainnet and Base addresses
+
+Protocol contracts use the **same addresses** on Ethereum mainnet and Base (CREATE2). Wrapped native differs per chain (WETH).
 
 | Contract | Address |
 | -------- | ------- |
-| MetricOmmPoolFactory | `0xf98aD80FE666B9a23075CdF64aF5971802844Fd8` |
-| MetricOmmPoolDeployer | `0xf93e1ea4516E99A4Ee81D4979C8D3C8Ab636e397` |
-| MetricOmmPoolLiquidityAdder | `0x05632ffd8D4a22ac6f925B9fc7b60390d436467D` |
-| MetricOmmPoolDataProvider | `0xAce0Ec0040e81eE3496EeE768db8F453f2f0B9Bb` |
-| DepositAllowlist | `0x497B15B9640eCbfFB96C1CFF7e6A3D8Ec5C6dAE2` |
-| SwapAllowlist | `0x657f8CAC2066481b3Cd421781410e383f173433D` |
-| MetricOmmPoolSwapper | `0x377421359e849cc44da76b18511f6A5Dd5abFc23` |
-| WETH | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` |
+| MetricOmmPoolFactory | `0x175851292f22621F337D76fE5445e9372fb06f9C` |
+| MetricOmmPoolDeployer | `0x1C0502457231fF2BE9af4468115B33c112A580eF` |
+| MetricOmmPoolLiquidityAdder | `0x7A2C0A39A48c526F1Cae4d67cb0e7aE883A7B623` |
+| MetricOmmPoolDataProvider | `0xD0C4df72910Fd70C89CBa5f0FE0ef45638D12775` |
+| MetricOmmPoolStateView | `0xb40F8B0cfBB6a01c3232c6D063B1F87d1C0bE40f` |
+| MetricOmmSimpleRouter | `0x818a948B25f32F41547a7B9175cB174d2B1e6AD7` |
+| MetricOmmPoolSwapper | `0x3B8F17A4cb4f91805338f4b6c2f2aAf94243587e` |
+| DepositAllowlistExtension | `0xa56f616c1C8108750b8a5BF387a34C757B8Bdc2c` |
+| SwapAllowlistExtension | `0x1aee646900bE4aa1D0A7Ec6c98483923E1aBf481` |
+| OracleValueStopLossExtension | `0x3CB3EdCce50Bdc95e746F6e7C23fd61d439fA02a` |
+| PriceVelocityGuardExtension | `0x65D5C490fF5Df1861D966A671dB43a8d0c22b9C4` |
+| WETH (Ethereum) | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` |
+| WETH (Base) | `0x4200000000000000000000000000000000000006` |
 
 `MetricOmmPoolDataProvider` is the deployed lens: pool reads (`slot0`, `binStates`, `positionBinShares`, …) plus swap depth and revert-based quotes. Pass `addresses.dataProvider` to read helpers and liquidity builders (`dataProviderAddress` param).
 
@@ -35,10 +42,11 @@ import { v1 } from "@nradko/metric-omm-sdk";
 import { getAddressesOrThrow, ChainId, isChainSupported } from "@nradko/metric-omm-sdk-v1";
 
 const a = getAddressesOrThrow(ChainId.ETHEREUM);
-// isChainSupported(ChainId.BASE) === false — use DeployedChainId / getSupportedChainIds() for bundled addresses
+// getAddressesOrThrow(ChainId.BASE) — same protocol addresses as Ethereum
+// isChainSupported(ChainId.ARBITRUM) === false — use DeployedChainId / getSupportedChainIds()
 ```
 
-`ChainId` lists future chain IDs for typing; **only Ethereum mainnet** has entries in `ADDRESSES` for this release. Use `getSupportedChainIds()`, `isChainSupported()`, or `DeployedChainId` when you need compile-time guarantees.
+ChainId lists future chain IDs for typing; **Ethereum mainnet and Base** have entries in ADDRESSES for this release. Use getSupportedChainIds(), isChainSupported(), or DeployedChainId when you need compile-time guarantees.
 
 ## Swaps (Swapper)
 
@@ -63,6 +71,7 @@ const { args, expectedInput, expectedOutput } =
     amountIn: 1_000_000_000_000_000_000n,
     slippagePercent: 0.5,
     deadline: BigInt(Math.floor(Date.now() / 1000) + 1200),
+    // extensionData: "0x", // optional; defaults to empty
   });
 
 await walletClient.writeContract({
@@ -81,8 +90,82 @@ Quote without building tx args: `quoteSwap` (read-only pool quote), `quoteExpect
 - **Add (EOA):** approve **LiquidityAdder**, then `addLiquidityExactShares` / `addLiquidityWeighted` on the adder (see `encodeAddLiquidity*` helpers).
 - **Remove:** `removeLiquidity` on the pool — build deltas with `buildModifyLiquidityArgsForRemoval` / `encodeRemoveLiquidityCalldata`.
 
+`addLiquidityWeighted` encoders accept optional bin-position bounds (`minimalCurBin`, `minimalPosition`, `maximalCurBin`, `maximalPosition`); defaults disable bounds.
+
 SDK builders still use internal names like `buildModifyLiquidityArgsForUniformAddition` where the math is shared; encoders target v1 pool/adder ABIs.
 
+## Extensions
+
+Pools support up to seven **extensions** (periphery contracts) configured at creation via `extensions`, `extensionOrders`, and `extensionInitData`. Swap and liquidity encoders forward optional **`extensionData`** (defaults to `0x`).
+
+### Pool creation with extensions
+
+```typescript
+import {
+  encodeCreatePoolCalldata,
+  buildExtensionOrders,
+  encodeOracleStopLossInitData,
+  EMPTY_EXTENSION_INIT_DATA,
+} from "@nradko/metric-omm-sdk-v1";
+
+const calldata = encodeCreatePoolCalldata({
+  token0,
+  token1,
+  priceProvider,
+  admin,
+  adminFeeDestination,
+  adminSpreadFeeE6: 5000,
+  adminNotionalFeeE8: 0,
+  curBinDistFromProvidedPricePercent: 0,
+  initialScaledToken0PerShareE18,
+  initialScaledToken1PerShareE18,
+  minimalMintableLiquidity: 1000n,
+  nonNegativeBins,
+  negativeBins,
+  extensions: [depositAllowlistAddress, swapAllowlistAddress],
+  extensionOrders: buildExtensionOrders({
+    beforeAddLiquidity: [1],
+    beforeSwap: [2],
+  }),
+  extensionInitData: [
+    EMPTY_EXTENSION_INIT_DATA, // DepositAllowlist — no init payload
+    EMPTY_EXTENSION_INIT_DATA, // SwapAllowlist — no init payload
+  ],
+});
+```
+
+`encodeExtensionOrder` / `buildExtensionOrders` pack 3-bit extension indices per action (same encoding as on-chain `ExtensionOrders`).
+
+### Initialize data
+
+| Extension | Init encoder |
+| --------- | ------------ |
+| DepositAllowlist, SwapAllowlist, PriceVelocityGuard | `EMPTY_EXTENSION_INIT_DATA` |
+| OracleValueStopLoss | `encodeOracleStopLossInitData({ drawdownE6, decayPerSecondE8, timelockSeconds })` |
+
+### Admin actions (pool admin)
+
+```typescript
+import {
+  encodeSetAllowedToDepositCalldata,
+  encodeSetAllowedToSwapCalldata,
+  encodeSetMaxChangePerBlockCalldata,
+  encodeProposeOracleStopLossDrawdownCalldata,
+} from "@nradko/metric-omm-sdk-v1";
+
+// Allow a depositor on a pool with DepositAllowlistExtension
+const data = encodeSetAllowedToDepositCalldata({
+  extension: depositAllowlistAddress,
+  pool: poolAddress,
+  depositor: userAddress,
+  allowed: true,
+});
+```
+
+Also available: swap allowlist setters, price-velocity guard setters, and oracle stop-loss propose / execute / cancel helpers for timelock, drawdown, decay, and high-watermark updates.
+
+**Swap allowlist note:** when users swap via `MetricOmmPoolSwapper`, the extension gates the **Swapper contract address** as the pool swap caller — allow that address, not the end-user EOA.
+
 ## Pool reads
 
 ```typescript
@@ -90,6 +173,7 @@ import { getPoolImmutables, getPoolState, getSlot0, getAddressesOrThrow, ChainId
 
 const addresses = getAddressesOrThrow(ChainId.ETHEREUM);
 const imm = await getPoolImmutables(publicClient, addresses.factory, poolAddress);
+// imm.extensions (extension1…7), imm.extensionOrders
 const state = await getPoolState(publicClient, addresses.dataProvider, poolAddress);
 const slot0 = await getSlot0(publicClient, addresses.dataProvider, poolAddress);
 ```
@@ -102,6 +186,10 @@ import {
   MetricOmmPoolDataProviderAbi,
   MetricOmmPoolSwapperAbi,
   MetricOmmPoolLiquidityAdderAbi,
+  DepositAllowlistExtensionAbi,
+  SwapAllowlistExtensionAbi,
+  PriceVelocityGuardExtensionAbi,
+  OracleValueStopLossExtensionAbi,
 } from "@nradko/metric-omm-sdk-v1/abis";
 ```
 
@@ -111,7 +199,7 @@ Regenerate from pinned contracts:
 npm run setup:contracts    # init submodules, hardhat build, sync ABIs
 ```
 
-All pinned contracts (including `MetricOmmPoolDataProvider`) are compiled by Hardhat from the pinned `@metric/core` and `@metric/periphery` git dependencies (periphery remappings use core's libs via `lib/metric-core`).
+All pinned contracts are compiled by Hardhat from the pinned `@metric/periphery` git dependency (core via `lib/metric-core`).
 
 ## Development
 
@@ -121,20 +209,19 @@ npm run setup:contracts    # refresh ABIs from pinned git deps (maintainers)
 npm test                   # Hardhat tests (needs matching @metric/* in node_modules)
 ```
 
-In the monorepo, run v1 tests with an isolated install (same pattern as v0):
+In the monorepo, run v1 tests with an isolated install:
 
 ```bash
-# from dev_sdk/
 cd v1
 npm ci
-npm run sync:contracts   # required before first test run
+npm run setup:contracts
 npm test
 ```
 
 ## Tests
 
 ```bash
-npm run sync:contracts && npm test
+npm run setup:contracts && npm test
 ```
 
 Fork tests: set `ETHEREUM_RPC_URL` (optional `ETHEREUM_FORK_BLOCK_NUMBER`).

package/dist/abis/DepositAllowlistExtension.d.ts

@@ -0,0 +1,440 @@
+export declare const DepositAllowlistExtensionAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "factory_";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ExtensionNotImplemented";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotAllowedToDeposit";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "factory";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyFactory";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "factory";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyPool";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "admin";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyPoolAdmin";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "allowed";
+        readonly type: "bool";
+    }];
+    readonly name: "AllowedToDepositSet";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "FACTORY";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "afterAddLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "afterRemoveLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "afterSwap";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }];
+    readonly name: "allowedDepositor";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "beforeAddLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "beforeRemoveLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "beforeSwap";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }];
+    readonly name: "isAllowedToDeposit";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "allowed";
+        readonly type: "bool";
+    }];
+    readonly name: "setAllowedToDeposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=DepositAllowlistExtension.d.ts.map

package/dist/abis/DepositAllowlistExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepositAllowlistExtension.d.ts","sourceRoot":"","sources":["../../src/abis/DepositAllowlistExtension.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0jB/B,CAAC"}