@nxuss/lemma 0.1.0 → 0.2.0

package/README.md

@@ -1,311 +1,477 @@
 # Lemma
 
-**Stop paying for the same LLM call twice.**
+**Shared memory for multi-agent systems.**
 
-Lemma is a semantic cache for AI apps. It recognizes when two prompts mean the same thing and returns the cached response — no LLM call, no cost, no wait.
+Lemma is an orchestration layer that lets AI agents coordinate, share work, and avoid redundant computation. Agents connect via WebSocket, register their capabilities, and automatically benefit from a shared semantic cache — so no two agents ever solve the same problem twice.
 
-```typescript
-import { Lemma } from 'lemma/embed';
-
-const lemma = await Lemma.create();
-const ask = lemma.wrap(yourLLMFunction);
-
-await ask('chicken and rice recipes');   // → calls your LLM, ~2s
-await ask('rice with chicken ideas');    // → ⚡ cache hit, 0ms, $0
+```
+5 agents. 15 tasks. 10 duplicates across different agents.
+Result: 100% cache hit rate. 20-27ms per response. Zero duplicate LLM calls.
 ```
 
 ---
 
-## The problem
+## The problem with multi-agent systems
 
-Every AI app has the same leak: users ask the same questions in different ways, and you pay full price every time.
+When you run multiple AI agents in parallel, they don't share context. Agent A solves a problem. Agent B gets the same problem 10 minutes later and solves it again. You pay twice, wait twice, and get the same answer.
+
+At scale this compounds fast:
 
 ```
-1,000 users ask about "chicken recipes" → 1,000 LLM calls → $60/day
+10 agents × 500 tasks/day × 70% overlap = 3,500 redundant LLM calls/day
 ```
 
-Lemma understands that *"chicken and rice"*, *"rice with chicken"*, and *"what can I make with chicken and rice?"* are the same question. One LLM call. 999 cache hits.
+Lemma puts a shared semantic brain between your agents. When any agent solves something, every other agent gets that answer for free — even if they phrase the question differently.
+
+---
+
+## How it works
 
 ```
-1,000 users ask about "chicken recipes" → 1 LLM call + 999 cache hits → $4/day
+Agent A ──┐
+Agent B ──┤──► SubconsciousHub ──► Semantic Cache (ChromaDB + embeddings)
+Agent C ──┘         │
+                     └──► Agent Registry + Capability Routing
 ```
 
+1. Agents connect via WebSocket and register their capabilities
+2. Every task request hits the semantic cache first
+3. On a miss, the hub routes to a capable agent and stores the result
+4. On a hit, the response returns in ~20ms — no agent invoked, no LLM called
+
+The cache is semantic, not exact. "fibonacci up to n=10" and "compute fibonacci(10)" resolve to the same cached answer.
+
 ---
 
-## Install
+## Quick start
+
+### 1. Install and setup dependencies
 
 ```bash
-npm install lemma
+npm install @nxuss/lemma
+
+# For semantic mode (optional, lightweight embeddings):
+npm install @xenova/transformers
+
+# For persistent storage with ChromaDB (optional):
+pip install chromadb
+chroma run --path ./chroma_data --port 8000
+
+# For ChromaDB embeddings (optional):
+ollama pull nomic-embed-text
 ```
 
-No config. No server. No Docker. Works in any Node.js project.
+### 2. Choose your mode
 
----
+#### Option A: Semantic Mode (Recommended) ⚡
 
-## Quick start
+Zero external dependencies, true semantic matching:
 
 ```typescript
-import { Lemma } from 'lemma/embed';
+import { Lemma } from '@nxuss/lemma/embed';
 
-const lemma = await Lemma.create();
+const lemma = await Lemma.create({
+  storage: 'semantic',  // Uses transformers.js
+  threshold: 0.85,      // Similarity threshold
+});
 
-const getAnswer = lemma.wrap(async (question: string) => {
-  return await llm.chat.completions.create({
-    model: 'gpt-4o-mini',
-    messages: [{ role: 'user', content: question }],
-  });
+const cachedLLM = lemma.wrap(async (query: string) => {
+  return await yourLLMCall(query);
 });
 
-const r1 = await getAnswer('what is the capital of France?');
-console.log(r1.fromCache); // false — first call
+await cachedLLM('weather in San Francisco');  // Calls LLM
+await cachedLLM('SF weather forecast');        // Cache HIT! ⚡
+await cachedLLM('San Francisco temperature');  // Cache HIT! ⚡
+```
+
+#### Option B: Memory Mode (Fastest)
+
+Exact matching, zero dependencies:
 
-const r2 = await getAnswer('capital city of France?');
-console.log(r2.fromCache); // true — ⚡ 0ms, $0
+```typescript
+const lemma = await Lemma.create({
+  storage: 'memory',  // Default, exact match only
+});
 ```
 
-### Drop into an existing Express app
+#### Option C: Server Mode (Multi-Agent)
+
+#### Option C: Server Mode (Multi-Agent)
+
+For multi-agent orchestration:
 
 ```typescript
-// Before — every request hits your LLM
-app.post('/api/chat', async (req, res) => {
-  const response = await llm.chat.completions.create({ ... });
-  res.json(response);
+import { SubconsciousHub } from '@nxuss/lemma';
+
+const hub = new SubconsciousHub({ 
+  server: { port: 8080 } 
 });
 
-// After — 3 lines changed, 70% fewer LLM calls
-import { Lemma } from 'lemma/embed';
-const lemma = await Lemma.create();
-const cachedChat = lemma.wrap((msg: string) => llm.chat.completions.create({ ... }));
+await hub.start();
+console.log('WebSocket hub listening on ws://localhost:8080');
+```
+
+### 3. Connect agents (Server Mode)
+
+```typescript
+import WebSocket from 'ws';
+
+const ws = new WebSocket('ws://localhost:8080');
+
+ws.on('open', () => {
+  // Register with the hub
+  ws.send(JSON.stringify({
+    type: 'handshake',
+    messageId: `msg-${Date.now()}`,
+    timestamp: Date.now(),
+    payload: {
+      agentId: 'my-agent-001',
+      capabilities: [{ name: 'code-generation', description: 'Writes code', version: '1.0.0' }],
+      metadata: { version: '1.0.0' }
+    }
+  }));
+});
 
-app.post('/api/chat', async (req, res) => {
-  const result = await cachedChat(req.body.message);
-  res.json(result.data);
+ws.on('message', (data) => {
+  const msg = JSON.parse(data.toString());
+
+  if (msg.type === 'handshake_ack') {
+    // Connected — send a task
+    ws.send(JSON.stringify({
+      type: 'task_request',
+      messageId: `msg-${Date.now()}`,
+      timestamp: Date.now(),
+      payload: {
+        taskId: `task-${Date.now()}`,
+        taskType: 'general',
+        description: 'Implement binary search in Python',
+        requiredCapabilities: ['code-generation'],
+        parameters: {}
+      }
+    }));
+  }
+
+  if (msg.type === 'task_response' || msg.type === 'TASK_RESPONSE') {
+    const { cached, executionTime, result } = msg.payload;
+    console.log(cached ? `⚡ Cache hit (${executionTime}ms)` : `🔄 Computed (${executionTime}ms)`);
+    console.log(result);
+  }
+
+  if (msg.type === 'task_assign') {
+    // Hub routed a task to us — process and respond
+    const { taskId, description } = msg.payload;
+    const result = yourLLM(description); // your actual LLM call
+    ws.send(JSON.stringify({
+      type: 'task_response',
+      messageId: `msg-${Date.now()}`,
+      timestamp: Date.now(),
+      payload: { taskId, success: true, result, executionTime: 1200, tokensUsed: 800 }
+    }));
+  }
 });
 ```
 
+### 4. See it in action
+
+When multiple agents request similar tasks, you'll see the cache working:
+
+```
+[agent-001] 🔄 COMPUTED  - Calculate fibonacci(10)... (1000ms)
+[agent-002] ⚡ CACHE HIT - compute the 10th fibonacci... (20ms)
+[agent-003] ⚡ CACHE HIT - fibonacci sequence up to n=10... (22ms)
+```
+
+**Result:** 100% cache hit rate after first computation. ~20ms responses. Zero duplicate LLM calls.
+
 ---
 
-## Storage modes
+## What's inside
+
+### Embedded Mode — Zero-config semantic cache
 
-### `memory` — Zero dependencies (default)
+The simplest way to add semantic caching to any project:
 
 ```typescript
-const lemma = await Lemma.create();
+import { Lemma } from '@nxuss/lemma/embed';
+
+const lemma = await Lemma.create({
+  storage: 'semantic',  // or 'memory', 'chroma', 'cloud'
+  threshold: 0.85,
+  ttl: 3600000,         // 1 hour
+  cleanupInterval: 60000, // Auto-cleanup every minute
+  enableFallback: true,  // Auto-fallback on failures
+});
+
+// Wrap any async function
+const cached = lemma.wrap(yourExpensiveFunction);
+
+// Use it
+const result = await cached('your input');
+console.log(result.fromCache); // true on cache hit
 ```
 
-- In-process, no external services
-- Exact string matching (normalized)
-- Resets on restart
-- Best for: development, low-traffic apps, getting started
+**Features:**
+- **Semantic matching** with lightweight embeddings (transformers.js)
+- **Automatic TTL cleanup** prevents memory leaks
+- **Circuit breaker** with automatic fallbacks (Cloud → Chroma → Memory)
+- **Health monitoring** with detailed metrics
+- **Graceful shutdown** with `lemma.stop()`
+
+**Storage options:**
+- `memory`: Exact match, zero dependencies, fastest
+- `semantic`: True semantic matching, lightweight (50MB)
+- `chroma`: Persistent semantic cache (requires ChromaDB)
+- `cloud`: Managed cache (requires API key)
+
+### SubconsciousHub — the orchestration layer
 
-### `chroma` — Persistent semantic cache
+The core of Lemma. A WebSocket server that manages agent connections, routes tasks by capability, and maintains the shared semantic cache.
 
 ```typescript
-const lemma = await Lemma.create({
-  storage: 'chroma',
-  threshold: 0.90,
-});
+import { SubconsciousHub } from '@nxuss/lemma';
+
+const hub = new SubconsciousHub({ server: { port: 8080 } });
+await hub.start();
+```
+
+**What it handles:**
+- Agent registration and capability discovery
+- Semantic cache lookup before every task (ChromaDB + `nomic-embed-text` embeddings)
+- Task routing to capable agents on cache miss
+- Response storage for future cache hits
+- WebSocket heartbeat and connection lifecycle
+- Rate limiting and message sanitization
+
+### Semantic cache — the shared memory
+
+Built on ChromaDB with Ollama embeddings. Catches paraphrases, not just exact matches.
+
+```
+"fibonacci up to n=10"          ──► cache hit (similarity: 0.97)
+"compute the 10th fibonacci"    ──► cache hit (similarity: 0.91)
+"fib sequence, first 10 terms"  ──► cache hit (similarity: 0.88)
 ```
 
-- Persists across restarts
-- True semantic matching via vector embeddings — catches paraphrases, typos, language variations
-- Requires ChromaDB + Ollama running locally
-- Best for: production apps where users rephrase the same questions
+Threshold is configurable (`SEMANTIC_THRESHOLD=0.85` by default).
 
-> **Note:** The "chicken and rice" → "rice with chicken" magic only works in `chroma` mode.  
-> Memory mode does exact normalized matching only.
+### Consensus engine — multi-model voting
 
-### `cloud` — Managed, zero infra
+For high-stakes decisions, route a query through multiple models and only return when they agree.
 
 ```typescript
-const lemma = await Lemma.create({
-  storage: 'cloud',
-  apiKey: 'lk_live_your_key_here',
+import { ConsensusEngine } from '@nxuss/lemma';
+
+const consensus = new ConsensusEngine({
+  minModels: 3,
+  minAgreement: 0.90,
+  maxRounds: 3,
+});
+
+const result = await consensus.requestConsensus({
+  query: 'Is this SQL query safe to run in production?',
+  models: ['llama3', 'gpt-4', 'claude-3'],
 });
+// Returns only when 3 models agree ≥90%
 ```
 
-- No ChromaDB, no Ollama, no servers
-- Persistent semantic cache hosted for you
-- Works in serverless (Vercel, AWS Lambda, Cloudflare Workers)
-- Get your key at [lemma.dev](https://lemma.dev)
+Supports Ollama (local), OpenAI, Anthropic, and Google models simultaneously.
 
 ---
 
-## API
+## New in v0.2.0 🎉
+
+### 1. Semantic Memory Backend
 
-### `Lemma.create(config?)`
+True semantic caching without external dependencies:
 
 ```typescript
 const lemma = await Lemma.create({
-  storage: 'memory' | 'chroma' | 'cloud', // default: 'memory'
-  threshold: 0.92,                         // similarity cutoff (0–1)
-  apiKey: 'lk_live_...',                   // required for cloud mode
-  debug: false,                            // log hits/misses
-  ttl: 0,                                  // cache TTL in ms (0 = forever)
-  maxSize: 10000,                          // max entries (memory mode)
+  storage: 'semantic',
+  embeddingModel: 'Xenova/all-MiniLM-L6-v2', // Lightweight!
 });
+
+// These all match semantically:
+await lemma.run('weather in SF', fetchWeather);
+await lemma.run('San Francisco weather', fetchWeather); // HIT!
+await lemma.run('SF temperature forecast', fetchWeather); // HIT!
 ```
 
-### `lemma.wrap(fn)`
+### 2. Automatic TTL Cleanup
 
-Wraps any async function. Uses the first argument as the cache key.
+No more memory leaks from expired entries:
 
 ```typescript
-const cached = lemma.wrap(async (input: string, ...rest) => {
-  return await someExpensiveCall(input, ...rest);
+const lemma = await Lemma.create({
+  ttl: 3600000,          // 1 hour expiry
+  cleanupInterval: 60000, // Check every minute
 });
 
-const result = await cached('my query');
-// result.data       — the actual response
-// result.fromCache  — true if served from cache
-// result.similarity — how similar to the cached entry (0–1)
-// result.latencyMs  — total time including cache lookup
+// Expired entries are automatically removed
+// No manual cleanup needed!
 ```
 
-### `lemma.run(input, fn)`
+### 3. Circuit Breaker & Fallbacks
 
-Manual control — check cache first, run function on miss.
+Automatic resilience when backends fail:
 
 ```typescript
-const result = await lemma.run(
-  userMessage,
-  () => llm.chat.completions.create({ ... })
-);
-
-if (result.fromCache) {
-  console.log(`Saved an API call! Similarity: ${result.similarity}`);
-}
-```
+const lemma = await Lemma.create({
+  storage: 'cloud',
+  enableFallback: true,  // Auto-fallback on failure
+  maxRetries: 3,
+  retryDelay: 1000,
+});
 
-### `lemma.get(input)` / `lemma.set(input, data)`
+// If cloud fails → falls back to chroma
+// If chroma fails → falls back to memory
+// Automatic recovery when backend comes back
 
-Direct cache access.
+lemma.on('backend-degraded', ({ from, to }) => {
+  console.log(`Degraded: ${from} → ${to}`);
+});
 
-```typescript
-const cached = await lemma.get('what is machine learning?');
-if (!cached) {
-  const data = await callYourLLM(...);
-  await lemma.set('what is machine learning?', data);
-}
+lemma.on('backend-recovered', ({ backend }) => {
+  console.log(`Recovered: ${backend}`);
+});
 ```
 
-### `lemma.getMetrics()`
+### 4. Enhanced Metrics & Health Monitoring
 
 ```typescript
 const metrics = lemma.getMetrics();
+console.log(metrics);
 // {
-//   hits: 847,
-//   misses: 153,
-//   total: 1000,
-//   hitRate: 0.847,
-//   avgLatencyMs: 12,
-//   cacheSize: 153
+//   hits: 150,
+//   misses: 50,
+//   hitRate: 0.75,
+//   backendHealth: 'healthy',
+//   failureCount: 0,
+//   evictedCount: 23,
+//   lastCleanupAt: 1234567890
 // }
-```
 
----
+const health = lemma.getBackendHealth();
+console.log(health);
+// {
+//   state: 'CLOSED',
+//   currentBackend: 'semantic',
+//   failureCount: 0,
+//   totalFailures: 0
+// }
+```
 
-## Who this is for
+### 5. Dual Module Support (ESM + CJS)
 
-Lemma pays off fast if your app has any of these:
+```typescript
+// ESM
+import { Lemma } from '@nxuss/lemma/embed';
+import { ConsensusEngine } from '@nxuss/lemma/consensus';
+import { SpeculativeEngine } from '@nxuss/lemma/speculative';
+
+// CJS
+const { Lemma } = require('@nxuss/lemma/embed');
+const { ConsensusEngine } = require('@nxuss/lemma/consensus');
+```
 
-- **Repetitive user queries** — support bots, FAQ assistants, recipe/travel/fitness apps. Users ask the same things in different words constantly.
-- **Multiple services calling the same LLM** — if 3 microservices independently ask similar questions, you're paying 3x. Lemma centralizes the cache.
-- **LangChain or CrewAI pipelines** — agents in a pipeline often re-derive the same context. Lemma short-circuits that.
-- **High-volume, cost-sensitive apps** — if your LLM bill is already noticeable, the ROI is immediate.
+**New exports:**
+- `@nxuss/lemma/consensus` - Multi-model consensus
+- `@nxuss/lemma/speculative` - Speculative execution
+- `@nxuss/lemma/security` - Security utilities
+- `@nxuss/lemma/protocol` - IAP protocol
+- `@nxuss/lemma/langchain` - LangChain SDK
+- `@nxuss/lemma/crewai` - CrewAI SDK
 
-### Real hit rates by app type
+See [MIGRATION_GUIDE.md](docs/MIGRATION_GUIDE.md) for upgrade instructions.
 
-| App type | Avg hit rate | Savings on 50k req/mo |
-|---|---|---|
-| Customer support chatbot | 85% | ~$340/mo |
-| Recipe / food suggestions | 78% | ~$180/mo |
-| Location / places search | 82% | ~$290/mo |
-| Code assistant | 65% | ~$120/mo |
+---
 
-*Based on gpt-4o-mini pricing at $0.002/1k tokens, avg 800 tokens/request.*
+## Install
 
----
+```bash
+npm install @nxuss/lemma
+```
 
-## For teams building multi-agent systems
+**Optional dependencies (install as needed):**
 
-If you're past the single-app use case and building systems where multiple AI agents collaborate, Lemma ships a full orchestration layer on top of the cache.
+```bash
+# For semantic mode (lightweight embeddings)
+npm install @xenova/transformers
 
-```typescript
-import { SubconsciousHub } from 'lemma';
+# For persistent storage with ChromaDB
+pip install chromadb
+chroma run --path ./chroma_data --port 8000
 
-const hub = new SubconsciousHub({ server: { port: 8080 } });
-await hub.start();
-// Agents connect via WebSocket and share a semantic cache
+# For ChromaDB embeddings
+ollama pull nomic-embed-text
 ```
 
-What this adds:
+**Zero dependencies required** for basic memory mode!
 
-- **WebSocket server** — persistent agent connections with heartbeat
-- **Agent registry** — dynamic capability discovery and routing
-- **Shared semantic cache** — all agents benefit from each other's work
-- **Consensus engine** — multi-model voting for high-stakes decisions
-- **Speculative execution** — pre-compute likely next requests
-- **Security middleware** — API key auth, rate limiting, message sanitization
+---
 
-This layer is designed for teams already running LangChain, CrewAI, or custom agent frameworks who need coordination and shared memory across agents. See [docs/](./docs/) for the full architecture guide.
+## Configuration
+
+```bash
+# .env
+WS_PORT=8080
+CHROMA_HOST=http://localhost
+CHROMA_PORT=8000
+OLLAMA_HOST=http://localhost:11434
+OLLAMA_MODEL=nomic-embed-text
+SEMANTIC_THRESHOLD=0.85   # similarity cutoff (0–1)
+ENABLE_CACHING=true
+AUTH_ENABLED=false        # set true in production
+```
 
 ---
 
-## Self-hosting the cloud server
+## Examples & Documentation
 
-```bash
-# 1. Build
-npm run build
+For complete examples including:
+- Single agent setup
+- Multi-agent swarms
+- Consensus voting
+- Security & authentication
+- LangChain/CrewAI integration
 
-# 2. Deploy to any VPS
-./scripts/deploy-cloud.sh YOUR_SERVER_IP
+Visit [lemma.nxus.studio/docs](https://lemma.nxus.studio/docs)
 
-# 3. Generate an API key
-curl -X POST http://YOUR_SERVER_IP:3100/admin/keys \
-  -H 'X-Admin-Secret: YOUR_ADMIN_SECRET' \
-  -H 'Content-Type: application/json' \
-  -d '{"tenantId": "user1", "name": "My Project", "plan": "pro"}'
+---
 
-# 4. Use it
-const lemma = await Lemma.create({
-  storage: 'cloud',
-  apiKey: 'lk_live_...',
-  cloudUrl: 'http://YOUR_SERVER_IP:3100',
-});
-```
+## Who this is for
+
+- Teams running **LangChain, CrewAI, or custom agent frameworks** who need shared memory across agents
+- Systems where **multiple agents handle overlapping queries** — support bots, research pipelines, code assistants
+- Anyone whose **LLM bill scales with agent count** rather than unique queries
 
-Requirements: Docker, ChromaDB, Ollama with `nomic-embed-text`.
+Lemma is designed for multi-agent systems where coordination and shared memory provide immediate value.
 
 ---
 
-## Pricing
+## Production deployment
 
-| | Free | Pro | Scale |
-|---|---|---|---|
-| Requests/day | 1,000 | 100,000 | Unlimited |
-| Semantic matching | ✅ | ✅ | ✅ |
-| Persistent cache | ✅ | ✅ | ✅ |
-| Savings dashboard | ✅ | ✅ | ✅ |
-| Price | $0 | $29/mo | $99/mo |
+Lemma can be deployed to any Node.js hosting environment. For production setup guides including:
+- Docker deployment
+- API key management
+- Security configuration
+- Monitoring & observability
 
-[Get your API key →](https://lemma.dev)
+Visit [lemma.nxus.studio/docs/deployment](https://lemma.nxus.studio/docs/deployment)
+
+---
+
+## Cloud hosting (coming soon)
+
+Managed Lemma instances with zero infrastructure setup. Check pricing and availability at [lemma.nxus.studio](https://lemma.nxus.studio)
 
 ---
 
 ## Contributing
 
-```bash
-git clone https://github.com/Nxusbets/lemma.git
-cd lemma
-npm install
-npm run build     # compile TypeScript
-npm test          # run tests
-npm run dev       # start the orchestration server
-```
+Contributions are welcome! For development setup and guidelines, visit [lemma.nxus.studio](https://lemma.nxus.studio)
 
 ---
 
 ## License
 
-MIT © [Nxus Studio](https://github.com/Nxusbets)
+MIT © [Nxus Studio](https://nxus.studio)

package/dist/cjs/cloud/KeyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyManager.d.ts","sourceRoot":"","sources":["../../../src/cloud/KeyManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAAE,MAAM,EAAe,MAAM,SAAS,CAAC;AAE9C,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAA+B;gBAEpC,SAAS,SAAqB;IAO1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,CAAU,GAAG,MAAM;IAkB/E,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IA4B1E,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAUlC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO;IAQzD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAQ9B,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAIvC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMtC,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,IAAI;IAWZ,OAAO,CAAC,IAAI;CAYb"}