@ruvector/ruvllm 2.4.1 → 2.5.0

package/README.md

@@ -1,42 +1,6 @@
-<div align="center">
+# @ruvector/ruvllm v2.3
 
-# @ruvector/ruvllm
-
-### The First Purpose-Built LLM Runtime for Claude Code Agent Orchestration
-
-**100% Routing Accuracy | Sub-Millisecond Inference | Self-Learning**
-
-[![npm](https://img.shields.io/npm/v/@ruvector/ruvllm)](https://www.npmjs.com/package/@ruvector/ruvllm)
-[![Downloads](https://img.shields.io/npm/dm/@ruvector/ruvllm)](https://www.npmjs.com/package/@ruvector/ruvllm)
-[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-145%20passing-brightgreen)](./test)
-
-[Quick Start](#quick-start) | [RLM](#rlm-recursive-language-model) | [Training](#training) | [Models](#models) | [API](#api-reference)
-
-</div>
-
----
-
-## What is @ruvector/ruvllm?
-
-**@ruvector/ruvllm** is a TypeScript/JavaScript SDK for intelligent LLM orchestration, specifically designed for **Claude Code** and multi-agent systems. It provides:
-
-- **RLM (Recursive Language Model)** - Break complex queries into sub-queries, synthesize coherent answers
-- **100% Routing Accuracy** - Hybrid keyword + embedding strategy for perfect agent selection
-- **SONA Self-Learning** - Model improves with every successful interaction
-- **SIMD Acceleration** - AVX2/NEON optimized inference
-
-### Why @ruvector/ruvllm?
-
-| Challenge | Traditional Approach | @ruvector/ruvllm Solution |
-|-----------|---------------------|---------------------------|
-| Agent selection | Manual or keyword-based | Semantic + keyword hybrid = **100%** |
-| Complex queries | Single-shot RAG | Recursive decomposition + synthesis |
-| Response latency | 2-5 seconds | **<1ms** cache, 50-200ms full |
-| Learning | Static models | **Self-improving** (SONA) |
-| Cost per route | $0.01+ (API call) | **$0** (local inference) |
-
----
+Self-learning LLM orchestration with SONA adaptive learning, HNSW memory, and SIMD inference for Node.js.
 
 ## Installation
 
@@ -47,444 +11,240 @@ npm install @ruvector/ruvllm
 ## Quick Start
 
 ```typescript
-import { RuvLLM, RlmController } from '@ruvector/ruvllm';
+import { RuvLLM, RuvLLMConfig } from '@ruvector/ruvllm';
+
+// Initialize with default configuration
+const llm = new RuvLLM();
 
-// Simple LLM inference
+// Or with custom configuration
 const llm = new RuvLLM({
-  modelPath: '~/.ruvllm/models/ruvltra-claude-code-0.5b-q4_k_m.gguf',
+  modelPath: './models/ruvltra-small-q4km.gguf',
   sonaEnabled: true,
+  flashAttention: true,
+  maxTokens: 256,
 });
 
+// Generate text
 const response = await llm.query('Explain quantum computing');
 console.log(response.text);
 
-// Recursive Language Model for complex queries
-const rlm = new RlmController({ maxDepth: 5 });
-const answer = await rlm.query('What are the causes AND solutions for slow API responses?');
-// Automatically decomposes into sub-queries, retrieves context, synthesizes answer
+// Stream generation
+for await (const token of llm.stream('Write a haiku about Rust')) {
+  process.stdout.write(token);
+}
 ```
 
----
-
-## Core Features
-
-### 1. Claude Code Native Routing
-
-Built **by** Claude Code, **for** Claude Code. Routes tasks to 60+ agent types:
+## What's New in v2.3
 
-```typescript
-import { RuvLLM } from '@ruvector/ruvllm';
-
-const llm = new RuvLLM({ model: 'ruv/ruvltra' });
-
-// Intelligent routing
-const route = await llm.route('implement OAuth2 authentication');
-console.log(route.agent);      // 'security-architect'
-console.log(route.confidence); // 0.98
-console.log(route.tier);       // 2 (Haiku-level complexity)
-
-// Multi-agent teams for complex tasks
-const team = await llm.routeComplex('build full-stack app with auth');
-// Returns: [system-architect, backend-dev, coder, security-architect, tester]
-```
+| Feature | Description |
+|---------|-------------|
+| **RuvLTRA Models** | Purpose-built 0.5B & 3B models for Claude Flow |
+| **Task-Specific LoRA** | 5 pre-trained adapters (coder, researcher, security, architect, reviewer) |
+| **HuggingFace Hub** | Download/upload models directly |
+| **Adapter Merging** | TIES, DARE, SLERP strategies |
+| **HNSW Routing** | 150x faster semantic matching |
+| **Evaluation Harness** | SWE-Bench testing with 5 ablation modes |
+| **Auto-Dimension** | HNSW auto-detects model embedding size |
+| **mistral-rs Backend** | Production serving with PagedAttention, X-LoRA, ISQ (5-10x concurrent users) |
 
-### 2. 3-Tier Intelligent Routing
+## CLI Usage
 
-```
-┌─────────────────────────────────────────────────────────┐
-│                    User Request                         │
-└─────────────────────┬───────────────────────────────────┘
-                      ↓
-              [RuvLTRA Routing]
-                      ↓
-        ┌─────────────┼─────────────┐
-        ↓             ↓             ↓
-┌───────────┐  ┌───────────┐  ┌───────────┐
-│  Tier 1   │  │  Tier 2   │  │  Tier 3   │
-│  Booster  │  │   Haiku   │  │   Opus    │
-│   <1ms    │  │  ~500ms   │  │   2-5s    │
-│    $0     │  │  $0.0002  │  │  $0.015   │
-└───────────┘  └───────────┘  └───────────┘
-```
+```bash
+# Query a model
+ruvllm query "What is machine learning?"
 
-### 3. Self-Learning (SONA)
+# Stream output
+ruvllm query --stream "Write a poem"
 
-Every successful interaction improves the model:
+# Download a model
+ruvllm download ruvector/ruvltra-small-q4km
 
-```typescript
-// First routing: Full inference
-llm.route('implement OAuth2') → security-architect (97%)
+# Benchmark
+ruvllm bench ./models/model.gguf
 
-// Later: Pattern hit in <25μs (learned from success)
-llm.route('add OAuth2 flow') → security-architect (99%, cached pattern)
+# Run evaluation (SWE-Bench)
+ruvllm eval --model ./models/model.gguf --subset lite --max-tasks 50
 ```
 
----
-
-## RLM (Recursive Language Model)
-
-RLM provides **recursive query decomposition** - unlike traditional RAG that retrieves once, RLM breaks complex questions into sub-queries and synthesizes coherent answers.
-
-### How It Works
-
-```
-Query: "What are the causes AND solutions for slow API responses?"
-                              ↓
-                    [Decomposition]
-                    /            \
-    "Causes of slow API?"    "Solutions for slow API?"
-           ↓                        ↓
-    [Sub-answers]            [Sub-answers]
-           \                        /
-                    [Synthesis]
-                         ↓
-            Coherent combined answer with sources
-```
+## API Reference
 
-### Basic Usage
+### RuvLLM Class
 
 ```typescript
-import { RlmController } from '@ruvector/ruvllm';
+class RuvLLM {
+  constructor(config?: RuvLLMConfig);
 
-const rlm = new RlmController({
-  maxDepth: 5,
-  retrievalTopK: 10,
-  enableCache: true,
-});
+  // Generate text
+  query(prompt: string, params?: GenerateParams): Promise<Response>;
 
-// Add knowledge to memory
-await rlm.addMemory('TypeScript adds static typing to JavaScript.');
-await rlm.addMemory('React is a library for building user interfaces.');
+  // Stream generation
+  stream(prompt: string, params?: GenerateParams): AsyncIterable<string>;
 
-// Query with recursive retrieval
-const answer = await rlm.query('What are causes and solutions for type errors in React?');
-console.log(answer.text);           // Comprehensive synthesized answer
-console.log(answer.sources);        // Source attributions
-console.log(answer.qualityScore);   // 0.0-1.0
-console.log(answer.confidence);     // Routing confidence
-```
+  // Load a model
+  loadModel(path: string): Promise<void>;
 
-### Streaming
+  // Get SONA learning stats
+  sonaStats(): SonaStats | null;
 
-```typescript
-for await (const event of rlm.queryStream('Explain machine learning')) {
-  if (event.type === 'token') {
-    process.stdout.write(event.text);
-  } else {
-    console.log('\n\nQuality:', event.answer.qualityScore);
-  }
+  // Adapt on feedback
+  adapt(input: Float32Array, quality: number): void;
 }
 ```
 
-### With Self-Reflection
-
-```typescript
-const rlm = new RlmController({
-  enableReflection: true,
-  maxReflectionIterations: 2,
-  minQualityScore: 0.8,
-});
-
-// Answers are iteratively refined until quality >= 0.8
-const answer = await rlm.query('Complex multi-part technical question...');
-```
-
-### RLM Configuration
+### Configuration
 
 ```typescript
-interface RlmConfig {
-  maxDepth?: number;              // Max recursion depth (default: 3)
-  maxSubQueries?: number;         // Max sub-queries per level (default: 5)
-  tokenBudget?: number;           // Token budget (default: 4096)
-  enableCache?: boolean;          // Enable caching (default: true)
-  cacheTtl?: number;              // Cache TTL in ms (default: 300000)
-  retrievalTopK?: number;         // Memory spans to retrieve (default: 10)
-  minQualityScore?: number;       // Min quality threshold (default: 0.7)
-  enableReflection?: boolean;     // Enable self-reflection (default: false)
-  maxReflectionIterations?: number; // Max reflection loops (default: 2)
+interface RuvLLMConfig {
+  modelPath?: string;       // Path to GGUF model
+  sonaEnabled?: boolean;    // Enable SONA learning (default: true)
+  flashAttention?: boolean; // Use Flash Attention 2 (default: true)
+  maxTokens?: number;       // Max generation tokens (default: 256)
+  temperature?: number;     // Sampling temperature (default: 0.7)
+  topP?: number;            // Top-p sampling (default: 0.9)
 }
 ```
 
----
-
-## Unique Capabilities
-
-### 1. Memory-Augmented Routing
-
-Every successful routing is stored in HNSW-indexed memory for instant recall:
+### Generate Parameters
 
 ```typescript
-// First time: Full inference (~50ms)
-route("implement OAuth2") → security-architect (97% confidence)
-
-// Later: Memory hit (<25μs)
-route("add OAuth2 flow") → security-architect (99% confidence, cached)
+interface GenerateParams {
+  maxTokens?: number;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  repetitionPenalty?: number;
+  stopSequences?: string[];
+}
 ```
 
-### 2. Confidence-Aware Escalation
+## SIMD Module
 
-```typescript
-// Low confidence automatically escalates
-Confidence > 0.9  → Use recommended agent
-Confidence 0.7-0.9 → Use with human confirmation
-Confidence < 0.7  → Escalate to higher tier
-```
-
-### 3. Batch SIMD Operations
+For direct access to optimized SIMD kernels:
 
 ```typescript
 import { simd } from '@ruvector/ruvllm/simd';
 
-// 4x faster vector operations with AVX2/NEON
-const similarity = simd.batchCosineSimilarity(query, targets);
-const attended = simd.flashAttention(q, k, v, scale);
-```
-
-### 4. Zero-Copy Caching
-
-Arc-based string interning for 100-1000x faster cache hits on large responses.
-
----
-
-## Performance
-
-### Benchmarks (M4 Pro)
-
-| Operation | Latency | Throughput |
-|-----------|---------|------------|
-| Query decomposition | 340 ns | 2.9M/s |
-| Cache lookup | 23.5 ns | 42.5M/s |
-| Embedding (384d) | 293 ns | 3.4M/s |
-| Memory search (10k) | 0.4 ms | 2.5K/s |
-| End-to-end routing | <1 ms | 1K+/s |
-| Full RLM query | 50-200 ms | 5-20/s |
-
-### Routing Accuracy
-
-| Strategy | RuvLTRA | Qwen Base | OpenAI |
-|----------|---------|-----------|--------|
-| Embedding Only | 45% | 40% | 52% |
-| Keyword Only | 78% | 78% | N/A |
-| **Hybrid** | **100%** | 95% | N/A |
+// Dot product
+const result = simd.dotProduct(vecA, vecB);
 
-### Test Results
+// Matrix multiplication
+const output = simd.matmul(matrix, vector);
 
-```
-145 tests passing
-  - RLM Controller: 24 tests
-  - Routing Accuracy: 18 tests
-  - Contrastive Training: 15 tests
-  - SIMD Operations: 22 tests
-  - SONA Learning: 19 tests
-  - Memory/HNSW: 21 tests
-  - Benchmarks: 26 tests
-```
-
----
-
-## Models
-
-### HuggingFace Repository
-
-**URL**: [https://huggingface.co/ruv/ruvltra](https://huggingface.co/ruv/ruvltra)
-
-### Available Models
-
-| Model | Size | Purpose | Accuracy |
-|-------|------|---------|----------|
-| **ruvltra-claude-code-0.5b-q4_k_m** | 398 MB | Agent routing | **100%** (hybrid) |
-| ruvltra-small-0.5b-q4_k_m | ~400 MB | Embeddings | - |
-| ruvltra-medium-1.1b-q4_k_m | ~1 GB | Full inference | - |
-
-### Download Models
+// Flash Attention
+const attended = simd.flashAttention(query, key, value, scale);
 
-```typescript
-// Programmatic
-import { downloadModel } from '@ruvector/ruvllm';
-await downloadModel('ruv/ruvltra', { quantization: 'q4_k_m' });
-
-// CLI
-ruvllm download ruv/ruvltra
-```
-
-### Auto-Download
-
-Models are automatically downloaded on first use:
-
-```typescript
-const llm = new RuvLLM({ model: 'ruv/ruvltra' });
-// Downloads to ~/.ruvllm/models/ if not present
+// RMS Normalization
+simd.rmsNorm(hidden, weights, epsilon);
 ```
 
----
-
-## Training
+## Performance (M4 Pro)
 
-### Generate Routing Dataset
+| Operation | Performance |
+|-----------|-------------|
+| Inference | 88-135 tok/s |
+| Flash Attention | 320µs (seq=2048) |
+| HNSW Search | 17-62µs |
+| SONA Adapt | <1ms |
+| Evaluation | 5 ablation modes |
 
-```bash
-node scripts/training/routing-dataset.js
-# Output: 381 examples, 793 contrastive pairs, 156 hard negatives
-```
+## Evaluation Harness
 
-### Contrastive Fine-tuning
+Run model evaluations with SWE-Bench integration:
 
 ```typescript
-import { ContrastiveTrainer } from '@ruvector/ruvllm';
+import { RuvLLM, EvaluationHarness, AblationMode } from '@ruvector/ruvllm';
 
-const trainer = new ContrastiveTrainer({
-  modelPath: './models/base.gguf',
-  loraRank: 8,
-  loraAlpha: 16,
-  learningRate: 1e-4,
+const harness = new EvaluationHarness({
+  modelPath: './models/model.gguf',
+  enableHnsw: true,
+  enableSona: true,
 });
 
-const pairs = [
-  { anchor: 'Fix auth bug', positive: 'coder', negative: 'researcher' },
-  // ... more pairs
-];
-
-await trainer.train(pairs, { epochs: 10 });
-await trainer.save('./adapters/routing-lora');
-```
-
-### Training Scripts
-
-| Script | Description |
-|--------|-------------|
-| `routing-dataset.js` | Generate 381 routing examples |
-| `claude-code-synth.js` | Synthetic data generation |
-| `contrastive-finetune.js` | LoRA fine-tuning pipeline |
-| `rlm-dataset.js` | RLM training data (500 examples) |
-
----
-
-## API Reference
-
-### RuvLLM Class
-
-```typescript
-class RuvLLM {
-  constructor(config?: RuvLLMConfig);
-
-  query(prompt: string, params?: GenerateParams): Promise<Response>;
-  stream(prompt: string, params?: GenerateParams): AsyncIterable<string>;
-  route(task: string): Promise<RoutingResult>;
-  routeComplex(task: string): Promise<AgentTeam[]>;
-
-  loadModel(path: string): Promise<void>;
-  addMemory(text: string, metadata?: object): number;
-  searchMemory(query: string, topK?: number): MemoryResult[];
+// Run single evaluation
+const result = await harness.evaluate(
+  'Fix the null pointer exception',
+  'def process(data): return data.split()',
+  AblationMode.Full
+);
 
-  sonaStats(): SonaStats | null;
-  adapt(input: Float32Array, quality: number): void;
-}
-```
+console.log(`Success: ${result.success}, Quality: ${result.qualityScore}`);
 
-### RlmController Class
-
-```typescript
-class RlmController {
-  constructor(config?: RlmConfig, engine?: RuvLLM);
-
-  query(input: string): Promise<RlmAnswer>;
-  queryStream(input: string): AsyncGenerator<StreamToken>;
-
-  addMemory(text: string, metadata?: object): Promise<string>;
-  searchMemory(query: string, topK?: number): Promise<MemorySpan[]>;
-
-  clearCache(): void;
-  getCacheStats(): { size: number; entries: number };
-
-  updateConfig(config: Partial<RlmConfig>): void;
-  getConfig(): Required<RlmConfig>;
+// Run ablation study (Baseline, RetrievalOnly, AdaptersOnly, R+A, Full)
+const report = await harness.runAblationStudy(tasks);
+for (const [mode, metrics] of Object.entries(report.modeMetrics)) {
+  console.log(`${mode}: ${metrics.successRate * 100}% success`);
 }
 ```
 
-### All Exports
-
-```typescript
-import {
-  // Core
-  RuvLLM, RuvLLMConfig,
-
-  // RLM
-  RlmController, RlmConfig, RlmAnswer, MemorySpan, StreamToken,
-
-  // Training
-  RlmTrainer, ContrastiveTrainer, createRlmTrainer,
-  DEFAULT_RLM_CONFIG, FAST_RLM_CONFIG, THOROUGH_RLM_CONFIG,
-
-  // SONA Learning
-  SonaCoordinator, TrajectoryBuilder,
+## mistral-rs Backend (Production Serving)
+
+For production deployments with 10-100+ concurrent users, use the mistral-rs backend:
+
+```typescript
+import { RuvLLM, MistralBackend, PagedAttentionConfig } from '@ruvector/ruvllm';
+
+// Configure for production serving
+const backend = new MistralBackend({
+  // PagedAttention: 5-10x more concurrent users
+  pagedAttention: {
+    blockSize: 16,
+    maxBlocks: 4096,
+    gpuMemoryFraction: 0.9,
+    prefixCaching: true,
+  },
+  // X-LoRA: Per-token adapter routing
+  xlora: {
+    adapters: ['./adapters/coder', './adapters/researcher'],
+    topK: 2,
+  },
+  // ISQ: Runtime quantization
+  isq: {
+    bits: 4,
+    method: 'awq',
+  },
+});
 
-  // LoRA
-  LoraAdapter, LoraManager,
+const llm = new RuvLLM({ backend });
+await llm.loadModel('mistralai/Mistral-7B-Instruct-v0.2');
 
-  // Benchmarks
-  ModelComparisonBenchmark, RoutingBenchmark, EmbeddingBenchmark,
-} from '@ruvector/ruvllm';
+// Serve multiple concurrent requests
+const response = await llm.query('Write production code');
 ```
 
----
-
-## CLI
-
-```bash
-# Route a task
-ruvllm route "add unit tests for auth module"
-# → Agent: tester | Confidence: 0.96 | Tier: 2
+> **Note**: mistral-rs features require the Rust backend with `mistral-rs` feature enabled. Native bindings will use mistral-rs when available.
 
-# Query with streaming
-ruvllm query --stream "Explain machine learning"
+## Supported Models
 
-# Download models
-ruvllm download ruv/ruvltra
-
-# Run benchmarks
-ruvllm bench ./models/model.gguf
-
-# Evaluate (SWE-Bench)
-ruvllm eval --model ./models/model.gguf --subset lite
-```
-
----
+- **RuvLTRA-Small** (494M) - Q4K, Q5K, Q8
+- **RuvLTRA-Medium** (3B) - Q4K, Q5K, Q8
+- **Qwen 2.5** (0.5B-72B)
+- **Llama 3.x** (8B-70B)
+- **Mistral** (7B-22B)
+- **Phi-3** (3.8B-14B)
+- **Gemma-2** (2B-27B)
 
 ## Platform Support
 
 | Platform | Architecture | Status |
 |----------|--------------|--------|
-| macOS | arm64 (M1-M4) | Full support |
-| macOS | x64 | Supported |
-| Linux | x64 | Supported |
-| Linux | arm64 | Supported |
-| Windows | x64 | Supported |
+| macOS | arm64 (M1-M4) | ✅ Full support |
+| macOS | x64 | ✅ Supported |
+| Linux | x64 | ✅ Supported |
+| Linux | arm64 | ✅ Supported |
+| Windows | x64 | ✅ Supported |
 
----
+## Related Packages
 
-## Links
+- [@ruvector/core](https://www.npmjs.com/package/@ruvector/core) - Vector operations
+- [@ruvector/sona](https://www.npmjs.com/package/@ruvector/sona) - SONA learning engine
+- [@ruvector/ruvector](https://www.npmjs.com/package/@ruvector/ruvector) - Full Ruvector SDK
 
-| Resource | URL |
-|----------|-----|
-| **npm** | [npmjs.com/package/@ruvector/ruvllm](https://www.npmjs.com/package/@ruvector/ruvllm) |
-| **HuggingFace** | [huggingface.co/ruv/ruvltra](https://huggingface.co/ruv/ruvltra) |
-| **Crate (Rust)** | [crates.io/crates/ruvllm](https://crates.io/crates/ruvllm) |
-| **Documentation** | [docs.rs/ruvllm](https://docs.rs/ruvllm) |
-| **GitHub** | [github.com/ruvnet/ruvector](https://github.com/ruvnet/ruvector) |
-| **Claude Flow** | [github.com/ruvnet/claude-flow](https://github.com/ruvnet/claude-flow) |
+## Links
 
----
+- [GitHub Repository](https://github.com/ruvnet/ruvector)
+- [API Documentation](https://docs.rs/ruvllm)
+- [Crate (Rust)](https://crates.io/crates/ruvllm)
 
 ## License
 
 MIT OR Apache-2.0
-
----
-
-<div align="center">
-
-**Built for Claude Code. Optimized for agents. Designed for speed.**
-
-[Get Started](#quick-start) | [View on GitHub](https://github.com/ruvnet/ruvector)
-
-</div>

package/dist/cjs/index.d.ts

@@ -62,7 +62,7 @@ export * from './training';
 export * from './contrastive';
 export * from './models';
 export * from './benchmarks';
-export * from './rlm';
+export * from './intelligence';
 export { version, hasSimdSupport } from './native';
 export { RuvLLM as default } from './engine';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,cAAc,SAAS,CAAC;AAGxB,cAAc,UAAU,CAAC;AAGzB,cAAc,QAAQ,CAAC;AAGvB,cAAc,WAAW,CAAC;AAG1B,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC;AAGzB,cAAc,YAAY,CAAC;AAG3B,cAAc,eAAe,CAAC;AAG9B,cAAc,UAAU,CAAC;AAGzB,cAAc,cAAc,CAAC;AAG7B,cAAc,OAAO,CAAC;AAGtB,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,cAAc,SAAS,CAAC;AAGxB,cAAc,UAAU,CAAC;AAGzB,cAAc,QAAQ,CAAC;AAGvB,cAAc,WAAW,CAAC;AAG1B,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC;AAGzB,cAAc,YAAY,CAAC;AAG3B,cAAc,eAAe,CAAC;AAG9B,cAAc,UAAU,CAAC;AAGzB,cAAc,cAAc,CAAC;AAG7B,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}