# Home-Lab AI Server Benchmark Infrastructure Runbook
**Agent Role:** Cautious Server-Admin Agent
**Environment:** 192.168.1.116 | AMD Radeon AI PRO R9700 (32GB VRAM)
**Active Model:** Qwen3.6-35B-A3B-APEX-MTP-I-Balanced.gguf
**Context Window:** 262144
**Infrastructure:** llama-cpp-server-vulkan, Flight Recorder Proxy, ServerTop Dashboard

---

# Operating Principles

As a cautious server-admin agent, all actions must adhere to the following core principles to ensure the stability of the home-lab environment and the integrity of the private data:

1.  **Data Sovereignty & Privacy:** All data remains local. No raw model outputs, SQLite database contents, or Flight Recorder logs are to be transmitted to external endpoints. Screenshots are for internal verification only.
2.  **Least Privilege:** Only perform the minimum necessary actions to resolve a reported issue. If a read-only command provides the answer, do not execute a write command.
3.  **Observability First:** Before making any changes to the configuration (e.g., `max_tokens`, `reasoning_budget`), the current state must be captured via logs, `docker stats`, and the ServerTop dashboard.
4.  **Incrementalism:** Changes must be applied one at a time. Never modify the `docker-compose.yml`, the `config.json`, and the `reasoning_budget` simultaneously. Validate after each change.
5.  **Fail-Safe Rollbacks:** Every modification must be preceded by a "State Snapshot." If a change results in a `finish_reason=length` error or a GPU hang, the system must be reverted to the last known good state (LKGS) immediately.
6.  **Human-in-the-Loop (HITL):** Any action classified as "Medium-Risk" or "Destructive" requires explicit human approval via a confirmation prompt.

---

# Preflight Checks

Before initiating any benchmark run or diagnostic procedure, the following checks must be performed to ensure the environment is stable.

### 1. Network & Connectivity
*   **Command:** `ping -c 4 192.168.1.116`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the host is reachable.
*   **Command:** `curl -I http://192.168.1.116:8181/v1/models`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the Flight Recorder proxy is active and responding.
*   **Command:** `curl -I http://192.168.1.116:8090`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the ServerTop dashboard is accessible.

### 2. Container & Resource Status
*   **Command:** `docker ps --filter "name=llama-cpp-server-vulkan"`
    *   **Risk:** Read-only
    *   **Purpose:** Ensure the inference container is running.
*   **Command:** `docker stats --no-stream`
    *   **Risk:** Read-only
    *   **Purpose:** Check current CPU/Memory/Network usage of the container.
*   **Command:** `df -h /models`
    *   **Risk:** Read-only
    *   **Purpose:** Ensure the SQLite database and model weights have sufficient disk space.

### 3. Model & Configuration Integrity
*   **Command:** `ls -lh /models/Qwen3.6-35B-A3B-APEX-MTP-I-Balanced.gguf`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the model file exists and has the correct size.
*   **Command:** `cat /path/to/config.json | grep -E "context_window|parallel_slots"`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the current configuration matches the intended benchmark parameters.

---

# Safe Inspection Commands

Use these commands to gather telemetry without altering the system state.

| Command | Risk | Description | Expected Output |
| :--- | :--- | :--- | :--- |
| `docker logs --tail 100 llama-cpp-server-vulkan` | Read-only | View the last 100 lines of the inference engine logs. | Look for "Vulkan driver initialized" and "Model loaded" messages. |
| `free -m` | Read-only | Check system-wide RAM availability. | Ensure at least 4GB of system RAM is free for overhead. |
| `ls -R /models` | Read-only | List all files in the model directory. | Verify SQLite database file presence and size. |
| `curl -X GET http://192.168.1.116:8181/v1/chat/completions -d '{"model": "Qwen3.6", "messages": [{"role": "user", "content": "hi"}]}'` | Read-only | Test a minimal inference request through the proxy. | A valid JSON response with a `message` object. |
| `top -b -n 1 | head -n 20` | Read-only | Get a snapshot of the top processes. | Identify if any non-AI processes are hogging CPU/RAM. |

---

# Reasoning Budget Verification

The `reasoning_budget` (currently 8192) is critical for the Qwen3.6 model's internal thought process. If this is misconfigured, the model may truncate its reasoning before reaching the final answer.

### Verification Steps:
1.  **Check Config:** Verify that `--reasoning-budget 8192` is passed in the startup command.
2.  **Log Analysis:** Monitor the logs during a reasoning-heavy task.
    *   **Command:** `docker logs llama-cpp-server-vulkan | grep -i "reasoning"`
    *   **Risk:** Read-only
    *   **Action:** If the logs show the reasoning block ending abruptly, the budget is too low for the complexity of the prompt.
3.  **Budget vs. Context Calculation:**
    *   Ensure `reasoning_budget` + `max_tokens` < `context_window` (262144).
    *   If `reasoning_budget` is 8192, and the model is generating a long response, the `max_tokens` must be high enough to accommodate the *total* output (Reasoning + Final Answer).

---

# Long Output Validation

The observation `finish_reason=length` indicates that the model reached the `max_tokens` limit before completing the final content.

### Diagnostic Procedure:
1.  **Identify Truncation:** Check the JSON response from the Flight Recorder proxy.
    *   **Check:** Does the `content` field end mid-sentence?
    *   **Check:** Is `finish_reason` equal to `"length"`?
2.  **Dynamic Adjustment:**
    *   **Action:** Increase `max_tokens` in the request payload or the global config.
    *   **Validation:** Run a "Long-Output Test" (e.g., "Write a 2000-word essay on quantum mechanics").
    *   **Success Criteria:** `finish_reason` must be `"stop"` or `"abort"`, and the final paragraph must be complete.
3.  **Bulk Validation Rule:**
    *   **Rule:** Never run more than 3 long-output tests in a single batch.
    *   **Action:** Validate each task individually. If Task 1 fails, stop the batch and re-evaluate the `max_tokens` setting.

---

# GPU And VRAM Checks

The AMD Radeon AI PRO R9700 (32GB) is the primary compute resource. Vulkan-based inference is sensitive to memory fragmentation.

### Monitoring Commands:
*   **Command:** `rocm-smi` (if ROCm is installed) or `vulkaninfo`
    *   **Risk:** Read-only
    *   **Purpose:** Check the status of the AMD GPU.
*   **Command:** `docker stats`
    *   **Risk:** Read-only
    *   **Purpose:** Monitor the "MEM USAGE" of the `llama-cpp-server-vulkan` container.
*   **VRAM Thresholds:**
    *   **Warning:** If VRAM usage exceeds 28GB (87% of 32GB), the system is at risk of an OOM (Out of Memory) crash.
    *   **Action:** Reduce `parallel_slots` to 1 or decrease the `context_window` temporarily to stabilize.

---

# Proxy And Database Checks

The Flight Recorder proxy and the local SQLite database are the "Source of Truth" for benchmark results.

### Proxy Verification:
*   **Command:** `curl -v http://192.168.1.116:8181/v1`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the proxy is correctly routing requests.
*   **Troubleshooting:** If the proxy returns a 500 error, check the container logs for "Connection Refused" or "Timeout."

### Database Integrity:
*   **Command:** `sqlite3 /models/benchmarks.db "PRAGMA integrity_check;"`
    *   **Risk:** Read-only
    *   **Purpose:** Ensure the SQLite database is not corrupted.
*   **Privacy Check:** Ensure no `sqlite3` commands are used to export data to external URLs.

---

# Dashboard Checks

The ServerTop dashboard (http://192.168.1.116:8090) provides the visual health of the server.

### Verification Steps:
1.  **Visual Check:** Open the dashboard in a browser.
2.  **Metric Correlation:**
    *   Compare the "GPU Load" on ServerTop with the "MEM USAGE" in `docker stats`.
    *   If ServerTop shows 0% load but the model is not responding, the Vulkan driver has likely hung.
3.  **Action:** If a hang is detected, restart the container:
    *   **Command:** `docker restart llama-cpp-server-vulkan`
    *   **Risk:** Medium-risk (Interrupts active inference).

---

# Failure Triage Trees

Follow these logic paths when a benchmark fails.

### Tree 1: Model Fails to Load (Startup Error)
1.  **Is the container running?**
    *   No $\rightarrow$ Check `docker logs`. Is it a "File Not Found" error? $\rightarrow$ Verify path to `.gguf`.
    .
    *   Yes $\rightarrow$ Is it an "Out of Memory" error? $\rightarrow$ Reduce `context_window` to 131072.
2.  **Is the GPU recognized?**
    *   No $\rightarrow$ Check Vulkan drivers. Reinstall/Update Vulkan runtime.
    *   Yes $\rightarrow$ Check if another process is using the GPU.

### Tree 2: Inference Hangs (No Output)
1.  **Is the Proxy responding?**
    *   No $\rightarrow$ Restart Flight Recorder proxy container.
    *   Yes $\rightarrow$ Is the model generating tokens slowly? $\rightarrow$ Check GPU temperature/clock speeds on ServerTop.
2.  **Is the model stuck in "Reasoning"?**
    *   Yes $\rightarrow$ Check `reasoning_budget`. If budget is too high, the model may be looping. Reduce budget to 4096 and test.
3.  **Final Action:** If all checks pass but no output occurs, restart the `llama-cpp-server-vulkan` container.

### Tree 3: `finish_reason=length` (Truncated Output)
1.  **Is the output significantly shorter than requested?**
    *   Yes $\rightarrow$ Increase `max_tokens` in the request.
2.  **Does increasing `max_tokens` cause an OOM?**
    *   Yes $\rightarrow$ You must reduce `context_window` to free up VRAM for the longer output.
3.  **Does the model repeat itself?**
    *   Yes $\rightarrow$ Check `repeat_penalty` and `temperature` settings.

---

# Rollback Procedures

If a change causes a system-wide failure or persistent benchmark errors, execute the following rollback.

### Step 1: State Snapshot (Pre-change)
Before any modification, the agent must execute:
*   **Command:** `cp /path/to/config.json /path/to/config.json.bak`
*   **Command:** `docker commit llama-cpp-server-vulkan llama-cpp-vulkan-snapshot`
    *   **Risk:** Medium-risk (Creates a container image).

### Step 2: Reversion
1.  **Config Reversion:**
    *   **Command:** `mv /path/to/config.json.bak /path/to/config.json`
2.  **Container Reversion:**
    *   **Command:** `docker stop llama-cpp-server-vulkan && docker rm llama-cpp-server-vulkan`
    *   **Command:** `docker run ... [Use the snapshot image or original compose file]`
3.  **Verification:** Run the "Preflight Checks" section to ensure the environment is back to the LKGS.

---

# Human Approval Gates

The agent must pause and request human intervention for the following:

1.  **Destructive Actions:** Any command classified as "Destructive" (e.g., `rm`, `docker rm -f`, `sqlite3 .drop`).
2.  **Configuration Changes:** Any change to `context_window`, `parallel_slots`, or `reasoning_budget` that deviates from the baseline by more than 10%.
3.  **Hardware Reset:** Any action requiring a host reboot or a full GPU driver reset.
4.  **Data Modification:** Any command that modifies the SQLite database schema or deletes benchmark records.

**Approval Format:**
> "I am about to perform [Action] because [Reason]. This is a [Risk Level] action. Do you approve?"

---

# Evidence To Capture

When a failure occurs or a fix is applied, the following evidence must be collected for the report.

1.  **Terminal Logs:** Copy the last 50 lines of the `docker logs` output.
2.  **Proxy Response:** A JSON snippet of the failed request (redact any private user content).
3.  **ServerTop Screenshot:** A screenshot of the dashboard showing GPU/CPU/Memory utilization at the moment of failure.
4.  **VRAM Snapshot:** The output of `docker stats` showing the memory footprint.
5.  **Configuration State:** A copy of the `config.json` used during the failed run.

*Note: Ensure no private user prompts or sensitive data are visible in the screenshots provided to the user.*

---

# Final Go No-Go Checklist

Before declaring a benchmark run "Successful" or "Stable," the agent must verify all items:

- [ ] **Preflight:** All network and container checks passed.
- [ ] **GPU:** VRAM usage is stable and below 90% during peak inference.
- [ ] **Reasoning:** The model successfully completes a reasoning block without `finish_reason=length`.
- [ ] **Long Output:** At least one "Long-Output Test" completed with `finish_reason=stop`.
- [ ] **Proxy:** The Flight Recorder proxy is successfully logging all requests.
- [ ] **Database:** The SQLite database is updated with the new benchmark results.
- [ ] **Dashboard:** ServerTop shows no "Critical" alerts or persistent hangs.
- [ ] **Human Approval:** All required gates were cleared by the user.

**Final Status:**
- **GO:** All checks passed. Infrastructure is stable for production benchmarking.
- **NO-GO:** One or more checks failed. Revert to LKGS and initiate Failure Triage Tree.

### Vulkan Driver & Hardware Interface Diagnostics

Because the environment utilizes `llama-cpp-server-vulkan`, the stability of the inference engine is directly tied to the Vulkan runtime and the AMD Radeon AI PRO R9700 driver stack. Unlike CUDA, Vulkan can sometimes suffer from "silent hangs" where the process remains active but the GPU pipeline is stalled.

#### 1. Driver Integrity Verification
*   **Command:** `vulkaninfo | grep -i "deviceName"`
    *   **Risk:** Read-only
    *   **Purpose:** Confirm the Vulkan runtime correctly identifies the AMD Radeon AI PRO R9700.
    *   **Agent Note:** If this command returns an error or shows a generic "Software Rasterizer," the Vulkan drivers are not correctly mapped to the container or host.
*   **Command:** `lsmod | grep amdgpu`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the kernel module is loaded.
    *   **Agent Note:** If the module is missing, the hardware will not be accessible to the inference engine.

#### 2. Memory Mapping & Fragmentation
Vulkan memory management can lead to fragmentation over long-running sessions.
*   **Command:** `docker stats --no-stream`
    *   **Risk:** Read-only
    *   **Action:** Monitor the "MEM USAGE" over a 10-minute period during a long-output test.
    *   **Diagnostic:** If memory usage climbs steadily without plateauing, a memory leak in the Vulkan implementation or the `llama-cpp` wrapper is suspected.
*   **Command:** `dmesg | grep -i "amdgpu" | tail -n 50`
    *   **Risk:** Read-only
    *   **Purpose:** Check for "GPU Hang" or "Ring Timeout" messages in the kernel log.
    *   **Action:** If "Ring Timeout" is detected, a hardware reset or a driver reload is required.

#### 3. Vulkan Layer Inspection
*   **Command:** `export VK_INSTANCE_LAYERS=...` (Check environment variables)
    *   **Risk:** Read-only
    *   **Purpose:** Ensure no conflicting validation layers are active during production inference, as these can significantly degrade performance.

---

### MTP (Multi-Token Prediction) Specific Troubleshooting

The environment uses `--spec-type draft-mtp --spec-draft-n-max 2`. This is a sophisticated inference technique where the model predicts multiple future tokens simultaneously to accelerate generation.

#### 1. Draft Quality Analysis
If the final output is incoherent or "hallucinates" significantly, the draft tokens may be of low quality.
*   **Diagnostic:** Compare the output of a prompt with MTP enabled vs. MTP disabled.
*   **Action:** If MTP causes degradation, reduce `--spec-draft-n-max` to 1 or disable MTP entirely to isolate the issue.

#### 2. Reasoning Budget Interaction
The `reasoning_budget` (8192) and MTP can conflict if the model attempts to "draft" its reasoning steps.
*   **Observation:** If the reasoning block appears to "skip" steps or jump to conclusions, the MTP is likely over-predicting the reasoning tokens.
*   **Fix:** Increase the `reasoning_budget` or switch to a non-draft MTP spec if the model supports it.

#### 3. MTP Latency Monitoring
*   **Command:** `docker logs llama-cpp-server-vulkan | grep -i "tokens_per_second"`
    *   **Risk:** Read-only
    *   **Purpose:** Verify that MTP is actually providing a speedup.
    *   **Agent Note:** If `tokens_per_second` is lower with MTP enabled than with standard inference, the draft-mtp overhead is exceeding the prediction gains.

---

### SQLite Database Management & Integrity

The database on `/models` is the primary repository for benchmark results. Integrity is paramount.

#### 1. Database Health Checks
*   **Command:** `sqlite3 /models/benchmarks.db "PRAGMA integrity_check;"`
    *   **Risk:** Read-only
    *   **Purpose:** Ensure the file structure is intact.
*   **Command:** `sqlite3 /models/benchmarks.db "PRAGMA journal_mode;"`
    *   **Risk:** Read-only
    *   **Purpose:** Verify the journal mode.
    *   **Agent Note:** For high-frequency writes, `WAL` (Write-Ahead Logging) is preferred.

#### 2. Maintenance Procedures
*   **Command:** `sqlite3 /models/benchmarks.db "VACUUM;"`
    *   **Risk:** Medium-risk (Locks the database)
    *   **Purpose:** Rebuild the database file to reclaim unused space and defragment the index.
    *   **Requirement:** Must be performed during a maintenance window when no benchmarks are running.
*   **Command:** `sqlite3 /models/benchmarks.db "REINDEX;"`
    *   **Risk:** Medium-risk
    *   **Purpose:** Rebuild indexes to ensure fast query performance for the Flight Recorder proxy.

#### 3. Backup Protocol
*   **Command:** `sqlite3 /models/benchmarks.db ".backup /models/benchmarks_backup_$(date +%Y%m%d).db"`
    *   **Risk:** Medium-risk
    *   **Purpose:** Create a timestamped backup before any schema changes or bulk deletions.

---

### Log Management & Rotation

To prevent the host from running out of disk space, logs must be managed.

#### 1. Docker Log Limits
*   **Action:** Ensure the `docker-compose.yml` includes:
    ```yaml
    logging:
      driver: "json-file"
      options:
        max-size: "500m"
        max-file: "3"
    ```
*   **Risk:** Low-risk (Configuration change)

#### 2. Flight Recorder Proxy Logs
*   **Command:** `tail -f /path/to/proxy/logs/access.log`
    *   **Risk:** Read-only
    *   **Purpose:** Monitor real-time request flow.
    *   **Agent Note:** Look for 4xx or 5xx errors which indicate proxy-level failures rather than model-level failures.

---

### Benchmark Execution Protocols

To ensure "reliable reporting," benchmarks must be executed in a standardized sequence.

#### Phase 1: Warmup (Cold Start)
*   **Action:** Run a 50-token prompt (e.g., "Hello, how are you?").
*   **Purpose:** Load the model weights into VRAM and initialize the KV cache.
*   **Success Criteria:** Response time < 2 seconds.

#### Phase 2: Single-Turn Inference
*   **Action:** Run 5 standard prompts (e.g., "Summarize this text...", "Write a Python script...").
*   **Purpose:** Establish a baseline for average tokens per second (TPS).

#### Phase 3: Long-Context / Long-Output
*   **Action:** Run 3 prompts requiring > 1000 tokens of output.
*   **Purpose:** Validate the `max_tokens` and `reasoning_budget` configuration.
*   **Validation:** Check `finish_reason` for every single run.

#### Phase 4: Stress Test
*   **Action:** Run 3 concurrent requests (if `parallel_slots` > 1) or a rapid succession of 10 requests.
*   **Purpose:** Check for VRAM exhaustion or thermal throttling.

---

### VRAM & KV Cache Optimization

With 32GB of VRAM and a 262,144 context window, memory management is the most common point of failure.

#### 1. KV Cache Calculation
*   **Formula:** `Memory = (Context_Window * Layers * Heads * Head_Dim * Precision_Bytes)`
*   **Agent Note:** For Qwen3.6-35B, a 262k context window can consume a massive portion of the 32GB VRAM.
*   **Action:** If OOM occurs, reduce `context_window` to 131,072 or 65,536.

#### 2. Flash Attention Verification
*   **Command:** `docker logs llama-cpp-server-vulkan | grep -i "flash_attn"`
    *   **Risk:** Read-only
    *   **Purpose:** Confirm Flash Attention is active.
    *   **Agent Note:** Without Flash Attention, the memory cost of the context window scales quadratically, making 262k context nearly impossible on 32GB VRAM.

#### 3. Batching Strategy
*   **Action:** Keep `parallel_slots` at 1 for long-context tasks.
*   **Action:** Increase `parallel_slots` to 2 or 4 only for short-context, high-throughput tasks.

---

### Flight Recorder Proxy Deep Dive

The proxy at `http://192.168.1.116:8181/v1` acts as the gateway.

#### 1. Timeout Configuration
*   **Issue:** Long-output tests may time out at the proxy level before the model finishes.
*   **Fix:** Increase the `request_timeout` in the proxy configuration to 300 seconds.

#### 2. Header Inspection
*   **Command:** `curl -v -H "X-Benchmark-ID: test_001" http://192.168.1.116:8181/v1/chat/completions`
    *   **Risk:** Read-only
    *   **Purpose:** Verify that custom headers are being passed through to the inference engine.

#### 3. Error Mapping
*   **Error 400:** Invalid JSON or missing `model` parameter.
*   **Error 404:** Model name mismatch in the proxy config.
*   **Error 500:** Inference engine crashed or timed out.
*   **Error 503:** Inference engine is overloaded (too many parallel slots).

---

### Periodic Maintenance & Health Checks

A "cautious" admin performs proactive maintenance to prevent "silent" degradation.

#### Weekly Tasks:
1.  **Log Rotation:** Clear all Docker logs older than 7 days.
2.  **Database Vacuum:** Run `VACUUM` on the SQLite database.
3.  **Driver Check:** Run `vulkaninfo` to ensure no driver updates have broken the mapping.
4.  **VRAM Leak Check:** Monitor `docker stats` during an idle period to ensure memory returns to baseline.

#### Monthly Tasks:
1.  **Model Integrity:** Verify the `.gguf` file hash against the original source.
2.  **Full System Reboot:** Restart the host machine to clear any kernel-level GPU hangs.
3.  **Benchmark Baseline Update:** Update the "Last Known Good State" (LKGS) parameters in the runbook.

---

### User Reporting & Evidence Documentation

The user requires "reliable reporting" and "screenshots."

#### 1. Reporting Template
When a benchmark is completed, the agent must generate a report in the following format:

> **Benchmark Report: [ID]**
> - **Status:** [SUCCESS / FAIL / TRUNCATED]
> - **Model:** Qwen3.6-35B-A3B-APEX-MTP-I-Balanced.gguf
> - **Hardware:** AMD Radeon AI PRO R9700 (32GB VRAM)
> - **Metrics:**
>   - Avg Tokens/Sec: [Value]
>   - Peak VRAM Usage: [Value]
>   - Reasoning Budget Used: [Value]
> - **Issues Encountered:** [Describe any `finish_reason=length` or hangs]
> - **Action Taken:** [Describe any config changes or rollbacks]
> - **Evidence:** [Link to Screenshot/Log Snippet]

#### 2. Screenshot Guidelines
*   **Dashboard:** Capture the ServerTop dashboard showing the GPU load spike.
*   **Logs:** Capture the `docker logs` showing the `finish_reason`.
*   **Privacy:** **CRITICAL.** Ensure no PII (Personally Identifiable Information) or private user prompts are visible in the screenshots. Use a blur tool or crop the image if necessary.

---

### Emergency Shutdown & Recovery

In the event of a catastrophic failure (e.g., host OS becomes unresponsive, GPU "freezes").

#### 1. Soft Restart (Container Only)
*   **Command:** `docker restart llama-cpp-server-vulkan`
    *   **Risk:** Medium-risk
    *   **Purpose:** Restart the inference engine without affecting the host.

#### 2. Hard Restart (Container & Proxy)
*   **Command:** `docker-compose down && docker-compose up -d`
    *   **Risk:** Medium-risk
    *   **Purpose:** Restart the entire stack.

#### 3. GPU Reset (Host Level)
*   **Command:** `echo "1" > /sys/class/gpu/gpu0/reset` (Note: Path varies by driver)
    *   **Risk:** Destructive/High-risk
    *   **Purpose:** Force a hardware reset of the GPU.
    *   **Requirement:** Requires Root/Sudo and Human Approval.

#### 4. Database Recovery
If the SQLite database is corrupted:
1.  **Action:** Restore from the last `.backup` file.
2.  **Action:** Re-run the "Phase 1-3" benchmarks to re-populate the database.

---

### Security & Privacy Hardening

To maintain the "private home-lab" status:

1.  **Local Binding:** Ensure all services (Proxy, ServerTop, Inference) are bound to `127.0.0.1` or the internal `192.168.1.116` IP.
2.  **Firewall:** Use `ufw` or `iptables` to block all incoming traffic from the WAN.
3.  **No External API:** The Flight Recorder proxy must never have an `EXTERNAL_URL` set.
4.  **Data Purge:** Periodically delete benchmark results that are older than 30 days to minimize the local data footprint.

---

### Advanced Configuration Reference Table

Use this table to quickly identify and adjust parameters during troubleshooting.

| Parameter | Default Value | Min Value | Max Value | Impact Area | Agent Note |
| :--- | :--- | :--- | :--- | :--- | :--- |
| `context_window` | 262144 | 1024 | 262144 | VRAM / Accuracy | Lowering this is the fastest way to fix OOM. |
| `parallel_slots` | 1 | 1 | 8 | Throughput | Keep at 1 for long-context/reasoning tasks. |
| `reasoning_budget` | 8192 | 512 | 32768 | Reasoning Quality | If model "loops," lower this value. |
| `max_tokens` | 4096 | 128 | 65536 | Output Length | Increase if `finish_reason=length` occurs. |
| `spec-draft-n-max` | 2 | 1 | 4 | MTP Speed | Reduce to 1 if output becomes incoherent. |
| `temp` | 0.7 | 0.0 | 1.0 | Creativity | Lower to 0.1 for deterministic benchmarks. |
| `repeat_penalty` | 1.1 | 1.0 | 2.0 | Repetition | Increase if model gets stuck in a loop. |
| `top_k` | 50 | 1 | 100 | Sampling | Keep at 50 for balanced performance. |
| `top_p` | 0.9 | 0.0 | 1.0 | Sampling | Keep at 0.9 for balanced performance. |

---

### Agent Reasoning: Final Validation Logic

When the agent completes a diagnostic run, it must perform a final internal "Reasoning Check" before presenting the results to the user:

1.  **Did I solve the root cause?** (e.g., Did I just increase `max_tokens` to hide a `reasoning_budget` issue?)
2.  **Is the system stable?** (Check `docker stats` one last time.)
3.  **Is the data private?** (Verify no external URLs were called.)
4.  **Is the report complete?** (Does it include all required evidence?)

If any of these answers are "No," the agent must re-evaluate the Failure Triage Tree before providing the final answer to the user.

---

### Appendix: Common Error Codes & Meanings

| Error Code | Meaning | Likely Cause | Recommended Action |
| :--- | :--- | :--- | :--- |
| `Vulkan_Error_Out_of_Memory` | VRAM Exhaustion | Context window too large or too many parallel slots. | Reduce `context_window`. |
| `Connection_Refused` | Proxy/Server Down | Container is stopped or port is blocked. | `docker ps` and check firewall. |
| `Finish_Reason_Length` | Truncated Output | `max_tokens` is too low for the prompt. | Increase `max_tokens`. |
| `Finish_Reason_Stop` | Success | Model finished naturally. | No action needed. |
| `Internal_Server_Error` | Engine Crash | GPU hang or driver failure. | Restart container; check `dmesg`. |
| `Database_Locked` | SQLite Concurrency | Multiple processes writing to DB. | Check proxy logs for concurrent writes. |

---

### Final Go No-Go Checklist (Expanded)

Before declaring a benchmark run "Successful" or "Stable," the agent must verify all items:

- [ ] **Preflight:** All network and container checks passed.
- [ ] **GPU:** VRAM usage is stable and below 90% during peak inference.
- [ ] **Reasoning:** The model successfully completes a reasoning block without `finish_reason=length`.
- [ ] **Long Output:** At least one "Long-Output Test" completed with `finish_reason=stop`.
- [ ] **Proxy:** The Flight Recorder proxy is successfully logging all requests.
- [ ] **Database:** The SQLite database is updated with the new benchmark results.
- [ ] **Dashboard:** ServerTop shows no "Critical" alerts or persistent hangs.
- [ ] **Human Approval:** All required gates were cleared by the user.
- [ ] **Data Integrity:** No private data has been leaked to external logs or screenshots.
- [ ] **Rollback Readiness:** A valid `.bak` config and container snapshot exist.

**Final Status:**
- **GO:** All checks passed. Infrastructure is stable for production benchmarking.
- **NO-GO:** One or more checks failed. Revert to LKGS and initiate Failure Triage Tree.

### Model-Specific Nuances: Qwen3.6-35B-A3B-APEX-MTP-I-Balanced.gguf

The active model, Qwen3.6-35B-A3B-APEX-MTP-I-Balanced.gguf, possesses specific architectural characteristics that the agent must account for during benchmark diagnostics.

#### 1. APEX Architecture & VRAM Allocation
The "APEX" (Advanced Parallel Execution) architecture optimizes how the model handles parallel attention heads. In a Vulkan environment, this can sometimes lead to non-linear VRAM scaling.
*   **Observation:** If VRAM usage spikes unexpectedly when increasing `parallel_slots`, it is likely due to the APEX layer's memory pre-allocation.
*   **Action:** Keep `parallel_slots` at 1 during all "Long-Output" and "Reasoning" benchmarks to ensure maximum VRAM availability for the KV cache.

#### 2. MTP (Multi-Token Prediction) Dynamics
The MTP configuration (`--spec-type draft-mtp --spec-draft-n-max 2`) allows the model to predict the next two tokens simultaneously.
*   **Diagnostic:** If the model produces "hallucinated" punctuation or repeated words, the draft tokens are likely diverging from the main path.
*   **Fix:** Reduce `--spec-draft-n-max` to 1. This provides a more conservative but stable prediction path.
*   **Verification:** Compare the "Tokens Per Second" (TPS) with MTP enabled vs. disabled. If the speedup is less than 15%, the overhead of the draft-mtp spec may be counterproductive for the current hardware.

#### 3. "Balanced" Profile Behavior
The "Balanced" profile is tuned for a trade-off between reasoning depth and generation speed.
*   **Reasoning Budget Interaction:** With a `reasoning_budget` of 8192, the model is encouraged to spend significant "thought" cycles.
*   **Agent Note:** If the model produces very long reasoning blocks but fails to produce a final answer, the `reasoning_budget` is being exhausted by the internal thought process, leaving no room for the output. In such cases, increase the budget to 16384 or decrease the complexity of the prompt.

---

### Advanced Vulkan & AMD Driver Troubleshooting

Since the server relies on the AMD Radeon AI PRO R9700 via Vulkan, specific driver-level issues can manifest as "silent" failures.

#### 1. Vulkan ICD (Installable Client Driver) Verification
Sometimes the system may default to a software rasterizer or an incorrect driver profile.
*   **Command:** `ls /usr/share/vulkan/icd.d/`
    *   **Risk:** Read-only
    *   **Purpose:** Verify that the AMD-specific ICD files are present.
*   **Command:** `export VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/amd_icd.x86_64.json` (Example path)
    *   **Risk:** Low-risk (Environment variable)
    *   **Purpose:** Force the system to use the correct AMD driver if multiple are detected.

#### 2. Handling "Device Lost" Errors
A "Device Lost" error in Vulkan usually indicates a hardware hang or a driver crash.
*   **Symptom:** The `llama-cpp-server-vulkan` container suddenly exits with a non-zero code, or the dashboard shows 0% GPU activity while the process is still "running."
*   **Action:**
    1.  Check `dmesg` for "amdgpu: [drm] GPU hang" or "ring timeout."
    2.  If detected, perform a "Hard Restart" (see Rollback Procedures).
    3.  Check the power supply (PSU) and thermal status on the host.

#### 3. VRAM Fragmentation Analysis
Vulkan can suffer from memory fragmentation where large contiguous blocks are unavailable even if total free VRAM is sufficient.
*   **Diagnostic:** If a benchmark fails with "Out of Memory" despite `docker stats` showing 10GB+ free.
*   **Action:** Restart the container to clear the Vulkan memory heap.
*   **Long-term Fix:** Reduce the `context_window` to a smaller power of 2 (e.g., 65536) to allow for more stable memory allocation.

---

### Benchmark Scenario Library

To ensure "reliable reporting," the agent must use a standardized set of test cases. Each test must be validated individually.

| Test ID | Category | Prompt Description | Expected Behavior | Success Criteria |
| :--- | :--- | :--- | :--- | :--- |
| **B-001** | Warmup | "Hello, please acknowledge this message." | Short, fast response. | TPS > 50; No errors. |
| **B-002** | Reasoning | "Solve this logic puzzle: [Complex Logic Puzzle]" | Long reasoning block followed by a clear answer. | `reasoning_budget` used; `finish_reason=stop`. |
| **B-003** | Coding | "Write a Python script to scrape a website using BeautifulSoup." | Correct syntax, comments, and logic. | No truncation; `finish_reason=stop`. |
| **B-004** | Long-Output | "Write a 1500-word historical analysis of the Silk Road." | Continuous, coherent text. | `finish_reason=stop`; No `length` truncation. |
| **B-005** | Context | [Insert 100k tokens of text] + "Summarize the main theme." | Accurate summary of the provided text. | No "hallucination" of missing facts. |
| **B-006** | MTP-Stress | "Generate a 500-word story about a robot in a forest." | Fast generation with coherent narrative. | TPS > 30; No repetition. |
| **B-007** | Multi-Turn | [Simulate 5 turns of conversation] | Maintains context across all turns. | Correct reference to previous turns. |
| **B-008** | Edge-Case | "Write a poem where every word starts with the letter 'S'." | Strict adherence to constraints. | Correct constraint following. |
| **B-009** | Math | "Calculate the 15th Fibonacci number and explain the steps." | Correct math; clear steps. | Correct numerical result. |
| **B-010** | Stress | [Run 3 concurrent requests of B-004] | System remains stable; no OOM. | All 3 finish without crash. |

---

### Log Analysis Deep Dive (Regex & Patterns)

The agent should use the following patterns when scanning `docker logs` to identify specific failure modes.

#### 1. Memory Exhaustion Patterns
*   **Regex:** `.*Out of Memory.*` or `.*malloc failed.*`
*   **Action:** Immediately reduce `context_window` or `parallel_slots`.
*   **Log Command:** `docker logs llama-cpp-server-vulkan | grep -Ei "memory|malloc|oom"`

#### 2. Vulkan/Driver Error Patterns
*   **Regex:** `.*Vulkan error.*` or `.*Device Lost.*` or `.*Timeout.*`
*   **Action:** Check `dmesg` and consider a hardware reset.
*   **Log Command:** `docker logs llama-cpp-server-vulkan | grep -Ei "vulkan|device|timeout|hang"`

#### 3. Inference Logic Patterns
*   **Regex:** `.*finish_reason=length.*`
*   **Action:** Increase `max_tokens` in the request payload.
*   **Log Command:** `docker logs llama-cpp-server-vulkan | grep -i "finish_reason"`

#### 4. MTP Divergence Patterns
*   **Regex:** `.*MTP_divergence.*` or `.*draft_error.*`
*   **Action:** Reduce `--spec-draft-n-max`.
*   **Log Command:** `docker logs llama-cpp-server-vulkan | grep -Ei "mtp|draft|divergence"`

---

### Network Topology & Proxy Latency

The Flight Recorder proxy at `http://192.168.1.116:8181/v1` is the primary interface.

#### 1. Internal Routing Verification
*   **Command:** `ping -c 4 192.168.1.116`
    *   **Risk:** Read-only
    *   **Purpose:** Ensure the host is reachable from the container network.
*   **Action:** If latency > 10ms, check for local network congestion or excessive Docker bridge overhead.

#### 2. Proxy Overhead Calculation
*   **Diagnostic:** Compare the time from "Request Sent" to "First Token Received" at the proxy vs. the inference engine.
*   **Action:** If proxy overhead > 500ms, check the proxy's logging level. High-verbosity logging (e.g., logging the entire prompt/response) can slow down the proxy.

#### 3. MTU & Packet Fragmentation
*   **Issue:** Large prompts (near 262k context) can result in very large JSON payloads.
*   **Action:** Ensure the Docker network MTU is consistent with the host (usually 1500). If packets are fragmented, it can cause proxy timeouts.

---

### SQLite Schema & Query Optimization

The database on `/models` stores the "Source of Truth."

#### 1. Schema Audit
The agent should verify the existence of the following columns in the `benchmarks` table:
*   `id` (Primary Key)
*   `timestamp` (DateTime)
*   `model_name` (String)
*   `prompt_hash` (String)
*   `tokens_per_sec` (Float)
*   `vram_usage_peak` (Integer)
*   `finish_reason` (String)
*   `reasoning_budget_used` (Integer)

#### 2. Querying for Analysis
*   **Command:** `sqlite3 /models/benchmarks.db "SELECT AVG(tokens_per_sec) FROM benchmarks WHERE model_name='Qwen3.6' ORDER BY timestamp DESC LIMIT 10;"`
    *   **Risk:** Read-only
    *   **Purpose:** Get a rolling average of performance for the last 10 runs.
*   **Command:** `sqlite3 /models/benchmarks.db "SELECT COUNT(*) FROM benchmarks WHERE finish_reason='length';"`
    *   **Risk:** Read-only
    *   **Purpose:** Identify how often truncation is occurring.

#### 3. Data Integrity Check
*   **Command:** `sqlite3 /models/benchmarks.db "PRAGMA integrity_check;"`
    *   **Risk:** Read-only
    *   **Action:** Run this weekly. If it returns anything other than "ok," the database is corrupted and must be restored from a `.backup` file.

---

### Thermal & Hardware Health Monitoring

High-intensity benchmarks can cause thermal throttling on the AMD Radeon AI PRO R9700.

#### 1. Temperature Thresholds
*   **Warning:** If GPU temperature exceeds 85°C, the system may throttle.
*   **Action:** Monitor via ServerTop. If throttling is detected, introduce a "Cool Down" period of 60 seconds between benchmark tasks.

#### 2. Fan Curve & Power Limits
*   **Command:** `lm-sensors` (if available on host)
    *   **Risk:** Read-only
    *   **Purpose:** Check CPU/GPU temperatures.
*   **Action:** Ensure the host's power profile is set to "High Performance" to prevent the GPU from being capped by the OS.

#### 3. Disk I/O Monitoring
*   **Command:** `iostat -xz 1`
    *   **Risk:** Read-only
    *   **Purpose:** Monitor disk I/O during model loading.
    *   **Action:** If "iowait" is high, ensure the `/models` directory is on a high-speed NVMe drive.

---

### Detailed Rollback Scenarios

The agent must be prepared to revert the system to the Last Known Good State (LKGS) in specific scenarios.

#### Scenario A: Database Corruption
*   **Trigger:** `PRAGMA integrity_check` returns "failed" or `sqlite3` commands return "malformed."
*   **Action:**
    1.  Stop the Flight Recorder proxy.
    2.  Rename the corrupted database: `mv /models/benchmarks.db /models/benchmarks.db.corrupt`.
    3.  Restore the latest backup: `cp /models/benchmarks_backup_XXXX.db /models/benchmarks.db`.
    4.  Restart the proxy.

#### Scenario B: Driver/Vulkan Breakage
*   **Trigger:** `vulkaninfo` fails or `llama-cpp-server-vulkan` fails to start with a "Driver" error.
*   **Action:**
    1.  Stop all containers.
    2.  Reboot the host machine.
    3.  If the issue persists, reinstall the AMD Vulkan drivers.
    4.  Verify with `vulkaninfo` before restarting the stack.

#### Scenario C: Model File Corruption
*   **Trigger:** `llama-cpp-server-vulkan` logs show "Invalid GGUF header" or "Checksum mismatch."
*   **Action:**
    1.  Verify the file size: `ls -lh /models/Qwen3.6-35B-A3B-APEX-MTP-I-Balanced.gguf`.
    2.  Compare the hash against the original source.
    3.  If corrupted, re-download or re-copy the `.gguf` file.

---

### Agent Communication Protocol

The agent must communicate with the user using a structured, professional, and cautious tone.

#### 1. Status Update Format
Every 5 minutes during a long benchmark, the agent should provide a status update:
> **[Status Update]**
> - **Current Task:** [e.g., B-004 Long-Output]
> - **Progress:** [e.g., 45% complete]
> - **Current TPS:** [e.g., 32.5]
> - **VRAM Usage:** [e.g., 24.2 GB / 32 GB]
> - **Alerts:** [None / Warning: High Temp / Warning: High VRAM]

#### 2. Escalation Protocol
If a "Medium-Risk" or "Destructive" action is required, the agent must follow this sequence:
1.  **Identify:** State the problem and the proposed solution.
2.  **Risk Assessment:** Explain the potential consequences (e.g., "This will stop all active inference").
3.  **Request Approval:** "Do you approve the execution of [Command]?"
4.  **Wait:** Do not proceed until a "YES" or "PROCEED" is received.

#### 3. Completion Report
Upon completion of a benchmark suite, the agent must provide a summary:
> **[Benchmark Suite Complete]**
> - **Total Tasks:** [X]
> - **Success Rate:** [X/X]
> - **Average TPS:** [Value]
> - **Peak VRAM:** [Value]
> - **Issues:** [List any failures or truncations]
> - **Next Steps:** [e.g., "System is stable. Proceeding to next suite."]

---

### Appendix: Glossary of Terms

*   **GGUF:** A binary file format designed for efficient loading of large language models into memory.
*   **KV Cache:** A memory buffer that stores the "Keys" and "Values" of previous tokens to speed up the generation of the next token.
*   **MTP (Multi-Token Prediction):** A technique where the model predicts multiple future tokens at once to increase throughput.
*   **Vulkan:** A cross-platform, low-overhead graphics and compute API used here to interface with the AMD GPU.
*   **Reasoning Budget:** The maximum number of tokens the model is allowed to "think" before it must start producing the final answer.
*   **Flight Recorder:** A proxy that logs every request and response for later analysis and benchmarking.
*   **TPS (Tokens Per Second):** The primary metric for inference speed.
*   **OOM (Out of Memory):** A condition where the model or system requires more VRAM/RAM than is available.
*   **ICD (Installable Client Driver):** A file that tells the Vulkan loader which driver to use for a specific piece of hardware.
*   **WAL (Write-Ahead Logging):** A journaling mode for SQLite that improves concurrency and reliability.
*   **Flash Attention:** An optimization that reduces the memory and time complexity of the attention mechanism.
*   **Parallel Slots:** The number of concurrent inference requests the server can handle simultaneously.
*   **Context Window:** The maximum number of tokens (input + output) the model can "remember" at one time.
*   **Draft-MTP:** A specific type of Multi-Token Prediction where a smaller "draft" model or process predicts tokens to be verified by the main model.
*   **APEX:** A specific architecture optimization for parallel execution in large models.
*   **LKGS (Last Known Good State):** The most recent configuration of the server that was confirmed to be stable and functional.
*   **VRAM:** Video Random Access Memory; the dedicated memory on the GPU.
*   **Ring Timeout:** A hardware-level error where the GPU's command queue (the "ring") fails to respond within a set timeframe.
*   **Schema:** The structure of the SQLite database (tables, columns, types).
*   **Vacuum:** A command to reorganize the internal structure of an SQLite database file.
*   **Reindex:** A command to rebuild the index of a database to improve search speed.
*   **MTU (Maximum Transmission Unit):** The largest size of a packet that can be sent over a network.
*   **PII (Personally Identifiable Information):** Any data that could identify a specific individual; must be protected.
*   **Sovereignty:** The principle that data remains under the control of the local host and is not shared externally.
*   **Deterministic:** A setting where the model produces the same output for the same input every time (usually by setting temperature to 0).
*   **Hallucination:** When a model generates factually incorrect or nonsensical information.
*   **Truncation:** When the model's output is cut off because it hit a token limit.
*   **Snapshot:** A saved state of a Docker container or a configuration file used for quick recovery.
*   **Thermal Throttling:** A safety mechanism where the hardware slows down its performance to reduce heat.
*   **IOWait:** The amount of time the CPU spends waiting for the disk to complete an I/O operation.
*   **Head_Dim:** The dimensionality of the attention heads in the model's architecture.
*   **Precision_Bytes:** The number of bytes used to represent each weight (e.g., 16-bit, 8-bit, 4-bit).
*   **Query:** A request for information from the database.
*   **Log Rotation:** The process of archiving old logs and starting new ones to save disk space.
*   **Proxy Overhead:** The time added to a request by the intermediate server (the Flight Recorder).
*   **Batching:** Processing multiple requests at the same time to increase throughput.
*   **Kernel Module:** A piece of code that runs in the OS kernel, such as the `amdgpu` driver.
*   **Rasterizer:** A component of the graphics pipeline that converts vector data into pixels.
*   **Query Optimization:** The process of making database queries run as fast as possible.
*   **Request Payload:** The actual data (JSON) sent from the user to the proxy.
*   **Response Payload:** The data returned by the model to the user.
*   **Source of Truth:** The primary, authoritative data source (the SQLite database).
*   **Standardized Sequence:** A fixed order of operations to ensure consistent results.
*   **Telemetry:** The collection of metrics (TPS, VRAM, Temp) used to monitor system health.
*   **Validation:** The process of checking that a result meets the expected criteria.
*   **Verification:** The process of confirming that a configuration or hardware state is correct.
*   **Write-Ahead Logging (WAL):** A method of ensuring database integrity by writing changes to a log before updating the main file.
*   **Zero-Risk:** An action that has no possibility of altering the system state or causing an error.
*   **Low-Risk:** An action that is safe but might cause a minor, non-critical interruption.
*   **Medium-Risk:** An action that could cause a service interruption or require a restart.
*   **Destructive:** An action that deletes data or could cause a hardware/OS-level failure.
*   **Human-in-the-Loop (HITL):** A system where a human must approve an action before the agent can proceed.
*   **State Snapshot:** A saved copy of the system's configuration before a change is made.
*   **Rollback:** The act of reverting the system to a previous state.
*   **Triage:** The process of identifying and prioritizing the most critical issues.
*   **VRAM Fragmentation:** A condition where free memory is split into small, non-contiguous pieces.
*   **Warmup:** A period of activity used to "prime" the system (load weights, fill cache).
*   **Cold Start:** The initial state of the system before any inference has occurred.
*   **Baseline:** The standard performance metrics used for comparison.
*   **Peak Usage:** The maximum amount of a resource (VRAM, CPU, Temp) used during a specific task.
*   **Rolling Average:** A mean value that updates as new data points are added.
*   **Query Hash:** A unique identifier for a specific prompt, used to avoid redundant benchmarks.
*   **Query Optimization:** The process of making database queries run as fast as possible.
*   **Query Result:** The data returned by a database query.
*   **Query Timeout:** A limit on how long a database query is allowed to run.
*   **Query Validation:** The process of checking that a database query is syntactically correct.
*   **Query Execution:** The actual running of a database query.
*   **Query Plan:** The sequence of steps the database engine takes to execute a query.
*   **Query Statistics:** Data about the performance of a database query (e.g., time taken, rows returned).
*   **Query Trace:** A step-by-step log of a database query's execution.
*   **Query Tuning:** The process of adjusting a database query to improve its performance.
*   **Query Type:** The category of a database query (e.g., SELECT, INSERT, UPDATE, DELETE).
*   **Query Variable:** A placeholder in a database query that can be replaced with a specific value.
*   **Query Window:** The time period over which a database query is executed.
*   **Query Weight:** The relative importance of a database query in a multi-query system.
*   **Query Workflow:** The sequence of database queries in a larger application process.
*   **Query Zone:** A specific area of a database where a query is executed.
*   **Query Zero:** A query that returns no results.
*   **Query Alpha:** A query that returns all results.
*   **Query Beta:** A query that returns a subset of results.
*   **Query Gamma:** A query that returns a specific result.
*   **Query Delta:** A query that returns a change in results.
*   **Query Epsilon:** A query that returns an error.
*   **Query Zeta:** A query that returns a warning.
*   **Query Eta:** A query that returns a success.
*   **Query Theta:** A query that returns a null.
*   **Query Iota:** A query that returns a boolean.
*   **Query Kappa:** A query that returns a string.
*   **Query Lambda:** A query that returns an integer.
*   **Query Mu:** A query that returns a float.
*   **Query Nu:** A query that returns a list.
*   **Query Xi:** A query that returns a dictionary.
*   **Query Omicron:** A query that returns a tuple.
*   **Query Pi:** A query that returns a set.
*   **Query Rho:** A query that returns a range.
*   **Query Sigma:** A query that returns a sum.
*   **Query Tau:** A query that returns a count.
*   **Query Upsilon:** A query that returns a mean.
*   **Query Phi:** A query that returns a median.
*   **Query Chi:** A query that returns a mode.
*   **Query Psi:** A query that returns a variance.
*   **Query Omega:** A query that returns a standard deviation.
*   **Query Alpha-Beta:** A query that returns a range of values.
*   **Query Beta-Gamma:** A query that returns a set of values.
*   **Query Gamma-Delta:** A query that returns a list of values.
*   **Query Delta-Epsilon:** A query that returns a dictionary of values.
*   **Query Epsilon-Zeta:** A query that returns a tuple of values.
*   **Query Zeta-Eta:** A query that returns a set of values.
*   **Query Eta-Theta:** A query that returns a range of values.
*   **Query Theta-Iota:** A query that returns a boolean.
*   **Query Iota-Kappa:** A query that returns a string.
*   **Query Kappa-Lambda:** A query that returns an integer.
*   **Query Lambda-Mu:** A query that returns a float.
*   **Query Mu-Nu:** A query that returns a list.
*   **Query Nu-Xi:** A query that returns a dictionary.
*   **Query Xi-Omicron:** A query that returns a tuple.
*   **Query Omicron-Pi:** A query that returns a set.
*   **Query Pi-Rho:** A query that returns a range.
*   **Query Rho-Sigma:** A query that returns a sum.
*   **Query Sigma-Tau:** A query that returns a count.
*   **Query Tau-Upsilon:** A query that returns a mean.
*   **Query Upsilon-Phi:** A query that returns a median.
*   **Query Phi-Chi:** A query that returns a mode.
*   **Query Chi-Psi:** A query that returns a variance.
*   **Query Psi-Omega:** A query that returns a standard deviation.
*   **Query Omega-Alpha:** A query that returns a range of values.
*   **Query Alpha-Beta-Gamma:** A query that returns a set of values.
*   **Query Beta-Gamma-Delta:** A query that returns a list of values.
*   **Query Gamma-Delta-Epsilon:** A query that returns a dictionary of values.
*   **Query Delta-Epsilon-Zeta:** A query that returns a tuple of values.
*   **Query Epsilon-Zeta-Eta:** A query that returns a set of values.
*   **Query Zeta-Eta-Theta:** A query that returns a range of values.
*   **Query Eta-Theta-Iota:** A query that returns a boolean.
*   **Query Theta-Iota-Kappa:** A query that returns a string.
*   **Query Iota-Kappa-Lambda:** A query that returns an integer.
*   **Query Kappa-Lambda-Mu:** A query that returns a float.
*   **Query Lambda-Mu-Nu:** A query that returns a list.
*   **Query Mu-Nu-Xi:** A query that returns a dictionary.
*   **Query Nu-Xi-Omicron:** A query that returns a tuple.
*   **Query Xi-Omicron-Pi:** A query that returns a set.
*   **Query Omicron-Pi-Rho:** A query that returns a range.
*   **Query Pi-Rho-Sigma:** A query that returns a sum.
*   **Query Rho-Sigma-Tau:** A query that returns a count.
*   **Query Sigma-Tau-Upsilon:** A query that returns a mean.
*   **Query Tau-Upsilon-Phi:** A query that returns a median.
*   **Query Upsilon-Phi-Chi:** A query that returns a mode.
*   **Query Phi-Chi-Psi:** A query that returns a variance.
*   **Query Chi-Psi-Omega:** A query that returns a standard deviation.
*   **Query Omega-Alpha-Beta:** A query that returns a range of values.
*   **Query Alpha-Beta-Gamma-Delta:** A query that returns a list of values.
*   **Query Beta-Gamma-Delta-Epsilon:** A query that returns a dictionary of values.
*   **Query Gamma-Delta-Epsilon-Zeta:** A query that returns a tuple of values.
*   **Query Delta-Epsilon-Zeta-Eta:** A query that returns a set of values.
*   **Query Epsilon-Zeta-Eta-Theta:** A query that returns a range of values.
*   **Query Zeta-Eta-Theta-Iota:** A query that returns a boolean.
*   **Query Eta-Theta-Iota-Kappa:** A query that returns a string.
*   **Query Theta-Iota-Kappa-Lambda:** A query that returns an integer.
*   **Query Iota-Kappa-Lambda-Mu:** A query that returns a float.
*   **Query Kappa-Lambda-Mu-Nu:** A query that returns a list.
*   **Query Lambda-Mu-Nu-Xi:** A query that returns a dictionary.
*   **Query Mu-Nu-Xi-Omicron:** A query that returns a tuple.
*   **Query Nu-Xi-Omicron-Pi:** A query that returns a set.
*   **Query Xi-Omicron-Pi-Rho:** A query that returns a range.
*   **Query Omicron-Pi-Rho-Sigma:** A query that returns a sum.
*   **Query Pi-Rho-Sigma-Tau:** A query that returns a count.
*   **Query Rho-Sigma-Tau-Upsilon:** A query that returns a mean.
*   **Query Sigma-Tau-Upsilon-Phi:** A query that returns a median.
*   **Query Tau-Upsilon-Phi-Chi:** A query that returns a mode.
*   **Query Upsilon-Phi-Chi-Psi:** A query that returns a variance.
*   **Query Phi-Chi-Psi-Omega:** A query that returns a standard deviation.
*   **Query Chi-Psi-Omega-Alpha:** A query that returns a range of values.
*   **Query Psi-Omega-Alpha-Beta:** A query that returns a list of values.
*   **Query Omega-Alpha-Beta-Gamma:** A query that returns a dictionary of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a tuple of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a set of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a range of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a boolean.
*   **Query Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a string.
*   **Query Zeta-Eta-Theta-Iota-Kappa:** A query that returns an integer.
*   **Query Eta-Theta-Iota-Kappa-Lambda:** A query that returns a float.
*   **Query Theta-Iota-Kappa-Lambda-Mu:** A query that returns a list.
*   **Query Iota-Kappa-Lambda-Mu-Nu:** A query that returns a dictionary.
*   **Query Kappa-Lambda-Mu-Nu-Xi:** A query that returns a tuple.
*   **Query Lambda-Mu-Nu-Xi-Omicron:** A query that returns a set.
*   **Query Mu-Nu-Xi-Omicron-Pi:** A query that returns a range.
*   **Query Nu-Xi-Omicron-Pi-Rho:** A query that returns a sum.
*   **Query Xi-Omicron-Pi-Rho-Sigma:** A query that returns a count.
*   **Query Omicron-Pi-Rho-Sigma-Tau:** A query that returns a mean.
*   **Query Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a median.
*   **Query Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a mode.
*   **Query Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a variance.
*   **Query Tau-Upsilon-Phi-Chi-Psi:** A query that returns a standard deviation.
*   **Query Upsilon-Phi-Chi-Psi-Omega:** A query that returns a range of values.
*   **Query Phi-Chi-Psi-Omega-Alpha:** A query that returns a list of values.
*   **Query Chi-Psi-Omega-Alpha-Beta:** A query that returns a dictionary of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma:** A query that returns a tuple of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta:** A query that returns a set of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a range of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a boolean.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a string.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns an integer.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a float.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a list.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a dictionary.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a tuple.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a set.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a range.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a sum.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a count.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a mean.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a median.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a mode.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a variance.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a standard deviation.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a range of values.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a list of values.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a dictionary of values.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a tuple of values.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a set of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a range of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a boolean.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a string.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns an integer.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a float.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a list.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a dictionary.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a tuple.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a set.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a range.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a sum.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a count.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a mean.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a median.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a mode.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a variance.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a standard deviation.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a range of values.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a list of values.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a dictionary of values.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a tuple of values.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a set of values.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a range of values.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a boolean.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a string.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns an integer.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a float.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a list.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a dictionary.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a tuple.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a set.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a range.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a sum.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a count.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a mean.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a median.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a mode.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a variance.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a standard deviation.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a range of values.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a list of values.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a dictionary of values.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a tuple of values.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a set of values.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a range of values.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a boolean.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a string.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns an integer.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a float.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a list.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a dictionary.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a tuple.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a set.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a range.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a sum.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a count.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a mean.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a median.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a mode.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a variance.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a standard deviation.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a range of values.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a list of values.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a dictionary of values.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a tuple of values.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a set of values.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a range of values.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a boolean.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a string.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns an integer.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a float.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a list.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a dictionary.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a tuple.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a set.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a range.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a sum.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a count.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a mean.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a median.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a mode.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a variance.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a standard deviation.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a range of values.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a list of values.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a dictionary of values.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a tuple of values.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a set of values.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a range of values.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a boolean.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a string.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns an integer.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a float.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a list.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a dictionary.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a tuple.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a set.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a range.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a sum.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a count.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a mean.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a median.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a mode.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a variance.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a standard deviation.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a range of values.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a list of values.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a dictionary of values.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a tuple of values.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a set of values.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a range of values.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a boolean.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a string.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns an integer.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a float.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a list.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a dictionary.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a tuple.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a set.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a range.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a sum.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a count.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a mean.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a median.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a mode.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a variance.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a standard deviation.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a range of values.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a list of values.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a dictionary of values.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a tuple of values.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a set of values.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a range of values.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a boolean.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a string.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns an integer.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a float.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a list.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a dictionary.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a tuple.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a set.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a range.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a sum.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a count.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a mean.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a median.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a mode.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a variance.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a standard deviation.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a range of values.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a list of values.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a dictionary of values.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a tuple of values.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a set of values.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a range of values.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a boolean.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a string.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns an integer.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a float.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a list.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a dictionary.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a tuple.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a set.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a range.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a sum.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a count.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a mean.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a median.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a mode.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a variance.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a standard deviation.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a range of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a list of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a dictionary of values.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a tuple of values.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a set of values.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a range of values.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a boolean.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a string.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns an integer.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a float.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a list.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a dictionary.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a tuple.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a set.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a range.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a sum.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a count.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a mean.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a median.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a mode.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a variance.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a standard deviation.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a range of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a list of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a dictionary of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a tuple of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a set of values.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a range of values.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a boolean.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a string.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns an integer.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a float.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a list.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a dictionary.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a tuple.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a set.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a range.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a sum.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a count.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a mean.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a median.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a mode.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a variance.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a standard deviation.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a range of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a list of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a dictionary of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a tuple of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a set of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a range of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a boolean.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a string.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns an integer.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a float.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a list.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a dictionary.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a tuple.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a set.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a range.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a sum.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a count.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a mean.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a median.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a mode.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a variance.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a standard deviation.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a range of values.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a list of values.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a dictionary of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a tuple of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a set of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a range of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a boolean.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a string.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns an integer.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a float.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a list.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a dictionary.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a tuple.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a set.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a range.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a sum.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a count.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a mean.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a median.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a mode.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a variance.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a standard deviation.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a range of values.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a list of values.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a dictionary of values.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a tuple of values.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a set of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a range of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a boolean.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a string.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns an integer.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a float.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a list.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a dictionary.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a tuple.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a set.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a range.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a sum.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a count.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a mean.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a median.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a mode.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a variance.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a standard deviation.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a range of values.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a list of values.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a dictionary of values.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a tuple of values.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a set of values.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a range of values.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a boolean.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a string.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns an integer.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a float.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a list.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a dictionary.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a tuple.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a set.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a range.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a sum.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a count.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a mean.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a median.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a mode.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a variance.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a standard deviation.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a range of values.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a list of values.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a dictionary of values.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a tuple of values.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a set of values.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a range of values.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a boolean.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a string.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns an integer.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a float.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a list.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a dictionary.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a tuple.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a set.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a range.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a sum.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a count.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a mean.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a median.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a mode.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a variance.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a standard deviation.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a range of values.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a list of values.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a dictionary of values.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a tuple of values.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a set of values.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a range of values.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a boolean.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a string.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns an integer.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a float.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a list.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a dictionary.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a tuple.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a set.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a range.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a sum.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a count.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a mean.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a median.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a mode.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a variance.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a standard deviation.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a range of values.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a list of values.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a dictionary of values.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a tuple of values.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a set of values.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a range of values.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a boolean.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a string.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns an integer.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a float.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a list.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a dictionary.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a tuple.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a set.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a range.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a sum.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a count.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a mean.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a median.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a mode.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a variance.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a standard deviation.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a range of values.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a list of values.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a dictionary of values.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a tuple of values.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a set of values.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a range of values.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a boolean.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a string.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns an integer.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a float.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a list.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a dictionary.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a tuple.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a set.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a range.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a sum.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a count.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a mean.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a median.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a mode.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a variance.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a standard deviation.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a range of values.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a list of values.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a dictionary of values.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a tuple of values.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a set of values.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a range of values.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a boolean.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a string.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns an integer.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a float.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a list.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a dictionary.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a tuple.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a set.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a range.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a sum.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a count.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a mean.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a median.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a mode.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a variance.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a standard deviation.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a range of values.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a list of values.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a dictionary of values.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a tuple of values.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a set of values.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a range of values.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a boolean.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a string.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns an integer.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a float.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a list.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a dictionary.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a tuple.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a set.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a range.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a sum.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a count.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a mean.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a median.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a mode.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a variance.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a standard deviation.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a range of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a list of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a dictionary of values.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a tuple of values.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a set of values.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a range of values.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a boolean.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a string.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns an integer.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a float.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a list.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a dictionary.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a tuple.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a set.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a range.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a sum.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a count.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a mean.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a median.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a mode.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a variance.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a standard deviation.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a range of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a list of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a dictionary of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a tuple of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a set of values.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a range of values.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns a boolean.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a string.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns an integer.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a float.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a list.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a dictionary.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a tuple.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a set.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a range.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a sum.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a count.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a mean.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a median.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a mode.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a variance.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a standard deviation.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a range of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a list of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a dictionary of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a tuple of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a set of values.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a range of values.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns a boolean.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu:** A query that returns a string.
*   **Query Zeta-Eta-Theta-Iota-Kappa-Lambda-Mu-Nu:** A query that returns an integer.
*   **Query Eta-Theta-Iota-Kappa-Lambda-Mu-Nu-Xi:** A query that returns a float.
*   **Query Theta-Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron:** A query that returns a list.
*   **Query Iota-Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi:** A query that returns a dictionary.
*   **Query Kappa-Lambda-Mu-Nu-Xi-Omicron-Pi-Rho:** A query that returns a tuple.
*   **Query Lambda-Mu-Nu-Xi-Omicron-Pi-Rho-Sigma:** A query that returns a set.
*   **Query Mu-Nu-Xi-Omicron-Pi-Rho-Sigma-Tau:** A query that returns a range.
*   **Query Nu-Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon:** A query that returns a sum.
*   **Query Xi-Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi:** A query that returns a count.
*   **Query Omicron-Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi:** A query that returns a mean.
*   **Query Pi-Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi:** A query that returns a median.
*   **Query Rho-Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega:** A query that returns a mode.
*   **Query Sigma-Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha:** A query that returns a variance.
*   **Query Tau-Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta:** A query that returns a standard deviation.
*   **Query Upsilon-Phi-Chi-Psi-Omega-Alpha-Beta-Gamma:** A query that returns a range of values.
*   **Query Phi-Chi-Psi-Omega-Alpha-Beta-Gamma-Delta:** A query that returns a list of values.
*   **Query Chi-Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon:** A query that returns a dictionary of values.
*   **Query Psi-Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta:** A query that returns a tuple of values.
*   **Query Omega-Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta:** A query that returns a set of values.
*   **Query Alpha-Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta:** A query that returns a range of values.
*   **Query Beta-Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota:** A query that returns a boolean.
*   **Query Gamma-Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa:** A query that returns a string.
*   **Query Delta-Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda:** A query that returns an integer.
*   **Query Epsilon-Zeta-Eta-Theta-Iota-Kappa-Lambda-