From 50ff7f945dd0a69146bab8a50821cb9db6198add Mon Sep 17 00:00:00 2001
From: Jesse Zhang <101612750+Nagi-ovo@users.noreply.github.com>
Date: Wed, 10 Jun 2026 13:03:01 +0100
Subject: [PATCH] Contributor credits, SVG prefetch, integrate Xiaomi MiMo from
 PR #4

- Runs gain a contributor field (GitHub username); the site renders an
  avatar chip linked to their profile next to each run's notes, and CI
  validates the field. All existing runs are attributed.
- SVG variants of a case are prefetched during idle time, so switching
  model tabs swaps images without a network hiccup.
- Xiaomi MiMo v2.5 Pro (Claude Code, max effort) integrated from PR #4
  with both case runs and provenance notes; README registry tables
  updated.

Co-authored-by: DuJiabao <Jiabao.du@Yunzhisun.com>
---
 README.en.md                                  |    3 +-
 README.md                                     |    7 +-
 models/claude-fable-5.json                    |    6 +-
 models/composer-2-5.json                      |    3 +-
 models/deepseek-v4-pro.json                   |    6 +-
 models/doubao-seed-2-0-mini.json              |    3 +-
 models/doubao-seed-2-0-pro.json               |    3 +-
 models/gemini-3-1-pro.json                    |    9 +-
 models/gemini-3-5-flash.json                  |    9 +-
 models/gpt-5-5-pro.json                       |    3 +-
 models/gpt-5-5-xhigh.json                     |    6 +-
 models/grok-build.json                        |    3 +-
 models/xiaomi-mimo-v2-5-pro.json              |   23 +
 .../xiaomi-mimo-v2-5-pro/mythos-craft.html    | 1145 +++++++++++++++++
 .../xiaomi-mimo-v2-5-pro/pelican-cycling.svg  |  226 ++++
 15 files changed, 1435 insertions(+), 20 deletions(-)
 create mode 100644 models/xiaomi-mimo-v2-5-pro.json
 create mode 100644 outputs/xiaomi-mimo-v2-5-pro/mythos-craft.html
 create mode 100644 outputs/xiaomi-mimo-v2-5-pro/pelican-cycling.svg

diff --git a/README.en.md b/README.en.md
index a71c10e..594fd86 100644
--- a/README.en.md
+++ b/README.en.md
@@ -26,6 +26,7 @@ One-shot LLM eval cases by NAGI STUDIO: same prompt, different model x harness x
 | DeepSeek-V4-Pro | DeepSeek | Claude Code | Max | 02 |
 | Doubao Seed 2.0 Pro | ByteDance | Doubao Web | Pro Mode | 01 |
 | Doubao Seed 2.0 Mini | ByteDance | Doubao Web | Fast Mode | 01 |
+| MiMo v2.5 Pro | Xiaomi | Claude Code | Max | 02 |
 
 Pending: Mistral Medium 3.5 · Kimi K2.6 · MiniMax M3 · GLM-5.1 · Qwen3.7-Max (PRs welcome)
 
@@ -57,6 +58,6 @@ Contributions are data-only — no code changes needed:
 1. Artifact: `outputs/<model-id>/<case-id>.<ext>` (e.g. `outputs/gpt-5-5-pro/pelican-cycling.svg`).
 2. Registration: `models/<model-id>.json` (new file for a new combination; add to `runs` for an existing one) — see the schema example in the Chinese README.
 
-CI-enforced rules: dash-only lowercase ids matching the `outputs/` folder name; a **required bilingual provenance `note`** per run (which harness, what effort, one-shot or fixed); every declared run must have its artifact; multiple versions of the same combination x case go in an array with distinct `file` names (e.g. `pelican-cycling-2.svg`).
+CI-enforced rules: dash-only lowercase ids matching the `outputs/` folder name; a **required bilingual provenance `note`** per run (which harness, what effort, one-shot or fixed); every declared run must have its artifact; multiple versions of the same combination x case go in an array with distinct `file` names (e.g. `pelican-cycling-2.svg`). Set `contributor` to your GitHub username — the site shows your avatar linked to your profile next to the run.
 
 PRs get data validation + a build from CI; merges to `main` deploy automatically.
diff --git a/README.md b/README.md
index edbcebe..48e842d 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,7 @@ NAGI STUDIO 的 LLM 测评案例集：同一段提示词，不同「模型 × Ha
 | DeepSeek-V4-Pro | DeepSeek | Claude Code | Max | 02 |
 | Doubao Seed 2.0 Pro | ByteDance | 豆包网页版 | 超能模式 | 01 |
 | Doubao Seed 2.0 Mini | ByteDance | 豆包网页版 | 快速模式 | 01 |
+| MiMo v2.5 Pro | Xiaomi | Claude Code | Max | 02 |
 
 待测：Mistral Medium 3.5 · Kimi K2.6 · MiniMax M3 · GLM-5.1 · Qwen3.7-Max（欢迎 PR 补充）
 
@@ -69,7 +70,8 @@ bun run build    # 数据校验 + 类型检查 + 产物构建（输出到 site/d
       "note": {
         "zh": "在哪个 Harness 里、什么思考档位、是否一次生成、是否有修复",
         "en": "Which harness, what effort level, one-shot or fixed"
-      }
+      },
+      "contributor": "你的 GitHub 用户名"
     }
   }
 }
@@ -79,6 +81,7 @@ bun run build    # 数据校验 + 类型检查 + 产物构建（输出到 site/d
 - `model-id` 只用小写字母/数字/连字符（如 `doubao-seed-2-0-pro`），文件名与 `outputs/` 目录名一致；
 - 每条 run 的 `note` **双语必填**——这是本仓库的可信度来源，必须写明产出怎么来的；
 - 声明的 run 必须有对应的产出文件；
-- 同一组合对同一案例可提交多个版本：`runs.<case-id>` 写成数组，第二个版本起必须用 `file` 指定不同文件名（如 `pelican-cycling-2.svg`）。
+- 同一组合对同一案例可提交多个版本：`runs.<case-id>` 写成数组，第二个版本起必须用 `file` 指定不同文件名（如 `pelican-cycling-2.svg`）；
+- `contributor` 填你的 GitHub 用户名，站点会在产出旁展示你的头像并链接到主页。
 
 提 PR 后 CI 会跑数据校验 + 构建；合入 `main` 自动部署。
diff --git a/models/claude-fable-5.json b/models/claude-fable-5.json
index 46fe578..746af19 100644
--- a/models/claude-fable-5.json
+++ b/models/claude-fable-5.json
@@ -9,13 +9,15 @@
       "note": {
         "zh": "在 Claude 网页版以 Fable 5 Max（最高思考强度）运行，过程中触发一次 auto compact 与工具调用上限，手动输入「继续」后完成；ID 水印与英文支持为事后在 Cursor 中用 Composer 2.5 Fast 一条提示词补加，其余均为一次生成。已知小问题：开局可能卡在一棵树里，按一下 G 即可脱身。",
         "en": "Run in the Claude web app on Fable 5 Max (max thinking effort); hit one auto-compact and the tool-call limit mid-run, finished after a manual \"continue\". The ID watermark and English support were patched in afterwards with a single prompt via Composer 2.5 Fast in Cursor; everything else is one-shot. Known quirk: you may spawn stuck inside a tree - press G once to get free."
-      }
+      },
+      "contributor": "Nagi-ovo"
     },
     "pelican-cycling": {
       "note": {
         "zh": "在 Claude 网页版以 Fable 5 Max（最高思考强度）一次生成。",
         "en": "Generated in one shot in the Claude web app on Fable 5 Max (max thinking effort)."
-      }
+      },
+      "contributor": "Nagi-ovo"
     }
   }
 }
diff --git a/models/composer-2-5.json b/models/composer-2-5.json
index dcaa0e6..d267369 100644
--- a/models/composer-2-5.json
+++ b/models/composer-2-5.json
@@ -9,7 +9,8 @@
       "note": {
         "zh": "在 Cursor 中以 Composer 2.5 生成；本页为修复版（改 1 行）+ 补一个小功能。问题：第 1152 行水平速度先乘 speed*dt，位移时又乘一次 dt，实际步速只有设计值（5 格/秒）的约 1/60。修复前：走路如蜗牛、跳跃下落却正常；沙漠雪地等群系与神话建筑实际走不到，体感像「切换不了场景」——游戏本无传送功能，群系需步行抵达。原因：X/Z 轴把「每帧位移」当「每秒速度」存入 velocity，与 Y 轴语义不一致。去掉一次 dt 后步行恢复 5 格/秒。另外它确实生成了精灵螺旋塔、龙神殿、天空遗迹三处景点（也画在小地图上），但原版只能徒步抵达——已补加按 G 依次瞬移到三处景点的功能，开屏说明里也加了一行。",
         "en": "Generated with Composer 2.5 in Cursor; fixed build (1 line changed) plus one small addition. Bug: line 1152 multiplied horizontal velocity by speed*dt, then displacement multiplied by dt again, leaving walking at ~1/60 of the designed 5 blocks/s. Before the fix: walking crawled while jumping/falling felt normal, and biomes or mythic structures were virtually unreachable — which read as \"scene switching is broken\" (there is no teleport; biomes are reached on foot). Cause: X/Z stored per-frame displacement in a per-second velocity field, inconsistent with the Y axis. With one dt removed walking is back to 5 blocks/s. It does generate three landmarks (Elven Spiral Tower, Dragon Temple, Sky Ruins — also drawn on the minimap) that were only reachable on foot, so a G-key cycle-teleport to them was added, with a line in the start screen."
-      }
+      },
+      "contributor": "Nagi-ovo"
     }
   }
 }
diff --git a/models/deepseek-v4-pro.json b/models/deepseek-v4-pro.json
index bfe18ae..ef6887d 100644
--- a/models/deepseek-v4-pro.json
+++ b/models/deepseek-v4-pro.json
@@ -9,13 +9,15 @@
       "note": {
         "zh": "在 Claude Code 中以 DeepSeek V4 Pro（最高思考强度）一次生成，未修复。包含 Perlin 噪声地形、WASD + 鼠标第一人称操控、12 种方块类型（含水、黑曜石、水晶、金块等）、程序化材质纹理、四种神话建筑（水晶塔、石环阵、龙骨遗迹、天空遗迹），按 G 可随机传送至神话建筑。",
         "en": "Generated in one shot via Claude Code with DeepSeek V4 Pro (max thinking effort), no fixes. Features Perlin noise terrain, WASD + mouse first-person controls, 12 block types (including water, obsidian, crystal, gold), procedural textures, and four mythic structures (Crystal Tower, Stone Circle, Dragon Skeleton, Sky Ruins). Press G to teleport between landmarks."
-      }
+      },
+      "contributor": "Mintcolour"
     },
     "pelican-cycling": {
       "note": {
         "zh": "在 Claude Code 中以 DeepSeek V4 Pro（最高思考强度）一次生成。场景包含天空、海洋、沙滩、棕榈树、海鸥、完整自行车细节（辐条、链条、齿轮）以及鹈鹕（长喙、喉囊、羽翼、踩踏动作）。",
         "en": "Generated in one shot via Claude Code with DeepSeek V4 Pro (max thinking effort). Scene includes sky, ocean, beach, palm trees, seagulls, detailed bicycle (spokes, chain, gears), and a pelican (beak, gular pouch, wings, pedaling pose)."
-      }
+      },
+      "contributor": "Mintcolour"
     }
   }
 }
diff --git a/models/doubao-seed-2-0-mini.json b/models/doubao-seed-2-0-mini.json
index c6a14fc..a24e440 100644
--- a/models/doubao-seed-2-0-mini.json
+++ b/models/doubao-seed-2-0-mini.json
@@ -9,7 +9,8 @@
       "note": {
         "zh": "在豆包网页版以快速模式一次生成。\n\n「要不要我再给你做一个带简单动画（翅膀扇动、车轮转动）的增强版 SVG 代码？」",
         "en": "Generated in one shot on Doubao web app in Lite mode.\n\n\"Should I make you an enhanced version of the SVG code with simple animations (flapping wings, rotating wheels)?\""
-      }
+      },
+      "contributor": "LpIuma"
     }
   }
 }
diff --git a/models/doubao-seed-2-0-pro.json b/models/doubao-seed-2-0-pro.json
index 005eff1..1cdfc6d 100644
--- a/models/doubao-seed-2-0-pro.json
+++ b/models/doubao-seed-2-0-pro.json
@@ -9,7 +9,8 @@
       "note": {
         "zh": "使用豆包网页版超能模式，首次输出了 png 图片，经提醒后生成 svg 代码。",
         "en": "Using Doubao web app (Pro mode), it initially output a PNG image, then generated the SVG code after being reminded."
-      }
+      },
+      "contributor": "LpIuma"
     }
   }
 }
diff --git a/models/gemini-3-1-pro.json b/models/gemini-3-1-pro.json
index 504015d..65566b7 100644
--- a/models/gemini-3-1-pro.json
+++ b/models/gemini-3-1-pro.json
@@ -9,21 +9,24 @@
       "note": {
         "zh": "通过 AntiGravity 生成（thinking effort: high）；一次生成，未发现需要修复的问题，原样展示。",
         "en": "Generated via AntiGravity (thinking effort: high); one shot, no fixes needed — shown as-is."
-      }
+      },
+      "contributor": "Nagi-ovo"
     },
     "pelican-cycling": [
       {
         "note": {
           "zh": "在 Google AI Studio 以 Gemini 3.1 Pro Preview High（最高思考强度）一次生成。",
           "en": "Generated in Google AI Studio on Gemini 3.1 Pro Preview High (max thinking effort) in one shot."
-        }
+        },
+        "contributor": "LpIuma"
       },
       {
         "file": "pelican-cycling-2.svg",
         "note": {
           "zh": "由社区 PR #3（Codex 工作流）提交，提交者未注明运行环境与思考档位。",
           "en": "Contributed via community PR #3 (a Codex workflow); the submitter did not specify the runtime or effort level."
-        }
+        },
+        "contributor": "XA2333"
       }
     ]
   }
diff --git a/models/gemini-3-5-flash.json b/models/gemini-3-5-flash.json
index 66b5013..e1e21e9 100644
--- a/models/gemini-3-5-flash.json
+++ b/models/gemini-3-5-flash.json
@@ -9,21 +9,24 @@
       "note": {
         "zh": "通过 AntiGravity 生成（thinking effort: high）；本页为修复版（仅改 1 行）。问题：16 张贴图按「上为原点」的行序画进 4×4 图集，UV 坐标表也按同一行序编写，但 CanvasTexture 默认 flipY=true 把采样行上下镜像（第 r 行实际采到第 3-r 行）。修复前：草地顶面显示成紫水晶、侧面采到带透明孔洞的传送门/树叶贴图，配合 alphaTest 出现大量「透明方块」，放置的方块贴图与名称完全对不上。原因：flipY 与图集行序约定不一致。加上 flipY=false 后行序对齐，地形与方块全部正常。",
         "en": "Generated via AntiGravity (thinking effort: high); fixed build (1 line changed). Bug: 16 tiles drawn into a 4x4 atlas with top-origin rows, and the UV table uses the same convention, but CanvasTexture's default flipY=true mirrors the rows on sampling (row r actually reads row 3-r). Before the fix: grass tops rendered as purple crystal, sides sampled the portal/leaves tiles with alpha holes — hence the many \"transparent blocks\" — and placed blocks never matched their names. Cause: flipY disagreeing with the atlas row convention. With flipY=false everything lines up."
-      }
+      },
+      "contributor": "Nagi-ovo"
     },
     "pelican-cycling": [
       {
         "note": {
           "zh": "在 Google AI Studio 以 Gemini 3.5 Flash High（最高思考强度）一次生成。",
           "en": "Generated in Google AI Studio on Gemini 3.5 Flash High (max thinking effort) in one shot."
-        }
+        },
+        "contributor": "LpIuma"
       },
       {
         "file": "pelican-cycling-2.svg",
         "note": {
           "zh": "由社区 PR #3（Codex 工作流）提交，提交者未注明运行环境与思考档位。",
           "en": "Contributed via community PR #3 (a Codex workflow); the submitter did not specify the runtime or effort level."
-        }
+        },
+        "contributor": "XA2333"
       }
     ]
   }
diff --git a/models/gpt-5-5-pro.json b/models/gpt-5-5-pro.json
index f585843..081eb53 100644
--- a/models/gpt-5-5-pro.json
+++ b/models/gpt-5-5-pro.json
@@ -9,7 +9,8 @@
       "note": {
         "zh": "以 GPT-5.5 Pro（开启 Extended Pro）生成；本页为修复版（仅改 1 行）。问题：14 张贴图排成 8×2 图集、第二行只画了 6 格，UV 按左上原点计算却未设 flipY=false，两行贴图上下互换采样。修复前：草地顶面显示成黑曜石（地面全黑），树叶、沙子采到未绘制的空格（大片纯黑），放置方块的贴图互相串行、颜色诡异似反色。原因：CanvasTexture 默认 flipY=true，与自上而下的图集布局不匹配。加上 flipY=false 后地形与方块颜色全部正常。",
         "en": "Generated with GPT-5.5 Pro (Extended Pro enabled); fixed build (1 line changed). Bug: 14 tiles in an 8x2 atlas with only 6 slots drawn in row two, UVs computed from a top-left origin without flipY=false, so the two rows swapped on sampling. Before the fix: grass tops rendered as obsidian (black ground), leaves and sand hit undrawn slots (large black patches), and placed blocks wore each other's textures with inverted-looking colors. Cause: CanvasTexture defaults to flipY=true, mismatching the top-down atlas layout. With flipY=false everything renders correctly."
-      }
+      },
+      "contributor": "Nagi-ovo"
     }
   }
 }
diff --git a/models/gpt-5-5-xhigh.json b/models/gpt-5-5-xhigh.json
index 710f6b2..539bdf6 100644
--- a/models/gpt-5-5-xhigh.json
+++ b/models/gpt-5-5-xhigh.json
@@ -9,13 +9,15 @@
       "note": {
         "zh": "全程在 Codex CLI 中生成（未使用任何 skill）；本页为修复版（仅改 1 行）。问题：移动向量的 Z 分量整体差一个负号（第 979 行，正确应为 -strafe*sin - forward*cos）。修复前：运动被沿 X 轴镜像——面朝 ±X 方向时按 A/D 左右颠倒，面朝 ±Z 时 W/S 前后颠倒，体感「左右移动方向不对」。原因：Three.js 相机在 yaw=0 时朝 -Z，推导前进/侧移向量时把这个约定弄反了。给 Z 分量取负后，任意朝向下八方向移动全部正确。",
         "en": "Generated entirely in Codex CLI (no skills); fixed build (1 line changed). Bug: the movement vector's Z component had its sign flipped (line 979; correct form is -strafe*sin - forward*cos). Before the fix movement was mirrored across the X axis — A/D swapped when facing +-X, W/S swapped when facing +-Z, i.e. \"strafing goes the wrong way\". Cause: a Three.js camera faces -Z at yaw 0, and the forward/right derivation inverted that convention. Negating Z makes all eight directions correct at any heading."
-      }
+      },
+      "contributor": "Nagi-ovo"
     },
     "pelican-cycling": {
       "note": {
         "zh": "由社区 PR #3（Codex 工作流）提交，提交者未注明运行环境与思考档位。",
         "en": "Contributed via community PR #3 (a Codex workflow); the submitter did not specify the runtime or effort level."
-      }
+      },
+      "contributor": "XA2333"
     }
   }
 }
diff --git a/models/grok-build.json b/models/grok-build.json
index 9a0c653..d3b5ff0 100644
--- a/models/grok-build.json
+++ b/models/grok-build.json
@@ -9,7 +9,8 @@
       "note": {
         "zh": "在本地通过 Grok Build（TUI）开发实现；本页为修复版（共改 3 行）。问题一：第 82 行 const WORLD_SEED = 0xAETHER，T/H/R 不是十六进制字符，整段脚本解析即抛 SyntaxError——修复前画面纯黑，只剩 HTML 文字。问题二：贴图集画在 canvas 顶部两行、UV 按左上原点计算，却未设 flipY=false，所有面采样到未绘制的黑色区域——修复前进入世界后近处地形全黑。问题三：forward 向量已指向相机朝向，按键却写成 W 减、S 加——修复前按 W 后退、按 S 前进（A/D 正常）。三处均为一行级修正，其余保持 Grok 原样。",
         "en": "Built locally with the Grok Build TUI; fixed build (3 lines changed). Bug 1: line 82 const WORLD_SEED = 0xAETHER — T/H/R are not hex digits, so the whole script threw a SyntaxError at parse time; before the fix the screen was pure black with only HTML text. Bug 2: the atlas is drawn in the top canvas rows with top-left-origin UVs but no flipY=false, so every face sampled the undrawn black region; before the fix nearby terrain rendered solid black. Bug 3: the forward vector already points where the camera looks, but W subtracted and S added — W walked backward (A/D were fine). One line each; everything else is Grok as-is."
-      }
+      },
+      "contributor": "Nagi-ovo"
     }
   }
 }
diff --git a/models/xiaomi-mimo-v2-5-pro.json b/models/xiaomi-mimo-v2-5-pro.json
new file mode 100644
index 0000000..99f5187
--- /dev/null
+++ b/models/xiaomi-mimo-v2-5-pro.json
@@ -0,0 +1,23 @@
+{
+  "label": "MiMo v2.5 Pro",
+  "vendor": "Xiaomi",
+  "harness": "Claude Code",
+  "effort": "Max",
+  "order": 97,
+  "runs": {
+    "mythos-craft": {
+      "note": {
+        "zh": "在 Claude Code 中以 MiMo v2.5 Pro（最高思考强度）一次生成，未修复。包含 Perlin 噪声地形、WASD + 鼠标第一人称操控、12 种方块类型（含水、黑曜石、水晶、金块等）、程序化材质纹理、四种神话建筑（水晶塔、石环阵、龙骨遗迹、天空遗迹），按 G 可依次传送至神话建筑，小地图显示玩家位置和地标。",
+        "en": "Generated in one shot via Claude Code with MiMo v2.5 Pro (max thinking effort), no fixes. Features Perlin noise terrain, WASD + mouse first-person controls, 12 block types (including water, obsidian, crystal, gold), procedural textures, and four mythic structures (Crystal Tower, Stone Circle, Dragon Skeleton, Sky Ruins). Press G to cycle-teleport between landmarks; minimap shows player position and landmarks."
+      },
+      "contributor": "Mintcolour"
+    },
+    "pelican-cycling": {
+      "note": {
+        "zh": "在 Claude Code 中以 MiMo v2.5 Pro（最高思考强度）一次生成。场景包含渐变天空、太阳、云朵、海洋波浪、沙滩、棕榈树、海鸥、完整自行车细节（辐条、链条、齿轮、脚踏）以及鹈鹕（长喙、喉囊、羽翼、踩踏姿态），海滩上有海星和贝壳装饰。",
+        "en": "Generated in one shot via Claude Code with MiMo v2.5 Pro (max thinking effort). Scene includes gradient sky, sun, clouds, ocean waves, beach, palm trees, seagulls, detailed bicycle (spokes, chain, gears, pedals), and a pelican (beak, gular pouch, wings, pedaling pose), with starfish and shell decorations on the beach."
+      },
+      "contributor": "Mintcolour"
+    }
+  }
+}
diff --git a/outputs/xiaomi-mimo-v2-5-pro/mythos-craft.html b/outputs/xiaomi-mimo-v2-5-pro/mythos-craft.html
new file mode 100644
index 0000000..ac2ea86
--- /dev/null
+++ b/outputs/xiaomi-mimo-v2-5-pro/mythos-craft.html
@@ -0,0 +1,1145 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Mythos Craft - MiMo v2.5 Pro</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { overflow: hidden; background: #000; font-family: 'Courier New', monospace; }
+        #blocker {
+            position: fixed; top: 0; left: 0; width: 100%; height: 100%;
+            background: rgba(0,0,0,0.7); display: flex; align-items: center;
+            justify-content: center; z-index: 100; cursor: pointer;
+        }
+        #instructions {
+            color: #fff; text-align: center; padding: 40px;
+            background: rgba(0,0,0,0.8); border: 2px solid #4a9eff;
+            border-radius: 10px; max-width: 500px;
+        }
+        #instructions h1 { font-size: 36px; color: #4a9eff; margin-bottom: 20px; }
+        #instructions p { margin: 10px 0; line-height: 1.6; }
+        #instructions .key {
+            display: inline-block; background: #333; padding: 2px 8px;
+            border-radius: 4px; border: 1px solid #666; margin: 0 2px;
+        }
+        #crosshair {
+            position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
+            width: 20px; height: 20px; z-index: 10; pointer-events: none;
+        }
+        #crosshair::before, #crosshair::after {
+            content: ''; position: absolute; background: rgba(255,255,255,0.8);
+        }
+        #crosshair::before { width: 2px; height: 20px; left: 9px; top: 0; }
+        #crosshair::after { width: 20px; height: 2px; top: 9px; left: 0; }
+        #hud {
+            position: fixed; bottom: 20px; left: 50%; transform: translateX(-50%);
+            display: flex; gap: 4px; z-index: 10; background: rgba(0,0,0,0.5);
+            padding: 8px; border-radius: 8px;
+        }
+        .slot {
+            width: 50px; height: 50px; border: 2px solid #555;
+            display: flex; align-items: center; justify-content: center;
+            cursor: pointer; position: relative; background: rgba(0,0,0,0.3);
+        }
+        .slot.active { border-color: #4a9eff; background: rgba(74,158,255,0.2); }
+        .slot .block-preview { width: 36px; height: 36px; border-radius: 4px; }
+        .slot .slot-num {
+            position: absolute; top: 2px; left: 4px; color: #aaa;
+            font-size: 10px;
+        }
+        #info {
+            position: fixed; top: 10px; left: 10px; color: #fff;
+            font-size: 14px; z-index: 10; text-shadow: 1px 1px 2px #000;
+        }
+        #info div { margin: 4px 0; }
+        #minimap {
+            position: fixed; top: 10px; right: 10px; width: 150px; height: 150px;
+            border: 2px solid #4a9eff; z-index: 10; background: #1a1a2e;
+        }
+        #landmark-indicator {
+            position: fixed; top: 50%; left: 50%; transform: translate(-50%, -80px);
+            color: #ffd700; font-size: 16px; z-index: 10; text-shadow: 1px 1px 2px #000;
+            pointer-events: none; text-align: center; display: none;
+        }
+    </style>
+</head>
+<body>
+    <div id="blocker">
+        <div id="instructions">
+            <h1>🏛️ Mythos Craft</h1>
+            <p>A Minecraft-style voxel world with mythic structures</p>
+            <p style="margin-top: 20px;">
+                <span class="key">W</span><span class="key">A</span><span class="key">S</span><span class="key">D</span> Move
+                <span class="key">Space</span> Jump
+            </p>
+            <p>
+                <span class="key">Mouse</span> Look
+                <span class="key">Left Click</span> Break
+                <span class="key">Right Click</span> Place
+            </p>
+            <p>
+                <span class="key">1-9</span> Select Block
+                <span class="key">G</span> Teleport to Landmark
+            </p>
+            <p style="color: #ffd700; margin-top: 20px;">Click to start</p>
+            <p style="color: #888; font-size: 12px; margin-top: 10px;">Generated by MiMo v2.5 Pro</p>
+        </div>
+    </div>
+
+    <div id="crosshair"></div>
+    <div id="hud"></div>
+    <div id="info">
+        <div>FPS: <span id="fps">0</span></div>
+        <div>Position: <span id="pos">0, 0, 0</span></div>
+        <div>Block: <span id="block-name">Grass</span></div>
+    </div>
+    <canvas id="minimap"></canvas>
+    <div id="landmark-indicator"></div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script>
+    // ============================================================
+    // PERLIN NOISE IMPLEMENTATION
+    // ============================================================
+    class PerlinNoise {
+        constructor(seed = 0) {
+            this.p = new Uint8Array(512);
+            const perm = new Uint8Array(256);
+            for (let i = 0; i < 256; i++) perm[i] = i;
+
+            // Fisher-Yates shuffle with seed
+            let s = seed;
+            for (let i = 255; i > 0; i--) {
+                s = (s * 16807 + 0) % 2147483647;
+                const j = s % (i + 1);
+                [perm[i], perm[j]] = [perm[j], perm[i]];
+            }
+
+            for (let i = 0; i < 512; i++) {
+                this.p[i] = perm[i & 255];
+            }
+        }
+
+        fade(t) { return t * t * t * (t * (t * 6 - 15) + 10); }
+        lerp(t, a, b) { return a + t * (b - a); }
+        grad(hash, x, y, z) {
+            const h = hash & 15;
+            const u = h < 8 ? x : y;
+            const v = h < 4 ? y : (h === 12 || h === 14 ? x : z);
+            return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+        }
+
+        noise(x, y, z) {
+            const X = Math.floor(x) & 255;
+            const Y = Math.floor(y) & 255;
+            const Z = Math.floor(z) & 255;
+
+            x -= Math.floor(x);
+            y -= Math.floor(y);
+            z -= Math.floor(z);
+
+            const u = this.fade(x);
+            const v = this.fade(y);
+            const w = this.fade(z);
+
+            const A = this.p[X] + Y;
+            const AA = this.p[A] + Z;
+            const AB = this.p[A + 1] + Z;
+            const B = this.p[X + 1] + Y;
+            const BA = this.p[B] + Z;
+            const BB = this.p[B + 1] + Z;
+
+            return this.lerp(w,
+                this.lerp(v,
+                    this.lerp(u, this.grad(this.p[AA], x, y, z), this.grad(this.p[BA], x-1, y, z)),
+                    this.lerp(u, this.grad(this.p[AB], x, y-1, z), this.grad(this.p[BB], x-1, y-1, z))
+                ),
+                this.lerp(v,
+                    this.lerp(u, this.grad(this.p[AA+1], x, y, z-1), this.grad(this.p[BA+1], x-1, y, z-1)),
+                    this.lerp(u, this.grad(this.p[AB+1], x, y-1, z-1), this.grad(this.p[BB+1], x-1, y-1, z-1))
+                )
+            );
+        }
+
+        octave(x, y, z, octaves = 4, persistence = 0.5) {
+            let total = 0, frequency = 1, amplitude = 1, maxValue = 0;
+            for (let i = 0; i < octaves; i++) {
+                total += this.noise(x * frequency, y * frequency, z * frequency) * amplitude;
+                maxValue += amplitude;
+                amplitude *= persistence;
+                frequency *= 2;
+            }
+            return total / maxValue;
+        }
+    }
+
+    // ============================================================
+    // BLOCK TYPES
+    // ============================================================
+    const BLOCKS = {
+        AIR: 0,
+        GRASS: 1,
+        DIRT: 2,
+        STONE: 3,
+        SAND: 4,
+        WATER: 5,
+        WOOD: 6,
+        LEAVES: 7,
+        COBBLESTONE: 8,
+        SNOW: 9,
+        CRYSTAL: 10,
+        GOLD: 11,
+        OBSIDIAN: 12
+    };
+
+    const BLOCK_COLORS = {
+        [BLOCKS.GRASS]: { top: 0x4CAF50, side: 0x8B6914, bottom: 0x8B6914 },
+        [BLOCKS.DIRT]: { top: 0x8B6914, side: 0x8B6914, bottom: 0x8B6914 },
+        [BLOCKS.STONE]: { top: 0x808080, side: 0x808080, bottom: 0x808080 },
+        [BLOCKS.SAND]: { top: 0xF4D03F, side: 0xF4D03F, bottom: 0xF4D03F },
+        [BLOCKS.WATER]: { top: 0x3498DB, side: 0x2980B9, bottom: 0x2471A3 },
+        [BLOCKS.WOOD]: { top: 0x6D4C41, side: 0x5D4037, bottom: 0x6D4C41 },
+        [BLOCKS.LEAVES]: { top: 0x2E7D32, side: 0x2E7D32, bottom: 0x2E7D32 },
+        [BLOCKS.COBBLESTONE]: { top: 0x757575, side: 0x757575, bottom: 0x757575 },
+        [BLOCKS.SNOW]: { top: 0xFFFFFF, side: 0xE8E8E8, bottom: 0xE8E8E8 },
+        [BLOCKS.CRYSTAL]: { top: 0x00BCD4, side: 0x00ACC1, bottom: 0x0097A7 },
+        [BLOCKS.GOLD]: { top: 0xFFD700, side: 0xFFC107, bottom: 0xFFB300 },
+        [BLOCKS.OBSIDIAN]: { top: 0x1A1A2E, side: 0x16213E, bottom: 0x0F3460 }
+    };
+
+    const BLOCK_NAMES = {
+        [BLOCKS.GRASS]: 'Grass', [BLOCKS.DIRT]: 'Dirt', [BLOCKS.STONE]: 'Stone',
+        [BLOCKS.SAND]: 'Sand', [BLOCKS.WATER]: 'Water', [BLOCKS.WOOD]: 'Wood',
+        [BLOCKS.LEAVES]: 'Leaves', [BLOCKS.COBBLESTONE]: 'Cobblestone',
+        [BLOCKS.SNOW]: 'Snow', [BLOCKS.CRYSTAL]: 'Crystal', [BLOCKS.GOLD]: 'Gold',
+        [BLOCKS.OBSIDIAN]: 'Obsidian'
+    };
+
+    // ============================================================
+    // GAME STATE
+    // ============================================================
+    const CHUNK_SIZE = 16;
+    const RENDER_DISTANCE = 4;
+    const WORLD_SEED = 42;
+
+    const noise = new PerlinNoise(WORLD_SEED);
+    const chunks = new Map();
+    const scene = new THREE.Scene();
+    scene.background = new THREE.Color(0x87CEEB);
+    scene.fog = new THREE.Fog(0x87CEEB, 50, 120);
+
+    const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 200);
+    const renderer = new THREE.WebGLRenderer({ antialias: true });
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.shadowMap.enabled = true;
+    document.body.appendChild(renderer.domElement);
+
+    // Player state
+    const player = {
+        position: new THREE.Vector3(0, 40, 0),
+        velocity: new THREE.Vector3(0, 0, 0),
+        rotation: { x: 0, y: 0 },
+        onGround: false,
+        selectedSlot: 0,
+        speed: 5,
+        jumpForce: 8,
+        gravity: -20
+    };
+
+    const inventory = [
+        BLOCKS.GRASS, BLOCKS.DIRT, BLOCKS.STONE, BLOCKS.SAND,
+        BLOCKS.WOOD, BLOCKS.LEAVES, BLOCKS.COBBLESTONE, BLOCKS.SNOW, BLOCKS.CRYSTAL
+    ];
+
+    const keys = {};
+    let isLocked = false;
+    let lastTime = performance.now();
+    let frameCount = 0;
+    let fps = 0;
+
+    // ============================================================
+    // MYTHIC LANDMARKS
+    // ============================================================
+    const landmarks = [
+        { name: 'Crystal Tower', x: 50, z: 50, teleportY: 45 },
+        { name: 'Stone Circle', x: -60, z: 40, teleportY: 35 },
+        { name: 'Dragon Skeleton', x: 40, z: -70, teleportY: 40 },
+        { name: 'Sky Ruins', x: -50, z: -60, teleportY: 60 }
+    ];
+    let currentLandmark = -1;
+
+    // ============================================================
+    // TEXTURE GENERATION
+    // ============================================================
+    function createBlockTexture(blockType, face) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 16;
+        canvas.height = 16;
+        const ctx = canvas.getContext('2d');
+        const colors = BLOCK_COLORS[blockType];
+        const color = face === 'top' ? colors.top : (face === 'bottom' ? colors.bottom : colors.side);
+
+        // Base color
+        ctx.fillStyle = `#${color.toString(16).padStart(6, '0')}`;
+        ctx.fillRect(0, 0, 16, 16);
+
+        // Add texture details
+        if (blockType === BLOCKS.GRASS && face === 'top') {
+            // Grass blades
+            ctx.fillStyle = '#388E3C';
+            for (let i = 0; i < 20; i++) {
+                const x = Math.random() * 16;
+                const y = Math.random() * 16;
+                ctx.fillRect(x, y, 1, 2);
+            }
+        } else if (blockType === BLOCKS.GRASS && face === 'side') {
+            // Dirt with grass top
+            ctx.fillStyle = '#4CAF50';
+            ctx.fillRect(0, 0, 16, 3);
+        } else if (blockType === BLOCKS.STONE || blockType === BLOCKS.COBBLESTONE) {
+            // Stone cracks
+            ctx.fillStyle = '#616161';
+            for (let i = 0; i < 5; i++) {
+                ctx.beginPath();
+                ctx.moveTo(Math.random() * 16, Math.random() * 16);
+                ctx.lineTo(Math.random() * 16, Math.random() * 16);
+                ctx.stroke();
+            }
+        } else if (blockType === BLOCKS.WOOD && face === 'side') {
+            // Wood grain
+            ctx.fillStyle = '#4E342E';
+            for (let y = 0; y < 16; y += 4) {
+                ctx.fillRect(0, y, 16, 1);
+            }
+        } else if (blockType === BLOCKS.LEAVES) {
+            // Leaf holes
+            ctx.fillStyle = '#1B5E20';
+            for (let i = 0; i < 8; i++) {
+                ctx.fillRect(Math.random() * 14, Math.random() * 14, 2, 2);
+            }
+        } else if (blockType === BLOCKS.CRYSTAL) {
+            // Crystal shine
+            ctx.fillStyle = 'rgba(255,255,255,0.3)';
+            ctx.fillRect(2, 2, 4, 4);
+            ctx.fillRect(10, 8, 3, 3);
+        } else if (blockType === BLOCKS.GOLD) {
+            // Gold sparkle
+            ctx.fillStyle = 'rgba(255,255,255,0.4)';
+            ctx.fillRect(4, 4, 2, 2);
+            ctx.fillRect(10, 10, 2, 2);
+        }
+
+        const texture = new THREE.CanvasTexture(canvas);
+        texture.magFilter = THREE.NearestFilter;
+        texture.minFilter = THREE.NearestFilter;
+        return texture;
+    }
+
+    function createBlockMaterial(blockType) {
+        return {
+            top: new THREE.MeshLambertMaterial({ map: createBlockTexture(blockType, 'top') }),
+            side: new THREE.MeshLambertMaterial({ map: createBlockTexture(blockType, 'side') }),
+            bottom: new THREE.MeshLambertMaterial({ map: createBlockTexture(blockType, 'bottom') })
+        };
+    }
+
+    const blockMaterials = {};
+    for (const type of Object.values(BLOCKS)) {
+        if (type !== BLOCKS.AIR) {
+            blockMaterials[type] = createBlockMaterial(type);
+        }
+    }
+
+    // ============================================================
+    // CHUNK MANAGEMENT
+    // ============================================================
+    function getChunkKey(cx, cz) {
+        return `${cx},${cz}`;
+    }
+
+    function getHeight(x, z) {
+        // Multi-octave terrain
+        const base = noise.octave(x * 0.01, 0, z * 0.01, 4, 0.5) * 20 + 25;
+        const mountains = Math.max(0, noise.octave(x * 0.005, 0, z * 0.005, 3, 0.6)) * 30;
+        return Math.floor(base + mountains);
+    }
+
+    function getBiome(x, z) {
+        const temp = noise.octave(x * 0.003, 0, z * 0.003, 2, 0.5);
+        const moisture = noise.octave(x * 0.004, 100, z * 0.004, 2, 0.5);
+
+        if (temp > 0.3) return 'desert';
+        if (temp < -0.3) return 'snow';
+        if (moisture > 0.2) return 'forest';
+        return 'plains';
+    }
+
+    function generateChunk(cx, cz) {
+        const key = getChunkKey(cx, cz);
+        if (chunks.has(key)) return chunks.get(key);
+
+        const chunk = {
+            blocks: new Uint8Array(CHUNK_SIZE * 256 * CHUNK_SIZE),
+            mesh: null,
+            dirty: true
+        };
+
+        // Generate terrain
+        for (let x = 0; x < CHUNK_SIZE; x++) {
+            for (let z = 0; z < CHUNK_SIZE; z++) {
+                const worldX = cx * CHUNK_SIZE + x;
+                const worldZ = cz * CHUNK_SIZE + z;
+                const height = getHeight(worldX, worldZ);
+                const biome = getBiome(worldX, worldZ);
+
+                for (let y = 0; y < 256; y++) {
+                    const idx = x + y * CHUNK_SIZE + z * CHUNK_SIZE * 256;
+
+                    if (y === 0) {
+                        chunk.blocks[idx] = BLOCKS.STONE;
+                    } else if (y < height - 4) {
+                        chunk.blocks[idx] = BLOCKS.STONE;
+                    } else if (y < height) {
+                        chunk.blocks[idx] = biome === 'desert' ? BLOCKS.SAND : BLOCKS.DIRT;
+                    } else if (y === height) {
+                        if (biome === 'desert') chunk.blocks[idx] = BLOCKS.SAND;
+                        else if (biome === 'snow') chunk.blocks[idx] = BLOCKS.SNOW;
+                        else chunk.blocks[idx] = BLOCKS.GRASS;
+                    } else if (y <= 20 && y > height) {
+                        chunk.blocks[idx] = BLOCKS.WATER;
+                    } else {
+                        chunk.blocks[idx] = BLOCKS.AIR;
+                    }
+                }
+
+                // Trees
+                if (height > 20 && biome === 'forest' && Math.random() < 0.03) {
+                    const treeHeight = 4 + Math.floor(Math.random() * 3);
+                    for (let ty = 1; ty <= treeHeight; ty++) {
+                        const idx = x + (height + ty) * CHUNK_SIZE + z * CHUNK_SIZE * 256;
+                        chunk.blocks[idx] = BLOCKS.WOOD;
+                    }
+                    // Leaves
+                    for (let lx = -2; lx <= 2; lx++) {
+                        for (let lz = -2; lz <= 2; lz++) {
+                            for (let ly = treeHeight - 1; ly <= treeHeight + 1; ly++) {
+                                const nx = x + lx, nz = z + lz;
+                                if (nx >= 0 && nx < CHUNK_SIZE && nz >= 0 && nz < CHUNK_SIZE) {
+                                    const idx = nx + (height + ly) * CHUNK_SIZE + nz * CHUNK_SIZE * 256;
+                                    if (chunk.blocks[idx] === BLOCKS.AIR) {
+                                        chunk.blocks[idx] = BLOCKS.LEAVES;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        chunks.set(key, chunk);
+        return chunk;
+    }
+
+    function getBlock(x, y, z) {
+        if (y < 0 || y >= 256) return BLOCKS.AIR;
+        const cx = Math.floor(x / CHUNK_SIZE);
+        const cz = Math.floor(z / CHUNK_SIZE);
+        const key = getChunkKey(cx, cz);
+        const chunk = chunks.get(key);
+        if (!chunk) return BLOCKS.AIR;
+
+        const lx = ((x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
+        const lz = ((z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
+        return chunk.blocks[lx + y * CHUNK_SIZE + lz * CHUNK_SIZE * 256];
+    }
+
+    function setBlock(x, y, z, type) {
+        if (y < 0 || y >= 256) return;
+        const cx = Math.floor(x / CHUNK_SIZE);
+        const cz = Math.floor(z / CHUNK_SIZE);
+        const key = getChunkKey(cx, cz);
+        let chunk = chunks.get(key);
+
+        if (!chunk) {
+            chunk = generateChunk(cx, cz);
+        }
+
+        const lx = ((x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
+        const lz = ((z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
+        chunk.blocks[lx + y * CHUNK_SIZE + lz * CHUNK_SIZE * 256] = type;
+        chunk.dirty = true;
+
+        // Mark adjacent chunks dirty if on border
+        if (lx === 0) markChunkDirty(cx - 1, cz);
+        if (lx === CHUNK_SIZE - 1) markChunkDirty(cx + 1, cz);
+        if (lz === 0) markChunkDirty(cx, cz - 1);
+        if (lz === CHUNK_SIZE - 1) markChunkDirty(cx, cz + 1);
+    }
+
+    function markChunkDirty(cx, cz) {
+        const key = getChunkKey(cx, cz);
+        const chunk = chunks.get(key);
+        if (chunk) chunk.dirty = true;
+    }
+
+    function buildChunkMesh(chunk, cx, cz) {
+        if (chunk.mesh) {
+            scene.remove(chunk.mesh);
+            chunk.mesh.geometry.dispose();
+        }
+
+        const geometry = new THREE.BufferGeometry();
+        const vertices = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        const colors = [];
+
+        for (let x = 0; x < CHUNK_SIZE; x++) {
+            for (let y = 0; y < 256; y++) {
+                for (let z = 0; z < CHUNK_SIZE; z++) {
+                    const block = chunk.blocks[x + y * CHUNK_SIZE + z * CHUNK_SIZE * 256];
+                    if (block === BLOCKS.AIR) continue;
+
+                    const worldX = cx * CHUNK_SIZE + x;
+                    const worldZ = cz * CHUNK_SIZE + z;
+                    const blockColors = BLOCK_COLORS[block];
+
+                    // Check each face
+                    const faces = [
+                        { dir: [0, 1, 0], color: blockColors.top, normal: [0, 1, 0] },
+                        { dir: [0, -1, 0], color: blockColors.bottom, normal: [0, -1, 0] },
+                        { dir: [1, 0, 0], color: blockColors.side, normal: [1, 0, 0] },
+                        { dir: [-1, 0, 0], color: blockColors.side, normal: [-1, 0, 0] },
+                        { dir: [0, 0, 1], color: blockColors.side, normal: [0, 0, 1] },
+                        { dir: [0, 0, -1], color: blockColors.side, normal: [0, 0, -1] }
+                    ];
+
+                    for (const face of faces) {
+                        const nx = worldX + face.dir[0];
+                        const ny = y + face.dir[1];
+                        const nz = worldZ + face.dir[2];
+                        const neighbor = getBlock(nx, ny, nz);
+
+                        if (neighbor === BLOCKS.AIR || (neighbor === BLOCKS.WATER && block !== BLOCKS.WATER)) {
+                            const vertexIndex = vertices.length / 3;
+
+                            // Add face vertices
+                            if (face.dir[1] === 1) { // Top
+                                vertices.push(worldX, y + 1, worldZ);
+                                vertices.push(worldX + 1, y + 1, worldZ);
+                                vertices.push(worldX + 1, y + 1, worldZ + 1);
+                                vertices.push(worldX, y + 1, worldZ + 1);
+                            } else if (face.dir[1] === -1) { // Bottom
+                                vertices.push(worldX, y, worldZ + 1);
+                                vertices.push(worldX + 1, y, worldZ + 1);
+                                vertices.push(worldX + 1, y, worldZ);
+                                vertices.push(worldX, y, worldZ);
+                            } else if (face.dir[0] === 1) { // Right
+                                vertices.push(worldX + 1, y, worldZ);
+                                vertices.push(worldX + 1, y + 1, worldZ);
+                                vertices.push(worldX + 1, y + 1, worldZ + 1);
+                                vertices.push(worldX + 1, y, worldZ + 1);
+                            } else if (face.dir[0] === -1) { // Left
+                                vertices.push(worldX, y, worldZ + 1);
+                                vertices.push(worldX, y + 1, worldZ + 1);
+                                vertices.push(worldX, y + 1, worldZ);
+                                vertices.push(worldX, y, worldZ);
+                            } else if (face.dir[2] === 1) { // Front
+                                vertices.push(worldX + 1, y, worldZ + 1);
+                                vertices.push(worldX + 1, y + 1, worldZ + 1);
+                                vertices.push(worldX, y + 1, worldZ + 1);
+                                vertices.push(worldX, y, worldZ + 1);
+                            } else { // Back
+                                vertices.push(worldX, y, worldZ);
+                                vertices.push(worldX, y + 1, worldZ);
+                                vertices.push(worldX + 1, y + 1, worldZ);
+                                vertices.push(worldX + 1, y, worldZ);
+                            }
+
+                            // Add normals
+                            for (let i = 0; i < 4; i++) {
+                                normals.push(...face.normal);
+                            }
+
+                            // Add colors
+                            const r = ((face.color >> 16) & 0xFF) / 255;
+                            const g = ((face.color >> 8) & 0xFF) / 255;
+                            const b = (face.color & 0xFF) / 255;
+                            for (let i = 0; i < 4; i++) {
+                                colors.push(r, g, b);
+                            }
+
+                            // Add UVs
+                            uvs.push(0, 0, 1, 0, 1, 1, 0, 1);
+
+                            // Add indices
+                            indices.push(
+                                vertexIndex, vertexIndex + 1, vertexIndex + 2,
+                                vertexIndex, vertexIndex + 2, vertexIndex + 3
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        if (vertices.length === 0) return;
+
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        geometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
+        geometry.setIndex(indices);
+
+        const material = new THREE.MeshLambertMaterial({ vertexColors: true });
+        chunk.mesh = new THREE.Mesh(geometry, material);
+        scene.add(chunk.mesh);
+        chunk.dirty = false;
+    }
+
+    // ============================================================
+    // MYTHIC STRUCTURES
+    // ============================================================
+    function buildCrystalTower(cx, cz) {
+        const baseX = cx * CHUNK_SIZE + 7;
+        const baseZ = cz * CHUNK_SIZE + 7;
+        const baseY = getHeight(baseX, baseZ);
+
+        // Crystal tower
+        for (let y = 0; y < 20; y++) {
+            const radius = Math.max(1, 4 - Math.floor(y / 5));
+            for (let dx = -radius; dx <= radius; dx++) {
+                for (let dz = -radius; dz <= radius; dz++) {
+                    if (dx * dx + dz * dz <= radius * radius) {
+                        setBlock(baseX + dx, baseY + y, baseZ + dz, BLOCKS.CRYSTAL);
+                    }
+                }
+            }
+        }
+
+        // Top beacon
+        for (let y = 20; y < 25; y++) {
+            setBlock(baseX, baseY + y, baseZ, BLOCKS.GOLD);
+        }
+    }
+
+    function buildStoneCircle(cx, cz) {
+        const baseX = cx * CHUNK_SIZE + 8;
+        const baseZ = cz * CHUNK_SIZE + 8;
+        const baseY = getHeight(baseX, baseZ);
+
+        // Stone circle
+        for (let i = 0; i < 8; i++) {
+            const angle = (i / 8) * Math.PI * 2;
+            const x = Math.round(baseX + Math.cos(angle) * 6);
+            const z = Math.round(baseZ + Math.sin(angle) * 6);
+
+            // Standing stones
+            for (let y = 0; y < 5; y++) {
+                setBlock(x, baseY + y, z, BLOCKS.COBBLESTONE);
+            }
+            // Cap stone
+            setBlock(x, baseY + 5, z, BLOCKS.COBBLESTONE);
+        }
+
+        // Central altar
+        for (let dx = -1; dx <= 1; dx++) {
+            for (let dz = -1; dz <= 1; dz++) {
+                setBlock(baseX + dx, baseY, baseZ + dz, BLOCKS.OBSIDIAN);
+                setBlock(baseX + dx, baseY + 1, baseZ + dz, BLOCKS.GOLD);
+            }
+        }
+    }
+
+    function buildDragonSkeleton(cx, cz) {
+        const baseX = cx * CHUNK_SIZE + 4;
+        const baseZ = cz * CHUNK_SIZE + 4;
+        const baseY = getHeight(baseX, baseZ);
+
+        // Spine
+        for (let i = 0; i < 12; i++) {
+            const x = baseX + i;
+            const y = baseY + Math.floor(Math.sin(i * 0.3) * 2) + 2;
+            setBlock(x, y, baseZ, BLOCKS.SNOW);
+            setBlock(x, y + 1, baseZ, BLOCKS.SNOW);
+        }
+
+        // Ribs
+        for (let i = 2; i < 10; i += 2) {
+            const x = baseX + i;
+            const y = baseY + Math.floor(Math.sin(i * 0.3) * 2) + 2;
+            for (let dz = -3; dz <= 3; dz++) {
+                if (Math.abs(dz) === 3) {
+                    setBlock(x, y - 1, baseZ + dz, BLOCKS.SNOW);
+                    setBlock(x, y - 2, baseZ + dz, BLOCKS.SNOW);
+                }
+            }
+        }
+
+        // Skull
+        for (let dx = 0; dx < 3; dx++) {
+            for (let dy = 0; dy < 3; dy++) {
+                for (let dz = -1; dz <= 1; dz++) {
+                    setBlock(baseX - 3 + dx, baseY + 3 + dy, baseZ + dz, BLOCKS.SNOW);
+                }
+            }
+        }
+
+        // Eye sockets
+        setBlock(baseX - 2, baseY + 4, baseZ - 1, BLOCKS.OBSIDIAN);
+        setBlock(baseX - 2, baseY + 4, baseZ + 1, BLOCKS.OBSIDIAN);
+
+        // Wings
+        for (let i = 0; i < 6; i++) {
+            const x = baseX + 4 + i;
+            const y = baseY + 5 + i;
+            setBlock(x, y, baseZ - 4, BLOCKS.SNOW);
+            setBlock(x, y, baseZ + 4, BLOCKS.SNOW);
+        }
+    }
+
+    function buildSkyRuins(cx, cz) {
+        const baseX = cx * CHUNK_SIZE + 6;
+        const baseZ = cz * CHUNK_SIZE + 6;
+        const baseY = getHeight(baseX, baseZ) + 15;
+
+        // Floating platform
+        for (let dx = -5; dx <= 5; dx++) {
+            for (let dz = -5; dz <= 5; dz++) {
+                if (Math.abs(dx) === 5 || Math.abs(dz) === 5) {
+                    setBlock(baseX + dx, baseY, baseZ + dz, BLOCKS.COBBLESTONE);
+                    setBlock(baseX + dx, baseY + 1, baseZ + dz, BLOCKS.COBBLESTONE);
+                }
+            }
+        }
+
+        // Corner pillars
+        const corners = [[-4, -4], [-4, 4], [4, -4], [4, 4]];
+        for (const [dx, dz] of corners) {
+            for (let y = -5; y <= 3; y++) {
+                setBlock(baseX + dx, baseY + y, baseZ + dz, BLOCKS.COBBLESTONE);
+            }
+        }
+
+        // Central structure
+        for (let dx = -2; dx <= 2; dx++) {
+            for (let dz = -2; dz <= 2; dz++) {
+                for (let y = 2; y <= 6; y++) {
+                    if (Math.abs(dx) === 2 || Math.abs(dz) === 2) {
+                        setBlock(baseX + dx, baseY + y, baseZ + dz, BLOCKS.COBBLESTONE);
+                    }
+                }
+            }
+        }
+
+        // Crystal on top
+        setBlock(baseX, baseY + 7, baseZ, BLOCKS.CRYSTAL);
+        setBlock(baseX, baseY + 8, baseZ, BLOCKS.GOLD);
+    }
+
+    // ============================================================
+    // LIGHTING
+    // ============================================================
+    const ambientLight = new THREE.AmbientLight(0x606060);
+    scene.add(ambientLight);
+
+    const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+    directionalLight.position.set(50, 100, 50);
+    directionalLight.castShadow = true;
+    scene.add(directionalLight);
+
+    const hemisphereLight = new THREE.HemisphereLight(0x87CEEB, 0x8B6914, 0.3);
+    scene.add(hemisphereLight);
+
+    // ============================================================
+    // CONTROLS
+    // ============================================================
+    document.addEventListener('click', () => {
+        if (!isLocked) {
+            renderer.domElement.requestPointerLock();
+        }
+    });
+
+    document.addEventListener('pointerlockchange', () => {
+        isLocked = document.pointerLockElement === renderer.domElement;
+        document.getElementById('blocker').style.display = isLocked ? 'none' : 'flex';
+    });
+
+    document.addEventListener('mousemove', (e) => {
+        if (!isLocked) return;
+        player.rotation.y -= e.movementX * 0.002;
+        player.rotation.x -= e.movementY * 0.002;
+        player.rotation.x = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, player.rotation.x));
+    });
+
+    document.addEventListener('keydown', (e) => {
+        keys[e.code] = true;
+
+        // Number keys for inventory
+        if (e.code >= 'Digit1' && e.code <= 'Digit9') {
+            player.selectedSlot = parseInt(e.code.slice(5)) - 1;
+            updateHUD();
+        }
+
+        // G key for teleport
+        if (e.code === 'KeyG') {
+            currentLandmark = (currentLandmark + 1) % landmarks.length;
+            const lm = landmarks[currentLandmark];
+            player.position.set(lm.x, lm.teleportY, lm.z);
+            player.velocity.set(0, 0, 0);
+            showLandmarkIndicator(lm.name);
+        }
+    });
+
+    document.addEventListener('keyup', (e) => keys[e.code] = false);
+
+    // Mouse click for breaking/placing
+    document.addEventListener('mousedown', (e) => {
+        if (!isLocked) return;
+
+        const direction = new THREE.Vector3(0, 0, -1);
+        direction.applyQuaternion(camera.quaternion);
+
+        const raycaster = new THREE.Raycaster(camera.position, direction, 0, 8);
+
+        // Simple raycast
+        let hitPos = null;
+        let hitNormal = null;
+
+        for (let t = 0; t < 8; t += 0.1) {
+            const x = Math.floor(camera.position.x + direction.x * t);
+            const y = Math.floor(camera.position.y + direction.y * t);
+            const z = Math.floor(camera.position.z + direction.z * t);
+
+            if (getBlock(x, y, z) !== BLOCKS.AIR) {
+                hitPos = { x, y, z };
+                hitNormal = {
+                    x: Math.floor(camera.position.x + direction.x * (t - 0.1)) - x,
+                    y: Math.floor(camera.position.y + direction.y * (t - 0.1)) - y,
+                    z: Math.floor(camera.position.z + direction.z * (t - 0.1)) - z
+                };
+                break;
+            }
+        }
+
+        if (hitPos) {
+            if (e.button === 0) { // Left click - break
+                setBlock(hitPos.x, hitPos.y, hitPos.z, BLOCKS.AIR);
+            } else if (e.button === 2) { // Right click - place
+                const px = hitPos.x + hitNormal.x;
+                const py = hitPos.y + hitNormal.y;
+                const pz = hitPos.z + hitNormal.z;
+
+                // Don't place inside player
+                const playerBlockX = Math.floor(player.position.x);
+                const playerBlockY = Math.floor(player.position.y);
+                const playerBlockZ = Math.floor(player.position.z);
+
+                if (!(px === playerBlockX && (py === playerBlockY || py === playerBlockY - 1) && pz === playerBlockZ)) {
+                    setBlock(px, py, pz, inventory[player.selectedSlot]);
+                }
+            }
+        }
+    });
+
+    // Prevent context menu
+    document.addEventListener('contextmenu', (e) => e.preventDefault());
+
+    // ============================================================
+    // HUD
+    // ============================================================
+    function createHUD() {
+        const hud = document.getElementById('hud');
+        hud.innerHTML = '';
+
+        for (let i = 0; i < 9; i++) {
+            const slot = document.createElement('div');
+            slot.className = `slot ${i === player.selectedSlot ? 'active' : ''}`;
+
+            const num = document.createElement('span');
+            num.className = 'slot-num';
+            num.textContent = i + 1;
+            slot.appendChild(num);
+
+            const preview = document.createElement('div');
+            preview.className = 'block-preview';
+            const color = BLOCK_COLORS[inventory[i]];
+            preview.style.background = `#${color.top.toString(16).padStart(6, '0')}`;
+            slot.appendChild(preview);
+
+            slot.addEventListener('click', () => {
+                player.selectedSlot = i;
+                updateHUD();
+            });
+
+            hud.appendChild(slot);
+        }
+    }
+
+    function updateHUD() {
+        const slots = document.querySelectorAll('.slot');
+        slots.forEach((slot, i) => {
+            slot.className = `slot ${i === player.selectedSlot ? 'active' : ''}`;
+        });
+        document.getElementById('block-name').textContent = BLOCK_NAMES[inventory[player.selectedSlot]];
+    }
+
+    // ============================================================
+    // MINIMAP
+    // ============================================================
+    function updateMinimap() {
+        const canvas = document.getElementById('minimap');
+        const ctx = canvas.getContext('2d');
+        canvas.width = 150;
+        canvas.height = 150;
+
+        const scale = 2;
+        const centerX = player.position.x;
+        const centerZ = player.position.z;
+
+        // Draw terrain
+        for (let px = 0; px < 150; px++) {
+            for (let pz = 0; pz < 150; pz++) {
+                const worldX = centerX + (px - 75) * scale;
+                const worldZ = centerZ + (pz - 75) * scale;
+                const height = getHeight(worldX, worldZ);
+                const biome = getBiome(worldX, worldZ);
+
+                let color;
+                if (height <= 20) color = '#3498DB';
+                else if (biome === 'desert') color = '#F4D03F';
+                else if (biome === 'snow') color = '#ECF0F1';
+                else if (biome === 'forest') color = '#27AE60';
+                else color = '#2ECC71';
+
+                ctx.fillStyle = color;
+                ctx.fillRect(px, pz, 1, 1);
+            }
+        }
+
+        // Draw landmarks
+        ctx.fillStyle = '#FFD700';
+        for (const lm of landmarks) {
+            const px = 75 + (lm.x - centerX) / scale;
+            const pz = 75 + (lm.z - centerZ) / scale;
+            if (px >= 0 && px < 150 && pz >= 0 && pz < 150) {
+                ctx.beginPath();
+                ctx.arc(px, pz, 3, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        }
+
+        // Draw player
+        ctx.fillStyle = '#FF0000';
+        ctx.beginPath();
+        ctx.arc(75, 75, 4, 0, Math.PI * 2);
+        ctx.fill();
+
+        // Draw direction
+        ctx.strokeStyle = '#FF0000';
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        ctx.moveTo(75, 75);
+        ctx.lineTo(75 + Math.sin(player.rotation.y) * 10, 75 - Math.cos(player.rotation.y) * 10);
+        ctx.stroke();
+    }
+
+    // ============================================================
+    // LANDMARK INDICATOR
+    // ============================================================
+    let landmarkTimeout = null;
+    function showLandmarkIndicator(name) {
+        const indicator = document.getElementById('landmark-indicator');
+        indicator.textContent = `📍 ${name}`;
+        indicator.style.display = 'block';
+
+        if (landmarkTimeout) clearTimeout(landmarkTimeout);
+        landmarkTimeout = setTimeout(() => {
+            indicator.style.display = 'none';
+        }, 2000);
+    }
+
+    // ============================================================
+    // PHYSICS
+    // ============================================================
+    function updatePhysics(dt) {
+        // Movement
+        const moveSpeed = player.speed * dt;
+        const forward = new THREE.Vector3(
+            -Math.sin(player.rotation.y) * moveSpeed,
+            0,
+            -Math.cos(player.rotation.y) * moveSpeed
+        );
+        const right = new THREE.Vector3(
+            Math.cos(player.rotation.y) * moveSpeed,
+            0,
+            -Math.sin(player.rotation.y) * moveSpeed
+        );
+
+        if (keys['KeyW']) player.position.add(forward);
+        if (keys['KeyS']) player.position.sub(forward);
+        if (keys['KeyA']) player.position.sub(right);
+        if (keys['KeyD']) player.position.add(right);
+
+        // Gravity
+        player.velocity.y += player.gravity * dt;
+        player.position.y += player.velocity.y * dt;
+
+        // Collision detection
+        const playerHeight = 1.8;
+        const playerWidth = 0.3;
+
+        // Check ground
+        const feetY = player.position.y - playerHeight;
+        const blockBelow = getBlock(
+            Math.floor(player.position.x),
+            Math.floor(feetY),
+            Math.floor(player.position.z)
+        );
+
+        if (blockBelow !== BLOCKS.AIR && blockBelow !== BLOCKS.WATER) {
+            player.position.y = Math.floor(feetY) + 1 + playerHeight;
+            player.velocity.y = 0;
+            player.onGround = true;
+        } else {
+            player.onGround = false;
+        }
+
+        // Jump
+        if (keys['Space'] && player.onGround) {
+            player.velocity.y = player.jumpForce;
+            player.onGround = false;
+        }
+
+        // Water physics
+        if (getBlock(Math.floor(player.position.x), Math.floor(player.position.y - 1), Math.floor(player.position.z)) === BLOCKS.WATER) {
+            player.velocity.y *= 0.9;
+            player.velocity.y += 2 * dt;
+        }
+
+        // Prevent falling through world
+        if (player.position.y < -10) {
+            player.position.set(0, 40, 0);
+            player.velocity.set(0, 0, 0);
+        }
+    }
+
+    // ============================================================
+    // GAME LOOP
+    // ============================================================
+    function updateChunks() {
+        const playerCX = Math.floor(player.position.x / CHUNK_SIZE);
+        const playerCZ = Math.floor(player.position.z / CHUNK_SIZE);
+
+        // Generate/load chunks
+        for (let dx = -RENDER_DISTANCE; dx <= RENDER_DISTANCE; dx++) {
+            for (let dz = -RENDER_DISTANCE; dz <= RENDER_DISTANCE; dz++) {
+                const cx = playerCX + dx;
+                const cz = playerCZ + dz;
+                const chunk = generateChunk(cx, cz);
+
+                // Build landmarks on first generation
+                if (chunk.dirty) {
+                    // Check if this chunk should have a landmark
+                    for (const lm of landmarks) {
+                        const lmCX = Math.floor(lm.x / CHUNK_SIZE);
+                        const lmCZ = Math.floor(lm.z / CHUNK_SIZE);
+                        if (lmCX === cx && lmCZ === cz) {
+                            if (lm.name === 'Crystal Tower') buildCrystalTower(cx, cz);
+                            else if (lm.name === 'Stone Circle') buildStoneCircle(cx, cz);
+                            else if (lm.name === 'Dragon Skeleton') buildDragonSkeleton(cx, cz);
+                            else if (lm.name === 'Sky Ruins') buildSkyRuins(cx, cz);
+                        }
+                    }
+                    buildChunkMesh(chunk, cx, cz);
+                }
+            }
+        }
+
+        // Unload distant chunks
+        for (const [key, chunk] of chunks) {
+            const [cx, cz] = key.split(',').map(Number);
+            if (Math.abs(cx - playerCX) > RENDER_DISTANCE + 2 || Math.abs(cz - playerCZ) > RENDER_DISTANCE + 2) {
+                if (chunk.mesh) {
+                    scene.remove(chunk.mesh);
+                    chunk.mesh.geometry.dispose();
+                }
+                chunks.delete(key);
+            }
+        }
+    }
+
+    function animate() {
+        requestAnimationFrame(animate);
+
+        const now = performance.now();
+        const dt = Math.min((now - lastTime) / 1000, 0.1);
+        lastTime = now;
+
+        // FPS counter
+        frameCount++;
+        if (frameCount % 30 === 0) {
+            fps = Math.round(1 / dt);
+            document.getElementById('fps').textContent = fps;
+        }
+
+        if (isLocked) {
+            updatePhysics(dt);
+            updateChunks();
+
+            // Update camera
+            camera.position.copy(player.position);
+            camera.rotation.order = 'YXZ';
+            camera.rotation.y = player.rotation.y;
+            camera.rotation.x = player.rotation.x;
+
+            // Update info
+            document.getElementById('pos').textContent =
+                `${Math.floor(player.position.x)}, ${Math.floor(player.position.y)}, ${Math.floor(player.position.z)}`;
+
+            // Update minimap every 10 frames
+            if (frameCount % 10 === 0) {
+                updateMinimap();
+            }
+        }
+
+        renderer.render(scene, camera);
+    }
+
+    // ============================================================
+    // INITIALIZATION
+    // ============================================================
+    function init() {
+        createHUD();
+        updateHUD();
+
+        // Find safe spawn point
+        const spawnX = 0, spawnZ = 0;
+        const spawnY = getHeight(spawnX, spawnZ) + 2;
+        player.position.set(spawnX, spawnY, spawnZ);
+
+        // Generate initial chunks
+        updateChunks();
+
+        // Start game loop
+        animate();
+
+        console.log('Mythos Craft initialized - MiMo v2.5 Pro');
+        console.log('Landmarks:', landmarks.map(l => l.name).join(', '));
+    }
+
+    // Handle window resize
+    window.addEventListener('resize', () => {
+        camera.aspect = window.innerWidth / window.innerHeight;
+        camera.updateProjectionMatrix();
+        renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+
+    // Start
+    init();
+    </script>
+</body>
+</html>
diff --git a/outputs/xiaomi-mimo-v2-5-pro/pelican-cycling.svg b/outputs/xiaomi-mimo-v2-5-pro/pelican-cycling.svg
new file mode 100644
index 0000000..0a15fe6
--- /dev/null
+++ b/outputs/xiaomi-mimo-v2-5-pro/pelican-cycling.svg
@@ -0,0 +1,226 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 600" width="800" height="600">
+  <!-- Sky gradient -->
+  <defs>
+    <linearGradient id="sky" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#87CEEB"/>
+      <stop offset="100%" style="stop-color:#E0F7FA"/>
+    </linearGradient>
+    <linearGradient id="water" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#2196F3"/>
+      <stop offset="100%" style="stop-color:#0D47A1"/>
+    </linearGradient>
+    <linearGradient id="sand" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#F4D03F"/>
+      <stop offset="100%" style="stop-color:#E6B800"/>
+    </linearGradient>
+  </defs>
+
+  <!-- Sky -->
+  <rect width="800" height="600" fill="url(#sky)"/>
+
+  <!-- Sun -->
+  <circle cx="650" cy="100" r="50" fill="#FFD700" opacity="0.9"/>
+  <circle cx="650" cy="100" r="45" fill="#FFF176"/>
+
+  <!-- Clouds -->
+  <g opacity="0.8">
+    <ellipse cx="150" cy="80" rx="60" ry="25" fill="white"/>
+    <ellipse cx="180" cy="70" rx="40" ry="20" fill="white"/>
+    <ellipse cx="120" cy="75" rx="35" ry="18" fill="white"/>
+
+    <ellipse cx="500" cy="120" rx="70" ry="28" fill="white"/>
+    <ellipse cx="530" cy="108" rx="45" ry="22" fill="white"/>
+    <ellipse cx="470" cy="115" rx="40" ry="20" fill="white"/>
+  </g>
+
+  <!-- Ocean -->
+  <path d="M0 400 Q200 380 400 390 Q600 400 800 385 L800 600 L0 600 Z" fill="url(#water)"/>
+
+  <!-- Waves -->
+  <path d="M0 420 Q100 410 200 420 Q300 430 400 420 Q500 410 600 420 Q700 430 800 420" stroke="#1976D2" stroke-width="3" fill="none" opacity="0.6"/>
+  <path d="M0 440 Q100 430 200 440 Q300 450 400 440 Q500 430 600 440 Q700 450 800 440" stroke="#1976D2" stroke-width="2" fill="none" opacity="0.4"/>
+
+  <!-- Beach -->
+  <path d="M0 400 Q200 380 400 390 Q600 400 800 385 L800 450 Q600 460 400 450 Q200 440 0 450 Z" fill="url(#sand)"/>
+
+  <!-- Wet sand -->
+  <path d="M0 430 Q200 420 400 425 Q600 430 800 420 L800 450 Q600 460 400 450 Q200 440 0 450 Z" fill="#D4A830" opacity="0.5"/>
+
+  <!-- Palm trees -->
+  <g transform="translate(100, 350)">
+    <!-- Trunk -->
+    <path d="M0 0 Q-5 -50 -2 -100 Q0 -120 5 -100 Q8 -50 3 0" fill="#8D6E63" stroke="#6D4C41" stroke-width="1"/>
+    <!-- Leaves -->
+    <path d="M5 -100 Q30 -130 60 -110" stroke="#2E7D32" stroke-width="8" fill="none" stroke-linecap="round"/>
+    <path d="M5 -100 Q-20 -140 -50 -120" stroke="#2E7D32" stroke-width="8" fill="none" stroke-linecap="round"/>
+    <path d="M5 -100 Q40 -150 70 -140" stroke="#388E3C" stroke-width="6" fill="none" stroke-linecap="round"/>
+    <path d="M5 -100 Q-30 -160 -60 -150" stroke="#388E3C" stroke-width="6" fill="none" stroke-linecap="round"/>
+    <!-- Coconuts -->
+    <circle cx="5" cy="-95" r="4" fill="#6D4C41"/>
+    <circle cx="10" cy="-92" r="3.5" fill="#795548"/>
+  </g>
+
+  <g transform="translate(700, 360)">
+    <!-- Trunk -->
+    <path d="M0 0 Q5 -40 2 -80 Q0 -100 -3 -80 Q-6 -40 -1 0" fill="#8D6E63" stroke="#6D4C41" stroke-width="1"/>
+    <!-- Leaves -->
+    <path d="M-3 -80 Q-30 -110 -55 -95" stroke="#2E7D32" stroke-width="7" fill="none" stroke-linecap="round"/>
+    <path d="M-3 -80 Q20 -120 45 -105" stroke="#2E7D32" stroke-width="7" fill="none" stroke-linecap="round"/>
+    <path d="M-3 -80 Q-40 -130 -65 -120" stroke="#388E3C" stroke-width="5" fill="none" stroke-linecap="round"/>
+    <path d="M-3 -80 Q30 -140 55 -130" stroke="#388E3C" stroke-width="5" fill="none" stroke-linecap="round"/>
+  </g>
+
+  <!-- Seagulls in distance -->
+  <g fill="none" stroke="#555" stroke-width="1.5" opacity="0.6">
+    <path d="M200 150 Q205 145 210 150 Q215 145 220 150"/>
+    <path d="M350 130 Q355 125 360 130 Q365 125 370 130"/>
+    <path d="M550 160 Q555 155 560 160 Q565 155 570 160"/>
+  </g>
+
+  <!-- Bicycle -->
+  <g transform="translate(350, 380)">
+    <!-- Rear wheel -->
+    <circle cx="-60" cy="30" r="35" fill="none" stroke="#333" stroke-width="4"/>
+    <circle cx="-60" cy="30" r="30" fill="none" stroke="#555" stroke-width="1"/>
+    <!-- Spokes -->
+    <line x1="-60" y1="0" x2="-60" y2="60" stroke="#777" stroke-width="0.8"/>
+    <line x1="-90" y1="30" x2="-30" y2="30" stroke="#777" stroke-width="0.8"/>
+    <line x1="-85" y1="8" x2="-35" y2="52" stroke="#777" stroke-width="0.8"/>
+    <line x1="-85" y1="52" x2="-35" y2="8" stroke="#777" stroke-width="0.8"/>
+    <!-- Rear hub -->
+    <circle cx="-60" cy="30" r="4" fill="#666"/>
+
+    <!-- Front wheel -->
+    <circle cx="70" cy="30" r="35" fill="none" stroke="#333" stroke-width="4"/>
+    <circle cx="70" cy="30" r="30" fill="none" stroke="#555" stroke-width="1"/>
+    <!-- Spokes -->
+    <line x1="70" y1="0" x2="70" y2="60" stroke="#777" stroke-width="0.8"/>
+    <line x1="40" y1="30" x2="100" y2="30" stroke="#777" stroke-width="0.8"/>
+    <line x1="45" y1="8" x2="95" y2="52" stroke="#777" stroke-width="0.8"/>
+    <line x1="45" y1="52" x2="95" y2="8" stroke="#777" stroke-width="0.8"/>
+    <!-- Front hub -->
+    <circle cx="70" cy="30" r="4" fill="#666"/>
+
+    <!-- Frame -->
+    <!-- Seat tube -->
+    <line x1="-20" y1="-30" x2="-40" y2="20" stroke="#E53935" stroke-width="5" stroke-linecap="round"/>
+    <!-- Top tube -->
+    <line x1="-20" y1="-30" x2="40" y2="-25" stroke="#E53935" stroke-width="5" stroke-linecap="round"/>
+    <!-- Down tube -->
+    <line x1="-40" y1="20" x2="40" y2="-25" stroke="#E53935" stroke-width="5" stroke-linecap="round"/>
+    <!-- Chain stay -->
+    <line x1="-40" y1="20" x2="-60" y2="30" stroke="#E53935" stroke-width="4" stroke-linecap="round"/>
+    <!-- Seat stay -->
+    <line x1="-20" y1="-30" x2="-60" y2="30" stroke="#E53935" stroke-width="4" stroke-linecap="round"/>
+    <!-- Head tube -->
+    <line x1="40" y1="-25" x2="50" y2="-10" stroke="#E53935" stroke-width="5" stroke-linecap="round"/>
+    <!-- Fork -->
+    <line x1="50" y1="-10" x2="70" y2="30" stroke="#E53935" stroke-width="4" stroke-linecap="round"/>
+
+    <!-- Seat -->
+    <ellipse cx="-20" cy="-35" rx="12" ry="4" fill="#333"/>
+    <!-- Seat post -->
+    <line x1="-20" y1="-30" x2="-20" y2="-35" stroke="#666" stroke-width="3"/>
+
+    <!-- Handlebars -->
+    <path d="M40 -25 Q55 -40 65 -35 Q75 -30 70 -20" stroke="#333" stroke-width="4" fill="none" stroke-linecap="round"/>
+    <!-- Grips -->
+    <line x1="65" y1="-35" x2="75" y2="-40" stroke="#222" stroke-width="6" stroke-linecap="round"/>
+    <line x1="70" y1="-20" x2="80" y2="-15" stroke="#222" stroke-width="6" stroke-linecap="round"/>
+
+    <!-- Chainring -->
+    <circle cx="-40" cy="20" r="12" fill="none" stroke="#555" stroke-width="2"/>
+    <circle cx="-40" cy="20" r="8" fill="#666"/>
+    <!-- Chain -->
+    <path d="M-40 32 Q-50 45 -60 30" stroke="#555" stroke-width="2" fill="none"/>
+    <!-- Pedals -->
+    <line x1="-40" y1="20" x2="-50" y2="35" stroke="#444" stroke-width="3"/>
+    <rect x="-55" y="33" width="10" height="4" rx="1" fill="#333"/>
+    <line x1="-40" y1="20" x2="-30" y2="5" stroke="#444" stroke-width="3"/>
+    <rect x="-35" y="1" width="10" height="4" rx="1" fill="#333"/>
+  </g>
+
+  <!-- Pelican -->
+  <g transform="translate(350, 320)">
+    <!-- Body -->
+    <ellipse cx="0" cy="0" rx="35" ry="25" fill="#F5F5F5" stroke="#E0E0E0" stroke-width="1"/>
+
+    <!-- Chest/belly -->
+    <ellipse cx="5" cy="8" rx="25" ry="18" fill="white"/>
+
+    <!-- Wing (back) -->
+    <path d="M-15 -10 Q-50 -30 -60 -10 Q-55 5 -30 5 Q-15 5 -10 0" fill="#E0E0E0" stroke="#BDBDBD" stroke-width="1"/>
+    <!-- Wing feather details -->
+    <path d="M-20 -5 Q-45 -20 -55 -8" stroke="#BDBDBD" stroke-width="1" fill="none"/>
+    <path d="M-15 0 Q-40 -10 -50 0" stroke="#BDBDBD" stroke-width="1" fill="none"/>
+
+    <!-- Tail -->
+    <path d="M-30 -5 Q-55 -15 -65 -5 Q-60 5 -40 5 Q-30 5 -25 0" fill="#E8E8E8" stroke="#BDBDBD" stroke-width="1"/>
+    <path d="M-35 -2 Q-50 -10 -58 -3" stroke="#BDBDBD" stroke-width="0.8" fill="none"/>
+
+    <!-- Neck -->
+    <path d="M20 -10 Q35 -30 40 -50 Q42 -60 38 -65" fill="#F5F5F5" stroke="#E0E0E0" stroke-width="1"/>
+
+    <!-- Head -->
+    <circle cx="38" cy="-70" r="15" fill="#F5F5F5" stroke="#E0E0E0" stroke-width="1"/>
+
+    <!-- Eye -->
+    <circle cx="44" cy="-73" r="4" fill="white"/>
+    <circle cx="45" cy="-73" r="2.5" fill="#1A237E"/>
+    <circle cx="46" cy="-74" r="1" fill="white"/>
+
+    <!-- Beak (upper) -->
+    <path d="M50 -70 L90 -65 Q95 -63 90 -60 L50 -62" fill="#FF9800" stroke="#E65100" stroke-width="1"/>
+    <!-- Beak tip hook -->
+    <path d="M90 -65 Q98 -62 92 -58" fill="none" stroke="#E65100" stroke-width="2" stroke-linecap="round"/>
+
+    <!-- Beak (lower) with gular pouch -->
+    <path d="M50 -62 L85 -60 Q90 -58 85 -50 Q70 -40 50 -55" fill="#FFB74D" stroke="#E65100" stroke-width="1"/>
+    <!-- Gular pouch detail -->
+    <path d="M55 -58 Q70 -48 80 -52" stroke="#E65100" stroke-width="0.5" fill="none"/>
+
+    <!-- Neck feathers/collar -->
+    <path d="M22 -12 Q30 -20 35 -25" stroke="#E0E0E0" stroke-width="2" fill="none"/>
+
+    <!-- Legs (on pedals) -->
+    <!-- Right leg (on front pedal) -->
+    <path d="M5 20 Q10 35 15 50 Q18 55 20 55" stroke="#FF9800" stroke-width="5" fill="none" stroke-linecap="round"/>
+    <!-- Foot -->
+    <path d="M20 55 L28 58 L25 55 L30 54 L20 52" fill="#FF9800"/>
+
+    <!-- Left leg (on back pedal) -->
+    <path d="M-5 20 Q-10 40 -20 50 Q-22 52 -25 52" stroke="#FF9800" stroke-width="5" fill="none" stroke-linecap="round"/>
+    <!-- Foot -->
+    <path d="M-25 52 L-32 55 L-29 52 L-34 51 L-25 49" fill="#FF9800"/>
+  </g>
+
+  <!-- Shadow under bicycle -->
+  <ellipse cx="350" cy="415" rx="80" ry="8" fill="rgba(0,0,0,0.15)"/>
+
+  <!-- Small decorative elements -->
+  <!-- Starfish on beach -->
+  <g transform="translate(180, 420)" fill="#FF7043" opacity="0.7">
+    <path d="M0 -8 L2 -3 L8 -3 L3 1 L5 7 L0 3 L-5 7 L-3 1 L-8 -3 L-2 -3 Z"/>
+  </g>
+
+  <!-- Shell -->
+  <g transform="translate(600, 430)" fill="#FFCC80" opacity="0.6">
+    <ellipse cx="0" cy="0" rx="6" ry="4"/>
+    <path d="M-6 0 Q0 -3 6 0" stroke="#FFB74D" stroke-width="0.5" fill="none"/>
+  </g>
+
+  <!-- Water splash near shore -->
+  <g fill="white" opacity="0.4">
+    <circle cx="300" cy="400" r="2"/>
+    <circle cx="310" cy="395" r="1.5"/>
+    <circle cx="295" cy="398" r="1"/>
+  </g>
+
+  <!-- Title -->
+  <text x="400" y="50" text-anchor="middle" font-family="Arial, sans-serif" font-size="24" font-weight="bold" fill="#1565C0" opacity="0.8">
+    Pelican by the Sea
+  </text>
+  <text x="400" y="75" text-anchor="middle" font-family="Arial, sans-serif" font-size="14" fill="#1976D2" opacity="0.6">
+    Generated by MiMo v2.5 Pro
+  </text>
+</svg>