Turn a ~$5 AliExpress clock into a physical AI usage dashboard (Claude, Codex, multi-account). No firmware flashing.
Release 0.3.0: the animated Arcade face, Copilot and Antigravity, Pixel Retro Dual
click6067-ship-it1151fcb5e91c
diff --git a/README.ko.md b/README.ko.mdindex 4c2a141..09f0730 100644--- a/README.ko.md+++ b/README.ko.md@@ -7,9 +7,11 @@</p><p align="center"><img src="docs/images/real-clock.jpg" alt="작은 책상 시계에 띄운 TokenTV"></p>+<p align="center"><img src="docs/images/arcade.gif" width="320" alt="움직이는 Arcade 화면(샘플 데이터): Clawd, Codex 구름, Grok, Copilot, Anti가 일하는 모습, 그림이 곧 게이지"></p><p align="center"><img src="docs/images/clock-faces.png" alt="시계 화면 6종(샘플 데이터)"></p>-약 5달러 Wi-Fi 책상 시계에 Claude·Codex 사용 한도를 띄웁니다. 펌웨어는 그대로예요.+약 5달러 Wi-Fi 책상 시계에 Claude·Codex 사용 한도(그리고 Grok, CodexBar를 거쳐 Copilot·Antigravity)를 띄웁니다. 펌웨어는 그대로예요.+**새 화면 Arcade:** 캐릭터마다 그림이 곧 게이지인 움직이는 화면입니다. 드문 장면 몇 개는 그 순간이 실제로 찾아올 때만 열립니다.**구경하기:** [라이브 데모](https://token-tv.vercel.app), `npx token-tv demo` 또는 `uvx token-tv demo`, 시계·로그인 없이 바로.**설치하기:** 이 저장소를 AI에게 주고 *"TokenTV 설정해줘"* 라고 하세요. AI는 [AGENTS.md](AGENTS.md)를 따릅니다.**내 화면 만들기:** 시계 없이 [Game Boy 예제](examples/gameboy)에서 시작해 AI에게 바꿔 달라고 하세요. [가이드](docs/clock-faces.md) · [공유하기](https://github.com/click6067-ship-it/token-tv/issues/new?template=share_a_face.md)diff --git a/README.md b/README.mdindex 64d8258..1db9206 100644--- a/README.md+++ b/README.md@@ -7,9 +7,11 @@</p><p align="center"><img src="https://raw.githubusercontent.com/click6067-ship-it/token-tv/main/docs/images/real-clock.jpg" alt="TokenTV on a real tiny desk clock"></p>+<p align="center"><img src="https://raw.githubusercontent.com/click6067-ship-it/token-tv/main/docs/images/arcade.gif" width="320" alt="The animated Arcade face (sample data): Clawd, the Codex cloud, Grok, Copilot and Anti at work, each picture also a gauge"></p><p align="center"><img src="https://raw.githubusercontent.com/click6067-ship-it/token-tv/main/docs/images/clock-faces.png" alt="Six clock faces (sample data)"></p>-Your Claude and Codex usage limits on a ~$5 Wi-Fi desk clock. No firmware flashing.+Your Claude and Codex usage limits (plus Grok, and Copilot or Antigravity through CodexBar) on a ~$5 Wi-Fi desk clock. No firmware flashing.+**New: Arcade**, an animated face where each character's picture is also its gauge, with a few rare scenes that open only when their moment comes on your clock.**Try it:** [live demo](https://token-tv.vercel.app), `npx token-tv demo` or `uvx token-tv demo`, no clock or login needed.**Set it up:** give this repo to your AI and say *"Set up TokenTV for me."* It follows [AGENTS.md](https://github.com/click6067-ship-it/token-tv/blob/main/AGENTS.md).**Make your own face:** no clock needed, start from the [Game Boy example](https://github.com/click6067-ship-it/token-tv/tree/main/examples/gameboy) and ask your AI to change it. [Guide](https://github.com/click6067-ship-it/token-tv/blob/main/docs/clock-faces.md) · [Share it](https://github.com/click6067-ship-it/token-tv/issues/new?template=share_a_face.md)diff --git a/config.example.json b/config.example.jsonindex 853c517..07a8436 100644--- a/config.example.json+++ b/config.example.json@@ -1,5 +1,5 @@{- "poll_seconds": 300,+ "poll_seconds": 60,"accounts": [{"key": "claude_a",diff --git a/docs/adding-a-provider.md b/docs/adding-a-provider.mdindex e67bc66..666e8a9 100644--- a/docs/adding-a-provider.md+++ b/docs/adding-a-provider.md@@ -1,6 +1,6 @@# Adding a service (provider)-TokenTV reads Claude, Codex and Grok today. A new service is more than one function: the name is+TokenTV reads Claude, Codex, Grok and (through CodexBar) Copilot and Antigravity today. A new service is more than one function: the name islisted in several places. This is the full list as of 2026-10-04; an AI agent can follow it.**First check the service exposes usage you can read** (percent used and reset time) through its@@ -19,5 +19,10 @@ own signed-in CLI or a documented API. If it does not, it cannot be added honest| `token_tv/web/app.js` | `PROVIDERS`, `COMPANIES`, scene seed || `tests/` | a payload → windows test with sample JSON, never real account data |-Limits: every clock face shows at most three rows. With more than three services configured, the-first three in `PROVIDERS` order are shown. Missing readings must stay a dash, never 0%.+Limits: every account gets its own row, at most four; past four the clock keeps the accounts in use,+then the fullest. Missing readings must stay a dash, never 0%.++A service that CodexBar already reads can come in through CodexBar instead of its own reader, as+Copilot and Antigravity do: allow it in `load_config` and `check_codexbar`, name its windows in+`normalize_codexbar`, then add the drawing entries above. New clock styles take each service's+colour from `BRAND` in `token_tv/display.py`.diff --git a/docs/clock-faces.md b/docs/clock-faces.mdindex 96c1d7c..4738a1e 100644--- a/docs/clock-faces.md+++ b/docs/clock-faces.md@@ -101,6 +101,27 @@ It is not a live ranking. Older installs show "update TokenTV" instead of downlobytes like `token_tv/space.py`.- Fonts must be in `token_tv/web/` with their license file next to them.+## What a style may change++Every face is a style over the same instrument. Keep these the same on every face:++- **The characters' shapes.** Silhouette and eyes come from `token_tv/assets/`; a face may+ recolour or treat a mascot, never redraw its shape.+- **What the numbers mean.** Used % (not remaining), the window names `5H` / `WK` / `BUD`,+ the reset time, `OLD` / `LOGIN`, and a dash for a missing reading.+- **The gauge.** Ten 10% cells, with the levels changing at 50, 80 and 90%.+- **Who is who.** Each account's label, and Claude, Codex, Grok, Copilot, Antigravity in that order.++A style chooses its own fonts for numbers and labels, its background, ink, gauge and glow+colours, its frames and scenery, how a mascot is treated (full colour, one tint, hologram+lines) and the shape of the gauge cells. On full-colour faces Grok is white with dark eyes. Single-colour styles such as Digital (green phosphor) and Game Boy (four greens)+recolour everything, mascots and gauge levels included, and show levels by brightness.++A new style takes each service's colour from `BRAND` in `token_tv/display.py`: Claude orange, Codex+navy (with a light lavender), Grok white, Copilot a teal-to-blue gradient, Antigravity its logo's orange to+green to blue (gradients drawn as a few flat steps in pixel art). Service colours mark who a row belongs to; the gauge's level colours alone say how much is+used. The older faces keep their own tuned accents.+## Worked example[Pixel → Game Boy](../examples/gameboy/README.md) includes the render function, the same sample data before and after, and an old/missing-data check. It was made with Claude Code and runs without a clock or account.diff --git a/docs/codexbar.md b/docs/codexbar.mdindex ea941b8..e721534 100644--- a/docs/codexbar.md+++ b/docs/codexbar.md@@ -16,7 +16,13 @@ CodexBar CLI 0.74.0 (Linux x86_64 release tarball) on Ubuntu 24.04, 2026-10-11,| Claude, default source | `codexbar usage --provider claude --format json` | Failed: on Linux CodexBar fell back to Claude Code's `/usage` and could not read the output of Claude Code 2.1.289. Set `"codexbar_source": "oauth"` |`codexbar serve` (`GET /usage`) returned the same entries for both providers. TokenTV accepts the-CodexBar input for `claude` and `codex` accounts only, because no other provider has been checked.+CodexBar input for `claude`, `codex`, `copilot` and `antigravity` accounts. Copilot has not been checked with a real+account yet: its mapping follows CodexBar's [Copilot notes](https://github.com/steipete/CodexBar/blob/main/docs/copilot.md)+(sign in once with `codexbar config login --provider copilot`). Copilot and Antigravity accounts can only be read+through CodexBar. Google's two are one account on the clock: an Antigravity account reads CodexBar's+`antigravity` entry, or with `"codexbar_provider": "gemini"` its `gemini` one (the Gemini CLI quota, a daily+window, or the Gemini app's 5-hour and weekly limits); a config that still says `"provider": "gemini"` is read+as Antigravity. Neither has been checked with a real account yet.CodexBar's macOS app has not been tried.## Config@@ -28,6 +34,10 @@ CodexBar's macOS app has not been tried.{"key": "claude_a", "alias": "CLAUDE A", "provider": "claude", "email": "[email protected]","codexbar_command": "codexbar", "codexbar_source": "oauth"},{"key": "codex_a", "alias": "CODEX A", "provider": "codex", "email": "[email protected]",+ "codexbar_command": "codexbar"},+ {"key": "copilot_a", "alias": "COPILOT A", "provider": "copilot", "email": "[email protected]",+ "codexbar_command": "codexbar"},+ {"key": "anti_a", "alias": "ANTI A", "provider": "antigravity", "email": "[email protected]","codexbar_command": "codexbar"}]}@@ -51,7 +61,9 @@ account's source as CodexBar.- The `primary` and `secondary` windows. A 300-minute window is the 5-hour limit and a 10080-minutewindow is the weekly limit. A window without a length is shown without a label; TokenTV does not- guess one from CodexBar's display names.+ guess one from CodexBar's display names. Copilot's windows carry no length: its primary is the+ monthly premium-request allowance (`MO`) and its secondary is chat. GitHub gives no reset time, so+ Copilot's reset stays a dash.- Model-only windows (for example Claude's "Fable only") and `tertiary` are not shown, so they neverreplace the weekly reading.- A missing window is a dash, never 0%.diff --git a/docs/images/arcade.gif b/docs/images/arcade.gifnew file mode 100644index 0000000..a4a7c28Binary files /dev/null and b/docs/images/arcade.gif differdiff --git a/docs/setup.ko.md b/docs/setup.ko.mdindex 60595c3..e99a24e 100644--- a/docs/setup.ko.md+++ b/docs/setup.ko.md@@ -43,14 +43,24 @@ macOS(실기기 미검증): Claude Code가 로그인을 Keychain에 두므로, C시계는 Claude·Codex·Grok 각각 한 계정을 세 행으로 보여줍니다. 픽셀 아이콘, 큰 사용률 숫자, 막대, 기간 및 리셋 시간을 표시합니다.실제 사용량을 제공하는 첫 계정을 선택하며 계정 전환은 수행하지 않습니다. Claude/Codex는 가장 높은 기간 사용률을 표시합니다.영문 계정명은 `CLAUDE A/B/C`, `CODEX A/B`, `GROK A/B`로 구분합니다. 일곱 계정의 전체 기간과 조회 시각·오류 상태는 웹에서 공급자별로 확인합니다.-기본 조회 주기는 5분이며 브라우저를 열어도 추가 조회하지 않습니다.+기본 조회 주기는 1분(Claude 계정은 5분)이며 브라우저를 열어도 추가 조회하지 않습니다.### 화면 스타일-웹의 **Clock display**에서 시계 화면 6종을 미리 보고 고릅니다.+웹의 **Clock display**에서 시계 화면 9종을 미리 보고 고릅니다(설정값: pixel, digital, neon, retro, hud, space, gameboy, arcade, retro-dual).+**Pixel Retro Dual**(`retro-dual`)은 Pixel Retro 카드에 계정마다 5시간·주간 한도를 함께 보여 줍니다.**Digital / Neon / Pixel Retro / Sci-Fi HUD**는 같은 이름의 웹 테마와 같은 글꼴·장식·게이지를쓰고, 원래의 **Pixel**도 남아 있습니다. **Space**는 세 봇이 유리 헬멧을 쓰고 밤하늘을-떠다니는 움직이는 화면(GIF)입니다. 그린 이미지가 직전에 보낸 것과 다를 때만 새로 보내며, 사용률이 바뀌거나 30분마다 바뀌는 Space 애니메이션이 그 예입니다. **Apply to clock**을 누르면 선택을 저장하고 같은 계정+떠다니는 움직이는 화면(GIF)입니다. **Arcade**도 움직이는 화면이고, 캐릭터마다 그림이 한도 하나의 게이지이기도 합니다(작게 5H, WK 등 표시). Claude의 달은 5시간 한도의 남은 양,+Codex 꽃밭은 20% 쓸 때마다 괄호꽃 한 송이, Grok의 발사대 옆 연료탱크는 쓸수록 줄고, Copilot 하늘은 20%마다 구름이 하나씩 차고,+Anti(Antigravity)의 파워 펠릿 네 개는 5시간 한도의 남은 양입니다. 최근 10분 안에 사용률이 오른 계정은 '작업 중'으로 보여서+Clawd는 땅을 오가며 달리고(동작은 claude.dev의 Clawd's Quest 원본), Codex 구름은 0·1·기호 비로 꽃밭을 키우고, Grok은 팰컨 헤비에+연료를 넣거나 콘솔에서 점검하고, Copilot은 구름 아래를 가로질러 날고, Anti는 미로를 순찰합니다. 쉴 때는 숨을 쉬다가 가끔 둘러보고+기지개를 켭니다. 90% 넘게 쓰면(85% 아래로 내려갈 때까지) 저마다 다르게 초조해하며 더 크게 움직입니다. 창이 리셋되면 폭죽, 다 쓰면+지쳐 쓰러집니다. Codex의 저장된 리셋권은 머리줄에 금색 티켓과 남은 개수로, 만료 3일 전부터는 빨간 D-n으로 보입니다. 밤 11시부터+아침 6시까지는 화면이 어두워집니다. 더 드문 장면 몇 개는 숨겨져 있습니다. 잠긴 채로 들어 있다가 그 순간이 실제로 시계에 찾아올 때만+열리고(레어는 며칠에 한 번, 유니크는 한두 주에 한 번), 몇몇은 장면에 작은 기념품을 잠시 남깁니다.+Arcade는 한 계정씩(작업 중인 계정만 번갈아, 모두 쉬면 전부) 크게 보여 줍니다. 그린 이미지가 직전에 보낸 것과 다를 때만 새로 보내며, 사용률이 바뀌거나 30분마다 바뀌는 Space 애니메이션이 그 예입니다. **Apply to clock**을 누르면 선택을 저장하고 같은 계정캐시로 기기에 전송합니다. 미리보기만 선택하면 시계에는 적용되지 않습니다.| Theme | 240×240 화면 표현 |@@ -61,8 +71,9 @@ macOS(실기기 미검증): Claude Code가 로그인을 Keychain에 두므로, C| Sci-Fi HUD | 모서리를 깎은 발광 프레임, 기울어진 칸 게이지 |기존 Pixel(5×7 비트맵 글꼴과 픽셀 마스코트)도 같은 목록에서 고를 수 있습니다.-각 스타일은 Claude·Codex·Grok 한 계정과 10% 단위 10칸 게이지를 표시합니다.-설정의 `display_style`은 `digital`, `neon`, `retro`, `hud`, `pixel`, `space`를 지원하며 재시작 후에도 유지됩니다. 미설정 기본값은 `pixel`입니다.+각 스타일은 Claude·Codex·Grok·Copilot 계정과 10% 단위 10칸 게이지를 표시합니다.+계정마다 한 줄씩 최대 4줄로 화면을 나눠 쓰고(넘치면 작업 중·사용률 높은 계정 우선), 2줄까지는 5시간·주간 창을 둘 다, 3줄부터는 주간 창만 보여 줍니다.+설정의 `display_style`은 `digital`, `neon`, `retro`, `hud`, `pixel`, `space`, `gameboy`, `arcade`를 지원하며 재시작 후에도 유지됩니다. 미설정 기본값은 `pixel`입니다.숫자는 테마 내 공통 중성색입니다.로고 색은 공급자별로 유지하며 게이지는 0–49% / 50–79% / 80–89% / 90–100% 구간마다 같은 색 계열의 두 색 그라데이션으로 표시합니다.색만으로 상태를 전달하지 않으며 실제 숫자, 칸 수, 미인증/오래된 값 표기를 함께 제공합니다.@@ -140,7 +151,7 @@ SSH로 보낼 수 있습니다. 설정의 `snapshot_file`이 해당 파일을Mini 설정에 `source_home`과 `fallback_snapshot_file`을 함께 지정하면 Mini 로그인을우선 사용하고, 인증이 없을 때만 노트북 조회로 대체합니다. 이메일 불일치는 대체로 숨기지 않습니다.-Mini의 해당 계정에 로그인하면 다음 5분 조회부터 노트북 의존성이 없어집니다.+Mini의 해당 계정에 로그인하면 다음 조회부터 노트북 의존성이 없어집니다.```bash# Mini의 프로젝트 디렉터리에서 계정을 선택합니다.diff --git a/docs/setup.md b/docs/setup.mdindex a82a9d8..6ddf637 100644--- a/docs/setup.md+++ b/docs/setup.md@@ -20,15 +20,37 @@ token-tv run # dashboard at http://127.0.0.<p align="center"><img src="images/usage-examples.png" alt="Digital face at low, busy and near-limit usage (sample data)"></p><details>-<summary><b>All six clock faces</b></summary>+<summary><b>All the clock faces</b></summary><br>+Six of them are above; there are also **Game Boy** (four greens), **Pixel Retro Dual** (Pixel Retro with the 5-hour+and weekly windows of each account, `retro-dual`) and the animated **Arcade** (below).Pick one under **Clock display** in the dashboard, then press **Apply to clock**. Space is an animatedGIF that the stock photo album plays. A picture is uploaded again only when the rendered image differsfrom the last upload, for example a new percentage or the Space animation that changes every 30 minutes.++Each account gets its own row, up to four; the rows share the screen, so one account fills it and two+split it in half. With more than four, the clock keeps the ones in use, then the fullest. Up to two rows+show both the 5-hour and the weekly window; three or four rows show the weekly one.++**Arcade** is animated too, and each character's picture is also a gauge for one limit, labelled small+(5H, WK, ...): Claude's moon is what is left of its 5 hours, the Codex garden grows a bracket flower for every+20% used, Grok's fuel tank by the pad drains as it is used, Copilot's sky fills with a cloud for every 20%, and+Anti's (Antigravity's) four power pellets are what is left of its 5 hours. While an account's used % has gone up+within the last ten minutes it is at work: Clawd jogs to and fro (its poses come from Clawd's Quest on+claude.dev), the Codex cloud rains zeros, ones and code symbols on its garden, Grok fuels its Falcon Heavy or+runs checks at the console, Copilot flies across under its clouds, and Anti patrols its maze. At rest they+breathe, look round now and then and stretch. From 90% used (until it drops below 85%) each one frets in its own+way and moves more. A window that resets plays fireworks once; one that runs out, a flop. Codex's saved limit+resets show as a golden ticket in the header with how many are left, and in their last three days as a red D-n.+From 11 pm to 6 am the picture dims. A few rarer scenes are hidden: they ship locked and open only when their+moment really comes on your clock, a rare one every few days and a unique one every week or two, and some leave+a small keepsake in the scene for a while. Arcade shows one account at a time (the working ones in turn, or all+of them while idle). An account that reports no percentage, such as a Grok login without billing data, never+counts as working.</details>## Make it yours@@ -68,7 +90,8 @@ See [docs/hardware-compatibility.md](hardware-compatibility.md) for what is veri| Grok | Grok CLI billing RPC (experimental) | Share of the CLI **billing budget**, not web chat limits |Every login is checked against the email you configured. The clock gets only a picture,-never a password, token or cookie. Polling runs every five minutes; old readings say OLD and+never a password, token or cookie. Polling runs every minute, Claude accounts every five minutes+because its usage endpoint rate-limits frequent callers; old readings say OLD andmissing data shows a dash, never a fake 0%. Claude accounts with `refresh_with_cli: true` mayrefresh an expired login through the CLI, which sends one tiny prompt.diff --git a/docs/stock-photo-display.md b/docs/stock-photo-display.mdindex 0ee805a..4bacec4 100644--- a/docs/stock-photo-display.md+++ b/docs/stock-photo-display.md@@ -19,12 +19,16 @@ runs TokenTV code, so there is nothing to flash and no firmware to restore.1. **Read usage.** A computer on the same network reads usage through each tool's ownlogin: the Claude Code CLI's OAuth profile and usage, the official `codex app-server`rate-limit RPC, and, as an experimental option, the Grok CLI billing RPC (a share of the CLI- billing budget, not web chat limits). It polls every five minutes by default.+ billing budget, not web chat limits). It polls every minute by default, Claude accounts every five minutes.2. **Draw a face.** Python and Pillow draw a 240×240 image: used percentage, window,reset time and account label. An old reading is marked OLD, and missing data shows a dashinstead of a fake 0%.3. **Upload a picture.** The image goes to the clock's `/photo/upload` page as a normal- file upload: `tokentv.jpg` (kept under 60 KB), or `tokentv.gif` for the animated face.+ file upload: `tokentv.jpg` (kept under 60 KB), or for the animated face one of `tokentv.gif`,+ `tokentv-b.gif` and `tokentv-c.gif` in turn. A GIF never goes to the file the clock is playing:+ TokenTV checks the new one arrived whole, then switches the album over, and a picture that comes+ back (a resting pet's still minutes) is a switch, not a new upload. The third file is used only+ while it leaves 300 KB free for your own photos.4. **Show only that picture.** TokenTV first reads `/theme/list` and `/photo/list` and savesthe current settings. It then enables only its own file, switches the clock to the phototheme and leaves your other photos in the album.diff --git a/package.json b/package.jsonindex 60ac134..bb0f1d5 100644--- a/package.json+++ b/package.json@@ -1,10 +1,24 @@{"name": "token-tv",- "version": "0.2.0",- "description": "Your Claude and Codex usage limits on a tiny Wi-Fi desk clock (launcher for the Python package)",+ "version": "0.3.0",+ "description": "Your Claude, Codex, Grok, Copilot and Antigravity usage limits on a tiny Wi-Fi desk clock (launcher for the Python package)","license": "MIT",- "repository": "github:click6067-ship-it/token-tv",- "bin": { "token-tv": "bin/token-tv.js" },- "files": ["bin/", "token_tv/", "pyproject.toml", "README.md", "LICENSE"],- "engines": { "node": ">=18" }+ "repository": {+ "type": "git",+ "url": "git+https://github.com/click6067-ship-it/token-tv.git"+ },+ "bin": {+ "token-tv": "bin/token-tv.js"+ },+ "files": [+ "bin/",+ "token_tv/",+ "!**/__pycache__",+ "pyproject.toml",+ "README.md",+ "LICENSE"+ ],+ "engines": {+ "node": ">=18"+ }}diff --git a/pyproject.toml b/pyproject.tomlindex 6dd77b9..c403463 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -1,11 +1,11 @@[build-system]-requires = ["setuptools>=68"]+requires = ["setuptools>=77"] # the SPDX license field needs 77build-backend = "setuptools.build_meta"[project]name = "token-tv"-version = "0.2.0"-description = "Your AI usage limits on a $5 desk clock: Claude, Codex and Grok on a 240x240 Wi-Fi clock"+version = "0.3.0"+description = "Your AI usage limits on a $5 desk clock: Claude, Codex, Grok, Copilot and Antigravity on a 240x240 Wi-Fi clock"readme = "README.md"license = "MIT"requires-python = ">=3.10"@@ -23,4 +23,4 @@ packages = ["token_tv", "token_tv.providers", "token_tv.web", "token_tv.assets"][tool.setuptools.package-data]"token_tv.web" = ["*"]-"token_tv.assets" = ["*.png", "*.json"]+"token_tv.assets" = ["*.png", "*.json", "*.bin"]diff --git a/scripts/render_arcade_demo.py b/scripts/render_arcade_demo.pynew file mode 100644index 0000000..8dd5bab--- /dev/null+++ b/scripts/render_arcade_demo.py@@ -0,0 +1,52 @@+"""Render docs/images/arcade.gif: the animated Arcade face, each character at work for a few seconds.++Sample readings only, and only the everyday scenes (the hidden ones are not in this tree):+ python3 scripts/render_arcade_demo.py+"""+import sys+import time+from pathlib import Path++from PIL import Image++ROOT = Path(__file__).resolve().parents[1]+sys.path.insert(0, str(ROOT))+from token_tv import arcade # noqa: E402+from token_tv.sample import D, H, snapshot # noqa: E402++# Each character at work on its own clock: the picture is its gauge (moon, garden, fuel, clouds, pellets).+CAST = [('claude', 'CLAUDE A', [('5H', 38, 3 * H), ('WEEK', 61, 3 * D)]), ('codex', 'CODEX A', [('WEEK', 47, 4 * D)]),+ ('grok', 'GROK A', [('BUDGET', 52, 12 * D)]), ('copilot', 'COPILOT A', [('MONTH', 46, 9 * D)]),+ ('antigravity', 'ANTI A', [('5H', 30, 2 * H)])]+SHOWN = 48 # frames of each, a little over three seconds+SCALE = 2+++def main():+ now = time.mktime((2026, 10, 28, 14, 0, 0, 0, 0, -1)) # daytime: the stage is not dimmed+ frames = []+ for provider, alias, windows in CAST:+ data = snapshot(now, [(f'{provider}_a', alias, provider, windows)])+ data['accounts'][f'{provider}_a']['active'] = True+ if provider == 'grok':+ data['accounts']['grok_a']['role'] = 'crew'+ frames += [f.convert('RGB').resize((240 * SCALE, 240 * SCALE), Image.Resampling.NEAREST)+ for f in arcade.arcade_frames(data, now)[:SHOWN]]+ colours = {c for f in frames[::6] for _, c in f.getcolors(maxcolors=1 << 16)}+ if len(colours) <= 256: # every colour exactly+ palette = Image.new('P', (1, 1))+ palette.putpalette([v for c in sorted(colours) for v in c])+ else: # the closest 256 over a sample of every character's frames+ sheet = Image.new('RGB', (240 * SCALE, 240 * SCALE * len(frames[::12])))+ for n, f in enumerate(frames[::12]):+ sheet.paste(f, (0, 240 * SCALE * n))+ palette = sheet.quantize(colors=256, method=Image.Quantize.MEDIANCUT)+ indexed = [f.quantize(palette=palette, dither=Image.Dither.NONE) for f in frames]+ out = ROOT / 'docs' / 'images' / 'arcade.gif'+ indexed[0].save(out, save_all=True, append_images=indexed[1:], duration=arcade.FRAME_MS, loop=0, disposal=1,+ optimize=False)+ print(f'{out} {out.stat().st_size // 1024} KB, {len(frames)} frames')+++if __name__ == '__main__':+ main()diff --git a/tests/test_antigravity.py b/tests/test_antigravity.pynew file mode 100644index 0000000..4e53066--- /dev/null+++ b/tests/test_antigravity.py@@ -0,0 +1,137 @@+import io+import json+import tempfile+import time+import unittest+from pathlib import Path++from PIL import Image, ImageChops++from token_tv import arcade+from token_tv.display import STYLES, overview_rows, render_page+from token_tv.sample import H, snapshot+from token_tv.sources import codexbar_entry, load_config+from token_tv.usage import normalize_codexbar+from token_tv.web_assets import ASSETS+++def pixels(image):+ """Every pixel, on old and new Pillow alike."""+ return getattr(image, 'get_flattened_data', image.getdata)()++# Shapes of `codexbar usage --provider antigravity|gemini --format json` (sample values, no real account).+APP = {'provider': 'gemini', 'usage': {'primary': {'usedPercent': 42.0, 'windowMinutes': 300, 'resetsAt': 1900000000},+ 'secondary': {'usedPercent': 18.0, 'windowMinutes': 10080},+ 'accountEmail': '[email protected]'}}+CLI = {'provider': 'gemini', 'usage': {'primary': {'usedPercent': 7.0, 'windowMinutes': 1440}}}+AGY = {'provider': 'antigravity', 'usage': {'primary': {'usedPercent': 55.0, 'windowMinutes': 300}}}+++class AntigravityTests(unittest.TestCase):+ def test_windows_keep_their_lengths(self):+ self.assertEqual([(w['label'], w['used_percent']) for w in normalize_codexbar(APP)], [('5H', 42.0), ('WEEK', 18.0)])+ self.assertEqual([w['label'] for w in normalize_codexbar(CLI)], ['DAY']) # the Gemini CLI's daily quota++ def test_two_windows_of_one_length_keep_apart(self):+ both = {'provider': 'antigravity', 'usage': {'primary': {'usedPercent': 30.0}, 'secondary': {'usedPercent': 7.0}}}+ self.assertEqual([w['label'] for w in normalize_codexbar(both)], ['WINDOW', 'WINDOW2'])+ both['usage']['primary'] = {'usedPercent': None} # a reading without the first: the second keeps its name+ self.assertEqual([w['label'] for w in normalize_codexbar(both)], ['WINDOW2'])+ del both['usage']['primary']+ self.assertEqual([w['label'] for w in normalize_codexbar(both)], ['WINDOW2'])++ def test_one_google_pet_reads_antigravity_or_gemini_through_codexbar(self):+ with tempfile.TemporaryDirectory() as directory:+ path = Path(directory) / 'config.json'+ account = {'key': 'anti_a', 'alias': 'ANTI A', 'provider': 'antigravity', 'email': '[email protected]'}+ path.write_text(json.dumps({'accounts': [account]}))+ with self.assertRaises(ValueError): # CodexBar owns the login+ load_config(path)+ path.write_text(json.dumps({'accounts': [dict(account, codexbar_command='codexbar')]}))+ loaded = load_config(path)['accounts'][0]+ self.assertEqual(codexbar_entry([APP, AGY], loaded)[0], AGY) # its own entry by default+ old = dict(account, provider='gemini', codexbar_command='codexbar', codexbar_provider='gemini')+ path.write_text(json.dumps({'accounts': [old]}))+ loaded = load_config(path)['accounts'][0]+ self.assertEqual(loaded['provider'], 'antigravity') # an old Gemini account is Anti now+ self.assertEqual(codexbar_entry([APP, AGY], loaded)[0], APP)+ older = dict(account, provider='gemini', codexbar_url='http://127.0.0.1:8080/usage?provider=gemini')+ path.write_text(json.dumps({'accounts': [older]}))+ self.assertEqual(codexbar_entry([APP, AGY], load_config(path)['accounts'][0])[0], APP) # still its Gemini+ path.write_text(json.dumps({'accounts': [dict(account, codexbar_command='codexbar', codexbar_provider='cursor')]}))+ with self.assertRaises(ValueError):+ load_config(path)++ def test_every_face_draws_anti(self):+ now = time.time()+ data = snapshot(now, [('anti_a', 'ANTI A', 'antigravity', [('5H', 45, 2 * H)])])+ self.assertEqual([r['provider'] for r in overview_rows(data)], ['antigravity'])+ for style in STYLES:+ self.assertEqual(Image.open(io.BytesIO(render_page(data, style=style))).size, (240, 240), style)+ data['accounts']['anti_a']['active'] = True+ frames = arcade.arcade_frames(data, now)+ self.assertTrue(ImageChops.difference(frames[0], frames[6]).getbbox())+ self.assertIn('/assets/antigravity-pixel.png', ASSETS)+ for kind in ('reset', 'full'):+ self.assertLess(len(render_page(data, style='arcade', egg=f'{kind}@anti_a')), 400000)++ def test_a_daily_window_survives_a_snapshot_handed_over(self):+ from token_tv.sources import imported_row+ with tempfile.TemporaryDirectory() as directory:+ path = Path(directory) / 'snapshot.json'+ row = {'provider': 'antigravity', 'alias': 'ANTI A', 'status': 'ok', 'fetched_at': time.time() - 30,+ 'windows': [w for w in normalize_codexbar(CLI)]}+ path.write_text(json.dumps({'accounts': {'anti_a': row}}))+ account = {'key': 'anti_a', 'alias': 'ANTI A', 'provider': 'antigravity', 'snapshot_file': str(path)}+ self.assertEqual([w['label'] for w in imported_row(account)['windows']], ['DAY'])+ row.update(provider='codex', reset_credits={'count': 2, 'expires_at': 2_000_000_000})+ path.write_text(json.dumps({'accounts': {'anti_a': row}}))+ self.assertEqual(imported_row(dict(account, provider='codex'))['reset_credits'], {'count': 2, 'expires_at': 2_000_000_000})++ def test_old_names_keep_their_letter_and_full_counts_its_streak(self):+ from token_tv.display import account_label+ row = lambda alias: {'provider': 'antigravity', 'alias': alias}+ self.assertEqual([account_label(row(a)) for a in ('GEMINI B', 'ANTIGRAVITY C', 'ANTI D', 'WORK')],+ ['ANTI B', 'ANTI C', 'ANTI D', 'ANTI A'])+ from token_tv import events+ def full(streak):+ stage = Image.new('RGB', (120, 71))+ events.event_scene('full', 'antigravity', streak)(stage, arcade.ImageDraw.Draw(stage), (0, 0, 120, 71), 110, 1)+ return stage.tobytes()+ self.assertNotEqual(full(1), full(3)) # 200, then 800++ def test_a_reset_brings_back_only_the_pellets_really_left(self):+ now = time.mktime((2026, 10, 28, 12, 0, 0, 0, 0, -1))+ def pellets(used):+ data = snapshot(now, [('anti_a', 'ANTI A', 'antigravity', [('5H', used, 2 * H)])])+ last = arcade.arcade_frames(data, now, egg='reset@anti_a')[-1].convert('RGB').crop((0, 28, 240, 170))+ return sum(1 for p in pixels(last) if p == arcade.MAZE_DOT)+ self.assertGreater(pellets(5), pellets(80)) # a weekly reset with the 5 hours nearly gone refills little++ def test_the_pellets_are_what_is_left_of_the_five_hours(self):+ def lit(used, label='5H'):+ stage = Image.new('RGB', (120, 71))+ left = None if used is None else 1 - used / 100+ arcade.anti_pellets(arcade.ImageDraw.Draw(stage), (0, 0, 120, 71), left, label)+ return sum(1 for p in pixels(stage) if p == arcade.MAZE_DOT)+ self.assertGreater(lit(10), lit(45))+ self.assertGreater(lit(45), lit(80))+ self.assertEqual(lit(100), 0)+ self.assertEqual(lit(None), 0)++ def test_anti_turns_blue_near_the_limit_and_patrols_at_work(self):+ now = time.mktime((2026, 10, 28, 12, 0, 0, 0, 0, -1))+ def stage(used, active, worry=False):+ data = snapshot(now, [('anti_a', 'ANTI A', 'antigravity', [('5H', used, 2 * H)])])+ data['accounts']['anti_a'].update(active=active, worry=worry)+ return [f.convert('RGB').crop((0, 28, 240, 170)) for f in arcade.arcade_frames(data, now)]+ blue = lambda frames: sum(1 for p in pixels(frames[0]) if p == arcade.ANTI_SCARED)+ calm, scared = stage(50, True), stage(95, True, True)+ self.assertGreater(blue(scared), blue(calm) + 100) # the body itself turns blue+ self.assertGreater(blue(stage(95, False, True)), blue(stage(50, False)) + 100)+ moved = [ImageChops.difference(calm[0], calm[k]).getbbox() for k in (10, 40, 80)]+ self.assertTrue(all(moved)) # round the maze+++if __name__ == '__main__':+ unittest.main()diff --git a/tests/test_arcade.py b/tests/test_arcade.pynew file mode 100644index 0000000..475d6ff--- /dev/null+++ b/tests/test_arcade.py@@ -0,0 +1,305 @@+import io+import time+import unittest+from unittest.mock import patch++from PIL import Image, ImageChops, ImageDraw++from token_tv import arcade+from token_tv.display import render_page+from token_tv.sample import D, H, snapshot+from token_tv.state import ACTIVE_SECONDS, MIN_FETCH_SECONDS, UsageStore++def sample(now, working=()):+ data = snapshot(now, [+ ('claude_a', 'CLAUDE A', 'claude', [('5H', 41, 2 * H), ('WEEK', 86, 3 * D)]),+ ('codex_a', 'CODEX A', 'codex', [('5H', 34, 2 * H)]),+ ('grok_a', 'GROK A', 'grok', [('BUDGET', 61, 6 * D)]),+ ])+ for key in working:+ data['accounts'][key]['active'] = True+ return data+++def reply(key, provider, used, status='ok'):+ return {'key': key, 'alias': key.upper(), 'provider': provider, 'status': status, 'fetched_at': time.time(),+ 'windows': [{'label': '5H', 'used_percent': used, 'resets_at': None}] if used is not None else []}+++class WorkingTests(unittest.TestCase):+ def test_a_rise_in_used_percent_marks_the_account_working_until_it_settles(self):+ readings = [10, 10, 12, 0]+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}],+ fetch=lambda _: reply('a', 'codex', readings.pop(0)))+ store.refresh()+ self.assertFalse(store.snapshot()['accounts']['a']['active']) # the first reading has nothing to compare+ store.refresh()+ self.assertFalse(store.snapshot()['accounts']['a']['active']) # unchanged+ store.refresh()+ self.assertTrue(store.snapshot()['accounts']['a']['active']) # 10 → 12+ store.refresh()+ self.assertTrue(store.snapshot()['accounts']['a']['active']) # a reset to 0 is not work, the last rise holds+ later = time.time() + ACTIVE_SECONDS + 1+ with patch('token_tv.state.time.time', return_value=later):+ self.assertFalse(store.snapshot()['accounts']['a']['active'])++ def test_errors_and_missing_readings_never_count_as_work(self):+ readings = [reply('a', 'codex', 10), reply('a', 'codex', None, 'error'), reply('a', 'codex', 10),+ reply('a', 'codex', None, 'quota_unavailable')]+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}], fetch=lambda _: readings.pop(0))+ for _ in range(4):+ store.refresh()+ self.assertFalse(store.snapshot()['accounts']['a']['active'])++ def test_claude_is_read_at_most_every_five_minutes_while_others_follow_the_poll(self):+ calls = []++ def fetch(account):+ calls.append(account['key'])+ return reply(account['key'], account['provider'], 10)+ accounts = [{'key': 'c', 'alias': 'C', 'provider': 'claude'}, {'key': 'x', 'alias': 'X', 'provider': 'codex'}]+ store = UsageStore(accounts, fetch=fetch, min_fetch_seconds=MIN_FETCH_SECONDS)+ clock = [1000.0]+ with patch('token_tv.state.time.monotonic', side_effect=lambda: clock[0]):+ for _ in range(5): # one-minute polls+ store.refresh()+ clock[0] += 60+ self.assertEqual(calls.count('c'), 1)+ self.assertEqual(calls.count('x'), 5)+ store.refresh() # five minutes after the first read+ self.assertEqual(calls.count('c'), 2)+++class ArcadeFaceTests(unittest.TestCase):+ def test_animated_faces_fit_the_clock_and_equal_readings_give_equal_bytes(self):+ now = time.time()+ for style, render in (('arcade', arcade.render_arcade),):+ working = render(sample(now, ('claude_a', 'codex_a', 'grok_a')), now)+ idle = render(sample(now), now)+ for data in (working, idle):+ image = Image.open(io.BytesIO(data))+ self.assertEqual((image.format, image.size), ('GIF', (240, 240)))+ self.assertLess(len(data), 400000) # the clock's GIF upload limit+ self.assertNotEqual(working, idle)+ self.assertEqual(render(sample(now), now), idle, style) # unchanged clock is not rewritten+ image = Image.open(io.BytesIO(working))+ total = 0+ for index in range(image.n_frames): # identical neighbours are merged, the loop keeps its length+ image.seek(index)+ total += image.info['duration']+ self.assertEqual(total, arcade.FRAMES * arcade.FRAME_MS)+ durations = set()+ for index in range(image.n_frames):+ image.seek(index)+ durations.add(image.info['duration'] % arcade.FRAME_MS)+ self.assertEqual(durations, {0}) # every frame the same length (merged ones a whole multiple): no judder++ def test_arcade_takes_turns_on_working_accounts_or_on_all_when_idle(self):+ now = time.time()+ self.assertEqual([r['provider'] for r in arcade.shown_rows(sample(now, ('codex_a',)))], ['codex'])+ self.assertEqual([r['provider'] for r in arcade.shown_rows(sample(now, ('claude_a', 'grok_a')))],+ ['claude', 'grok'])+ self.assertEqual([r['provider'] for r in arcade.shown_rows(sample(now))], ['claude', 'codex', 'grok'])++ def test_each_scene_moves_only_while_working(self):+ now = time.time()+ for key in ('claude_a', 'codex_a', 'grok_a'):+ frames = arcade.arcade_frames(sample(now, (key,)), now)+ self.assertTrue(ImageChops.difference(frames[0], frames[7]).getbbox(), key)+ claude_only = lambda working: snapshot(now, [('claude_a', 'CLAUDE A', 'claude', [('WEEK', 63, 3 * D)])]) \+ if not working else dict(sample(now, ('claude_a',)), accounts={'claude_a': sample(now, ('claude_a',))['accounts']['claude_a']})+ idle = arcade.arcade_frames(claude_only(False), now)+ moving = arcade.arcade_frames(claude_only(True), now)+ ground = (0, 160, 240, 170) # the dotted ground strip under Clawd's feet: it stands still either way+ stage = (0, 28, 240, 150)+ for frames in (idle, moving):+ self.assertIsNone(ImageChops.difference(frames[1].crop(ground), frames[7].crop(ground)).getbbox())+ self.assertTrue(ImageChops.difference(moving[1].crop(stage), moving[7].crop(stage)).getbbox()) # Clawd jogs++ def test_near_the_limit_each_character_frets_instead_of_its_usual_idle(self):+ now = time.time()+ for provider in ('claude', 'codex', 'grok', 'copilot'):+ def frames(used):+ data = snapshot(now, [(f'{provider}_a', 'A', provider, [('WEEK', used, 3 * D)])])+ return arcade.arcade_frames(data, now)+ calm, worried = frames(50), frames(95)+ scene = (0, 28, 240, 170) # the stage only; the number differs anyway+ self.assertTrue(any(ImageChops.difference(calm[k].crop(scene), worried[k].crop(scene)).getbbox()+ for k in (0, 5, 10)), provider)+ self.assertTrue(ImageChops.difference(worried[0], worried[5]).getbbox(), provider) # fretting moves++ def test_reset_time_is_coarse_so_the_gif_changes_rarely(self):+ now = 1_000_000+ self.assertEqual(arcade.coarse_left(now + 3 * D + 5 * H, now), '3D')+ self.assertEqual(arcade.coarse_left(now + 5 * H + 59 * 60, now), '5H')+ self.assertEqual(arcade.coarse_left(now + 38 * 60, now), '38M')+ self.assertEqual(arcade.coarse_left(None, now), '--')++ def test_missing_services_and_logged_out_accounts_still_render(self):+ only_claude = snapshot(time.time(), [('claude_a', 'CLAUDE A', 'claude', [('5H', 72, 2 * H)])])+ logged_out = {'accounts': {'a': {'alias': 'CODEX A', 'provider': 'codex', 'status': 'auth_required', 'windows': []}}}+ for data in (only_claude, logged_out):+ for style in ('arcade',):+ self.assertEqual(render_page(data, style=style)[:4], b'GIF8')++ def test_a_loop_over_budget_drops_every_other_frame_but_keeps_its_length(self):+ now = time.time()+ with patch.object(arcade, 'BUDGET', 1000):+ data = arcade.render_arcade(sample(now, ('claude_a',)), now)+ image = Image.open(io.BytesIO(data))+ total = 0+ for index in range(image.n_frames):+ image.seek(index)+ total += image.info['duration']+ self.assertLessEqual(image.n_frames, arcade.FRAMES // 2)+ self.assertEqual(total, arcade.FRAMES * arcade.FRAME_MS)+ self.assertEqual(arcade.gif_seconds(data), arcade.LOOP_SECONDS)+++class EventTests(unittest.TestCase):+ def test_a_window_that_resets_or_runs_out_is_an_event_once(self):+ readings = [60, 100, 100, 4]+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}],+ fetch=lambda _: reply('a', 'codex', readings.pop(0)))+ store.refresh()+ self.assertIsNone(store.snapshot()['accounts']['a'].get('event'))+ store.refresh()+ row = store.snapshot()['accounts']['a']+ self.assertEqual(row['event'], 'full') # 60 → 100+ first = row['event_at']+ store.refresh()+ self.assertEqual(store.snapshot()['accounts']['a']['event_at'], first) # still full: no new event+ store.refresh()+ row = store.snapshot()['accounts']['a']+ self.assertEqual(row['event'], 'reset') # 100 → 4+ self.assertGreaterEqual(row['event_at'], first)++ def test_event_scenes_render_for_every_service_and_only_for_their_account(self):+ now = time.time()+ for provider, label in (('claude', 'WEEK'), ('codex', 'WEEK'), ('grok', 'BUDGET'), ('copilot', 'MONTH')):+ data = snapshot(now, [(f'{provider}_a', provider.upper() + ' A', provider, [(label, 100, None)])])+ usual = render_page(data, style='arcade')+ for kind in ('reset', 'full'):+ image = render_page(data, style='arcade', egg=f'{kind}@{provider}_a')+ self.assertLess(len(image), 400000)+ self.assertNotEqual(image, usual, (provider, kind))+ self.assertEqual(render_page(data, style='arcade', egg='full@someone_else'), usual)+++ def test_spending_a_saved_reset_is_a_reset_and_the_ticket_shows_in_the_header(self):+ from token_tv.usage import reset_credits+ reply_with = lambda count: {'rateLimitResetCredits': {'availableCount': count, 'credits': [+ {'status': 'available', 'expiresAt': 2_000_000_000}, {'status': 'used', 'expiresAt': 1_900_000_000}]}}+ self.assertEqual(reset_credits(reply_with(2)), {'count': 2, 'expires_at': 2_000_000_000})+ self.assertIsNone(reset_credits({'rateLimits': {}}))+ counts = [2, 2, 1]+ def fetch(_):+ row = reply('a', 'codex', 100)+ row['reset_credits'] = {'count': counts.pop(0), 'expires_at': None}+ return row+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}], fetch=fetch)+ store.refresh()+ store.refresh()+ self.assertIsNone(store.snapshot()['accounts']['a'].get('event'))+ store.refresh()+ self.assertEqual(store.snapshot()['accounts']['a']['event'], 'reset') # one ticket spent+ now = time.time()+ data = snapshot(now, [('codex_a', 'CODEX A', 'codex', [('WEEK', 47, 4 * D)])])+ plain = arcade.arcade_frames(data, now)+ data['accounts']['codex_a']['reset_credits'] = {'count': 1, 'expires_at': now + 20 * D}+ held = arcade.arcade_frames(data, now)+ header = (0, 0, 240, 28)+ self.assertTrue(ImageChops.difference(plain[0].crop(header), held[0].crop(header)).getbbox())+ self.assertIsNone(ImageChops.difference(held[0].crop(header), held[7].crop(header)).getbbox())+ data['accounts']['codex_a']['reset_credits'] = {'count': 1, 'expires_at': now + 2 * D}+ expiring = arcade.arcade_frames(data, now) # steady red, no blinking+ self.assertTrue(ImageChops.difference(held[0].crop(header), expiring[0].crop(header)).getbbox())+ self.assertIsNone(ImageChops.difference(expiring[0].crop(header), expiring[7].crop(header)).getbbox())+++class SpriteTests(unittest.TestCase):+ def test_clawd_poses_decode_like_the_game(self):+ data = arcade.clawd_data()+ for name, sheet in data.items():+ frames = arcade.clawd_frames(name)+ self.assertEqual(len(frames), len(sheet['deltas']) + 1, name)+ self.assertTrue(all(len(frame) == sheet['w'] * sheet['h'] for frame in frames), name)+ for name, first, last in list(arcade.IDLE_MOVES.values()) + [arcade.RUN]:+ self.assertLess(last, len(arcade.clawd_frames(name)), name)+ self.assertIsNotNone(arcade.clawd(name, first, 1).getbbox())+ for index in (*arcade.JUMP_RISE, arcade.JUMP_TOP, *arcade.JUMP_FALL, *arcade.JUMP_LAND):+ self.assertIsNotNone(arcade.clawd('Jumping', index, 1).getbbox())++ def test_the_falcon_window_lights_up_with_grok_aboard_and_the_cores_split(self):+ for height in (43, 13):+ plain, aboard = (arcade.rocket_art(height, glass).convert('RGB') for glass in ('empty', 'grok'))+ self.assertTrue(ImageChops.difference(plain, aboard).getbbox())+ whole = arcade.rocket_art(43)+ pieces = [arcade.rocket_art(43, 'empty', 0, (part,)) for part in ('left', 'centre', 'right')]+ self.assertTrue(all(piece.size == whole.size and piece.getbbox() for piece in pieces))+ self.assertLess(pieces[0].getbbox()[2], pieces[2].getbbox()[0]) # a booster on each side++ def test_codex_is_a_little_smaller_with_its_face_kept(self):+ shared, cloud = arcade.mascot_sprite('codex'), arcade.codex_cloud()+ self.assertLess(cloud.width, shared.width)+ self.assertLess(cloud.height, shared.height)+ face = lambda art: sum(1 for p in art.getdata() if arcade.is_light(p))+ self.assertGreater(face(cloud), face(shared) * .8) # the '>_' keeps its strokes++ def test_a_napper_shows_only_its_zs_and_the_awake_their_notes(self):+ for asleep, drawn in ((True, False), (False, True)):+ image = Image.new('RGB', (40, 40))+ arcade.mood_marks(ImageDraw.Draw(image), 10, 30, 1, 0, 'happy', asleep)+ self.assertEqual(bool(image.getbbox()), drawn)++ def test_codex_grins_at_a_reset(self):+ grin, plain = arcade.codex_pose('happy', 'smile'), arcade.codex_pose('closed', 'long')+ self.assertTrue(ImageChops.difference(grin.convert('RGB'), plain.convert('RGB')).getbbox())+ ink = sum(1 for p in grin.getdata() if arcade.is_light(p))+ self.assertGreater(ink, sum(1 for p in plain.getdata() if arcade.is_light(p)))++ def test_pixel_retro_draws_a_white_grok_on_a_dark_tile(self):+ data = snapshot(time.time(), [('grok_a', 'GROK A', 'grok', [('BUDGET', 61, 6 * D)])])+ image = Image.open(io.BytesIO(render_page(data, style='retro'))).convert('RGB')+ top = 82 # the single row sits in the middle slot+ tile = image.crop((16, top + 13, 46, top + 43))+ corner = tile.getpixel((1, 1))+ self.assertLess(sum(corner), 120) # dark, no light lavender card any more+ self.assertGreater(max(sum(p) for p in tile.getdata()), 600) # the bot itself is white+++if __name__ == '__main__':+ unittest.main()+++class ReadoutTests(unittest.TestCase):+ def test_every_look_reads_one_or_two_windows_known_or_not(self):+ from token_tv import readout+ now = time.mktime((2026, 10, 28, 12, 0, 0, 0, 0, -1))+ cases = ([('WEEK', 47, 4 * D)], [('5H', 41, 2 * H), ('WEEK', 63, 3 * D)], [('MONTH', 100, None)])+ try:+ for style, bar in (('score', None), ('chips', None), ('pixel', None), ('lcd', 'cells'), ('lcd', 'ticks'),+ ('lcd', 'dots'), ('lcd', 'zones'), ('lcd', 'capsule'), ('lcd', 'capsule_along'),+ ('lcd', 'capsule_lit'), ('lcd', 'capsule_heat')):+ readout.STYLE = style+ readout.LCD_BAR = bar or 'capsule'+ for windows in cases:+ data = snapshot(now, [('codex_a', 'CODEX A', 'codex', windows)])+ image = Image.open(io.BytesIO(arcade.render_arcade(data, now)))+ self.assertEqual(image.size, (240, 240), style)+ bottom = arcade.arcade_frames(data, now)[0].crop((0, 172, 240, 240))+ self.assertGreater(len(bottom.getcolors(4096)), 3, style) # something is drawn there+ data['accounts']['codex_a']['windows'] = []+ arcade.arcade_frames(data, now) # no reading at all: dashes, no crash+ finally:+ readout.STYLE, readout.LCD_BAR = 'lcd', 'capsule'++ def test_seven_segment_digits_light_their_own_strokes(self):+ from token_tv import readout+ def lit(char):+ image = Image.new('RGB', (40, 50))+ readout.seven(ImageDraw.Draw(image), 0, 0, char, 'big', (255, 255, 255))+ return sum(1 for p in image.getdata() if p == (255, 255, 255))+ self.assertLess(lit('1'), lit('7'))+ self.assertLess(lit('7'), lit('8'))+ self.assertEqual(lit('8'), max(lit(c) for c in '0123456789'))diff --git a/tests/test_copilot.py b/tests/test_copilot.pynew file mode 100644index 0000000..c7596a2--- /dev/null+++ b/tests/test_copilot.py@@ -0,0 +1,61 @@+import io+import json+import tempfile+import time+import unittest+from pathlib import Path++from PIL import Image, ImageChops++from token_tv import arcade+from token_tv.display import STYLES, overview_rows, render_page+from token_tv.sample import D, snapshot+from token_tv.sources import load_config+from token_tv.usage import normalize_codexbar+from token_tv.web_assets import ASSETS++# Shape of `codexbar usage --provider copilot --format json` (sample values, no real account).+ENTRY = {'provider': 'copilot', 'usage': {'primary': {'usedPercent': 38.0}, 'secondary': {'usedPercent': 12.5},+ 'accountEmail': '[email protected]'}}+++class CopilotTests(unittest.TestCase):+ def test_codexbar_copilot_slots_become_the_month_and_chat(self):+ windows = normalize_codexbar(ENTRY)+ self.assertEqual([(w['label'], w['used_percent'], w['resets_at']) for w in windows],+ [('MONTH', 38.0, None), ('CHAT', 12.5, None)]) # GitHub gives no reset time++ def test_copilot_accounts_are_read_through_codexbar_only(self):+ with tempfile.TemporaryDirectory() as directory:+ path = Path(directory) / 'config.json'+ account = {'key': 'copilot_a', 'alias': 'COPILOT A', 'provider': 'copilot', 'email': '[email protected]'}+ path.write_text(json.dumps({'accounts': [account]}))+ with self.assertRaises(ValueError):+ load_config(path)+ path.write_text(json.dumps({'accounts': [dict(account, codexbar_command='codexbar')]}))+ self.assertEqual(load_config(path)['accounts'][0]['provider'], 'copilot')++ def test_every_face_draws_a_copilot_row_and_its_scene_moves(self):+ now = time.time()+ data = snapshot(now, [('copilot_a', 'COPILOT A', 'copilot', [('MONTH', 38, None)])])+ self.assertEqual([r['provider'] for r in overview_rows(data)], ['copilot'])+ for style in STYLES:+ image = Image.open(io.BytesIO(render_page(data, style=style)))+ self.assertEqual(image.size, (240, 240), style)+ data['accounts']['copilot_a']['active'] = True+ frames = arcade.arcade_frames(data, now)+ self.assertTrue(ImageChops.difference(frames[0], frames[6]).getbbox())+ self.assertIn('/assets/copilot-pixel.png', ASSETS)++ def test_four_services_take_turns_on_arcade(self):+ now = time.time()+ data = snapshot(now, [('claude_a', 'CLAUDE A', 'claude', [('WEEK', 86, 3 * D)]),+ ('codex_a', 'CODEX A', 'codex', [('WEEK', 47, 4 * D)]),+ ('grok_a', 'GROK A', 'grok', [('BUDGET', 61, 6 * D)]),+ ('copilot_a', 'COPILOT A', 'copilot', [('MONTH', 38, None)])])+ self.assertEqual(len(overview_rows(data)), 4)+ self.assertLess(len(arcade.render_arcade(data, now)), 400000)+++if __name__ == '__main__':+ unittest.main()diff --git a/tests/test_device.py b/tests/test_device.pyindex 6c1bbbd..e920283 100644--- a/tests/test_device.py+++ b/tests/test_device.py@@ -1,5 +1,6 @@import emailimport email.policy+import hashlibimport jsonimport socketimport tempfile@@ -156,6 +157,230 @@ def ultra_clock(state, calls):return Handler+def sd_pro_clock(state, calls):+ """SD_PRO photo album that keeps what it is sent: names, bytes, the enabled flags and its free space."""+ class Handler(BaseHTTPRequestHandler):+ def log_message(self, *args):+ return+ def reply(self, data):+ body = json.dumps(data).encode()+ self.send_response(200)+ self.end_headers()+ self.wfile.write(body)+ def do_GET(self):+ calls.append(("GET", self.path))+ url = urlparse(self.path)+ query = {key: values[0] for key, values in parse_qs(url.query).items()}+ if url.path == "/photo/list":+ files = [{"name": name, "size": len(data), "enabled": name in state["enabled"]} for name, data in state["files"].items()]+ return self.reply({"files": files, "interval": 10, "total": state["total"],+ "used": state["base"] + sum(len(data) for data in state["files"].values())})+ if url.path == "/theme/list":+ return self.reply({"interval": 10, "themes": [{"id": 0, "enabled": False}, {"id": 2, "enabled": True}]})+ if url.path == "/photo/toggle":+ (state["enabled"].add if query["state"] == "1" else state["enabled"].discard)(query["name"])+ if state.get("lose_answers"): # done on the clock, but the answer never arrives+ state["lose_answers"] -= 1+ self.send_response(500)+ self.end_headers()+ return+ if state.get("cut_answers"): # done, and the answer breaks off part-way+ state["cut_answers"] -= 1+ self.send_response(200)+ self.send_header("Content-Length", "100")+ self.end_headers()+ self.wfile.write(b"{")+ self.close_connection = True+ return+ self.reply({"ok": True})+ def do_POST(self):+ calls.append(("POST", self.path))+ body = self.rfile.read(int(self.headers["Content-Length"]))+ form = email.message_from_bytes(b"Content-Type: " + self.headers["Content-Type"].encode() + b"\r\n\r\n" + body,+ policy=email.policy.HTTP)+ for part in form.iter_parts():+ data = part.get_payload(decode=True)+ others = sum(len(d) for name, d in state["files"].items() if name != part.get_filename())+ room = state["total"] - state["base"] - others # a full clock keeps what fits, and still says OK+ state["files"][part.get_filename()] = data[:len(data) // 2] if state.get("drop") else data[:room]+ self.reply({"ok": True})+ return Handler+++class SlotTests(unittest.TestCase):+ """An animated face never writes over the GIF the clock is playing."""+ def setUp(self):+ self.state = {"files": {"cat.jpg": b"CAT", "tokentv.gif": b"GIF-OLD"}, "enabled": {"tokentv.gif"},+ "total": 3000000, "base": 1500000}+ self.calls = []++ def show(self, display, image):+ return display.show(SD_PRO_BACKUP, "tokentv.gif", image, hashlib.sha256(image).hexdigest())++ def test_each_new_picture_goes_to_a_slot_not_playing_then_the_album_switches(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ playing = []+ for image in (b"GIF-A", b"GIF-B", b"GIF-C", b"GIF-D"):+ sent = self.show(display, image)+ self.assertEqual([r["bytes"] for r in sent], [len(image)])+ self.assertEqual(self.state["enabled"], {display.active})+ self.assertEqual(self.state["files"][display.active], image)+ playing.append(display.active)+ # The one shown at the start of a run is not written over either; the oldest unused slot is reused.+ self.assertEqual(playing, ["tokentv-b.gif", "tokentv.gif", "tokentv-c.gif", "tokentv-b.gif"])+ for before, after in zip(playing, playing[1:]):+ self.assertNotEqual(before, after)++ def test_a_picture_already_on_the_clock_is_a_switch_without_a_send(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ for image in (b"GIF-LOOK", b"GIF-STILL"):+ self.show(display, image)+ start = len(self.calls)+ self.assertEqual(self.show(display, b"GIF-LOOK"), [])+ self.assertEqual(self.state["files"]["tokentv-b.gif"], b"GIF-LOOK")+ self.assertEqual(self.state["enabled"], {"tokentv-b.gif"})+ self.assertEqual(self.calls[start:], [("GET", "/photo/toggle?name=tokentv-b.gif&state=1"),+ ("GET", "/photo/toggle?name=tokentv.gif&state=0")])++ def test_a_picture_is_sent_ahead_and_the_clock_changes_only_at_the_switch(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-A")+ slot, sent = display.put("tokentv.gif", b"GIF-B", hashlib.sha256(b"GIF-B").hexdigest())+ self.assertEqual((slot, len(sent)), ("tokentv.gif", 1))+ self.assertEqual(self.state["enabled"], {"tokentv-b.gif"}) # still the last picture+ display.select(SD_PRO_BACKUP, slot)+ self.assertEqual(self.state["enabled"], {"tokentv.gif"})++ def test_a_clock_low_on_space_has_each_send_read_back_and_a_short_one_is_never_shown(self):+ self.state["total"] = self.state["base"] + 250000 # under the 300 kB kept free: sends are read back+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-GOOD")+ self.state["drop"] = True+ with self.assertRaises(ValueError):+ self.show(display, b"GIF-BROKEN")+ self.assertEqual(self.state["enabled"], {"tokentv-b.gif"})+ self.state["drop"] = False+ self.assertEqual(len(self.show(display, b"GIF-BROKEN")), 1) # not taken as there: sent again+ self.assertEqual(self.state["files"][display.active], b"GIF-BROKEN")++ def test_with_room_to_spare_a_send_is_three_requests_and_the_list_is_read_once(self):+ # Every request holds the clock's animation: upload and two toggles, no read back.+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-A")+ for image in (b"GIF-B", b"GIF-C"):+ start = len(self.calls)+ self.show(display, image)+ self.assertEqual([c[0] for c in self.calls[start:]], ["POST", "GET", "GET"])+ self.assertEqual(sum(c[1] == "/photo/list" for c in self.calls), 2) # the first send, and its activation++ def test_after_a_lost_answer_the_clock_is_listed_and_activated_again_never_written_while_enabled(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-A")+ self.state["lose_answers"] = 1+ with self.assertRaises(OSError):+ self.show(display, b"GIF-B") # the new one is on, the old one still on: two enabled+ self.assertEqual(len(self.state["enabled"]), 1 + 1)+ enabled = set(self.state["enabled"])+ before = {name: self.state["files"][name] for name in enabled}+ self.show(display, b"GIF-C")+ self.assertEqual({name: self.state["files"][name] for name in enabled}, before) # neither written+ self.assertEqual(self.state["enabled"], {display.active})+ self.assertEqual(self.state["files"][display.active], b"GIF-C")++ def test_an_answer_cut_short_is_a_failure_too(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-A")+ self.state["cut_answers"] = 1+ with self.assertRaises(Exception):+ self.show(display, b"GIF-B")+ enabled = set(self.state["enabled"])+ before = {name: self.state["files"][name] for name in enabled}+ self.show(display, b"GIF-C")+ self.assertEqual({name: self.state["files"][name] for name in enabled - {display.active}},+ {name: before[name] for name in enabled - {display.active}})+ self.assertEqual(self.state["enabled"], {display.active})+ self.assertNotIn(display.active, enabled) # written to a slot that was off++ def test_two_of_ours_on_and_little_room_one_is_turned_off_before_a_write(self):+ self.state["total"] = self.state["base"] + 250000 # no third slot+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-A")+ self.state["lose_answers"] = 1+ with self.assertRaises(OSError):+ self.show(display, b"GIF-B")+ self.assertEqual(self.state["enabled"], {"tokentv.gif", "tokentv-b.gif"})+ on = dict(self.state["files"])+ self.show(display, b"GIF-C")+ self.assertEqual(self.state["enabled"], {display.active})+ self.assertEqual(self.state["files"][display.active], b"GIF-C")+ kept = ({"tokentv.gif", "tokentv-b.gif"} - {display.active}).pop()+ self.assertEqual(self.state["files"][kept], on[kept])++ def test_a_photo_the_owner_turned_on_is_turned_off_at_the_next_change(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ for image in (b"GIF-A", b"GIF-B"):+ self.show(display, image)+ self.state["enabled"].add("cat.jpg")+ display.listed_at -= 601+ self.show(display, b"GIF-C")+ self.assertEqual(self.state["enabled"], {display.active})++ def test_the_list_is_read_again_after_ten_minutes(self):+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ for image in (b"GIF-A", b"GIF-B"):+ self.show(display, image)+ self.state["files"]["tokentv-b.gif"] = b"" # emptied on the clock's own page+ display.listed_at -= 601+ self.assertEqual(len(self.show(display, b"GIF-A")), 1) # seen as gone: sent again, not switched to++ def test_a_restart_on_a_full_clock_writes_over_the_gif_that_is_on(self):+ self.state["files"].update({"tokentv.gif": b"G" * 10, "tokentv-b.gif": b"B" * 1000})+ self.state["enabled"] = {"tokentv-b.gif"}+ self.state["total"] = self.state["base"] + 3 + 10 + 1000 + 20000+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ self.show(display, b"GIF-NEW")+ self.assertEqual(self.state["files"]["tokentv-b.gif"], b"GIF-NEW")+ self.assertEqual(self.state["enabled"], {"tokentv-b.gif"})++ def test_the_third_slot_is_written_only_while_room_is_kept(self):+ self.state["files"].update({"tokentv-b.gif": b"B", "tokentv-c.gif": b"C"})+ self.state["total"] = self.state["base"] + 250000+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ for image in (b"GIF-1", b"GIF-2", b"GIF-3", b"GIF-4"):+ self.show(display, image)+ self.assertEqual(self.state["files"]["tokentv-c.gif"], b"C")++ def test_a_third_slot_only_while_the_owner_keeps_room_and_a_full_clock_still_updates(self):+ self.state["total"] = self.state["base"] + 200000+ with serve(sd_pro_clock(self.state, self.calls)) as url:+ display = PhotoDisplay(url)+ for image in (b"GIF-A", b"GIF-B", b"GIF-C"):+ self.show(display, image)+ self.assertNotIn("tokentv-c.gif", self.state["files"]) # two slots, taken in turn+ self.assertEqual((self.state["files"]["tokentv.gif"], self.state["files"]["tokentv-b.gif"]), (b"GIF-B", b"GIF-C"))+ # The owner's new photos fill the clock: the send that no longer fits is caught and not shown, and the+ # next one, seeing no room for a second copy, writes over the one shown, as before slots.+ self.state["files"]["owner.jpg"] = b"x" * (200000 - 10)+ with self.assertRaises(ValueError):+ self.show(display, b"GIF-D")+ self.assertEqual(self.state["enabled"], {"tokentv-b.gif"})+ self.show(display, b"GIF-D")+ self.assertEqual(self.state["files"]["tokentv-b.gif"], b"GIF-D")+ self.assertEqual(self.state["enabled"], {"tokentv-b.gif"})++SD_PRO_BACKUP = {"themes": [{"id": 0, "enabled": True}, {"id": 2, "enabled": False}], "theme_interval": 10,"files": [{"name": "original.jpg", "enabled": True}], "photo_interval": 10}ULTRA_BACKUP = {"model": "ultra", "theme": 1, "autoplay": 1, "i_i": 5}diff --git a/tests/test_display_styles.py b/tests/test_display_styles.pyindex 7e35638..392e1a7 100644--- a/tests/test_display_styles.py+++ b/tests/test_display_styles.py@@ -78,14 +78,14 @@ class DisplayStyleTests(unittest.TestCase):for frame in frames:image = Image.open(io.BytesIO(frame))self.assertEqual(image.size, (240, 240))- if frame[:4] == b'GIF8': # the animated Space face+ if frame[:4] == b'GIF8': # the animated Space and Arcade facesself.assertEqual(image.format, 'GIF')self.assertGreater(image.n_frames, 1)self.assertLess(len(frame), 400000)else:self.assertEqual(image.format, 'JPEG')self.assertLess(len(frame), 60000)- self.assertEqual(sum(f[:4] == b'GIF8' for f in frames[:len(STYLES)]), 1)+ self.assertEqual(sum(f[:4] == b'GIF8' for f in frames[:len(STYLES)]), 2)with self.assertRaises(ValueError):render_page(sample, style='unknown')@@ -120,4 +120,5 @@ class ConfiguredServicesOnlyTest(unittest.TestCase):self.assertEqual([r['provider'] for r in overview_rows(data)], ['claude']) # no LOGIN rows for unused servicesfor style in STYLES:self.assertTrue(render_page(data, style=style)) # every face copes with one row- self.assertEqual(len(overview_rows({'accounts': {}})), 3) # empty config keeps the placeholders+ from token_tv.display import PROVIDERS+ self.assertEqual(len(overview_rows({'accounts': {}})), len(PROVIDERS)) # empty config keeps the placeholdersdiff --git a/tests/test_gif.py b/tests/test_gif.pynew file mode 100644index 0000000..6f9c231--- /dev/null+++ b/tests/test_gif.py@@ -0,0 +1,70 @@+import io+import time+import unittest++from PIL import Image, ImageDraw++from token_tv import arcade, gif+from token_tv.sample import H, snapshot+++def timeline(data, step):+ """Each frame as shown, one entry per `step` ms."""+ image, out = Image.open(io.BytesIO(data)), []+ for n in range(image.n_frames):+ image.seek(n)+ out += [image.convert('RGB').tobytes()] * round(image.info['duration'] / step)+ return out+++class GifTests(unittest.TestCase):+ def test_the_clock_gets_the_same_pixels_in_fewer_bytes(self):+ now = time.mktime((2026, 10, 28, 12, 0, 0, 0, 0, -1))+ frames = arcade.arcade_frames(snapshot(now, [('a', 'A', 'codex', [('WEEK', 47, 3 * 86400)])]), now)+ indexed = gif.indexed(frames, 'Arcade')+ data = gif.encode(indexed, [70] * len(indexed))+ self.assertEqual(timeline(data, 70), [f.convert('RGB').tobytes() for f in indexed])+ pillow = io.BytesIO() # Pillow's own best: its palette and transparency optimizing, interlaced+ indexed[0].save(pillow, format='GIF', save_all=True, append_images=indexed[1:], duration=70, loop=0,+ disposal=1, optimize=True)+ self.assertLess(len(data), .9 * len(pillow.getvalue()))+ palette_bits = (data[10] & 7) + 1+ self.assertLess(palette_bits, 8)+ first = 13 + 3 * (1 << palette_bits) + 19 + 8 # header, table, loop extension, frame timing+ self.assertEqual(data[first], 0x2C)+ self.assertEqual(data[first + 10], palette_bits) # LZW codes start as wide as the palette, not at 8++ def test_a_still_stretch_is_one_longer_frame_and_a_change_only_its_box(self):+ frames = [Image.new('RGB', (40, 40), (10, 20, 30)) for _ in range(4)]+ ImageDraw.Draw(frames[3]).rectangle((5, 6, 8, 9), fill=(200, 100, 0))+ data = gif.encode(gif.indexed(frames, 'Test'), [70] * 4)+ image = Image.open(io.BytesIO(data))+ self.assertEqual(image.n_frames, 2)+ self.assertEqual(image.info['duration'], 210)+ self.assertEqual(image.info['loop'], 0)+ image.seek(1)+ self.assertEqual(image.dispose_extent, (5, 6, 9, 10))+ self.assertEqual(timeline(data, 70), [f.tobytes() for f in frames])++ def test_a_frame_where_every_pixel_changes_has_no_transparent_pixels_and_still_plays_right(self):+ import random+ rnd = random.Random(4)+ first, second = Image.new('RGB', (64, 64)), Image.new('RGB', (64, 64))+ first.putdata([(rnd.randrange(16) * 8, 0, 0) for _ in range(64 * 64)])+ second.putdata([(200 + rnd.randrange(2) * 40, 9, 9) for _ in range(64 * 64)]) # two colours, a short palette+ indexed = gif.indexed([first, second], 'Test')+ self.assertEqual(timeline(gif.encode(indexed, [70, 70]), 70), [f.convert('RGB').tobytes() for f in indexed])++ def test_a_full_palette_has_no_index_left_for_unchanged_and_still_plays_right(self):+ frames = []+ for shift in range(3):+ frame = Image.new('RGB', (16, 16))+ frame.putdata([((i + shift) % 256, 0, 0) for i in range(256)])+ frames.append(frame)+ indexed = gif.indexed(frames, 'Test')+ self.assertEqual(len(indexed[0].getpalette()) // 3, 256)+ self.assertEqual(timeline(gif.encode(indexed, [70] * 3), 70), [f.convert('RGB').tobytes() for f in indexed])+++if __name__ == '__main__':+ unittest.main()diff --git a/tests/test_live.py b/tests/test_live.pyindex 8d2d3f5..c94e0db 100644--- a/tests/test_live.py+++ b/tests/test_live.py@@ -123,19 +123,38 @@ class LiveTests(unittest.TestCase):self.assertGreater(len(image.getcolors(240 * 240)), 20)self.assertLess(len(body), 60000)- def test_overview_keeps_one_account_per_provider_without_losing_details(self):- def account(provider, alias, status="ok"):+ def test_each_account_gets_a_row_and_more_than_four_keep_the_most_relevant(self):+ def account(provider, alias, status="ok", used=94):return {"provider": provider, "alias": alias, "status": status,- "windows": [] if status != "ok" else [{"label": "WEEK", "used_percent": 94, "resets_at": None}]}+ "windows": [] if status != "ok" else [{"label": "WEEK", "used_percent": used, "resets_at": None}]}snapshot = {"accounts": {- "ca": account("claude", "CLAUDE A"), "cb": account("claude", "CLAUDE B"),+ "ca": account("claude", "CLAUDE A"), "cb": account("claude", "CLAUDE B", used=20),"cc": account("claude", "CLAUDE C"), "xa": account("codex", "CODEX A"),- "ga": account("grok", "GROK A", "auth_required"), "gb": account("grok", "GROK B")}}- rows = overview_rows(snapshot)- self.assertEqual([r["key"] for r in rows], ["ca", "xa", "gb"])+ "ga": account("grok", "GROK A", "auth_required"), "gb": account("grok", "GROK B", used=50)}}+ rows = overview_rows(snapshot) # four rows: the fullest accounts with a reading, in service order+ self.assertEqual([r["key"] for r in rows], ["ca", "cc", "xa", "gb"])+ snapshot["accounts"]["cb"]["active"] = True # an account in use takes a row first+ self.assertEqual([r["key"] for r in overview_rows(snapshot)], ["ca", "cb", "cc", "xa"])+ two = {"accounts": {"xa": account("codex", "CODEX A"), "xb": account("codex", "CODEX B")}}+ self.assertEqual([r["key"] for r in overview_rows(two)], ["xa", "xb"]) # two of one service, two rowsself.assertEqual(len(snapshot["accounts"]), 6)self.assertEqual(render_page(snapshot, 0), render_page(snapshot, 1))+ def test_roomy_rows_show_both_windows_and_crowded_ones_the_week(self):+ from token_tv.display import shown_windows, slots+ row = {"windows": [{"label": "WEEK", "used_percent": 80}, {"label": "5H", "used_percent": 20}]}+ self.assertEqual([w["label"] for w in shown_windows(row, 1)], ["5H", "WEEK"])+ self.assertEqual([w["label"] for w in shown_windows(row, 2)], ["5H", "WEEK"])+ self.assertEqual([w["label"] for w in shown_windows(row, 3)], ["WEEK"])+ self.assertEqual([w["label"] for w in shown_windows({"windows": [{"label": "5H", "used_percent": 3}]}, 4)], ["5H"])+ self.assertEqual(shown_windows({"windows": []}, 1), [])+ self.assertEqual([(s.y, s.h) for s in slots(3)], [(3, 76), (82, 76), (161, 76)]) # three rows as always+ for count in (1, 2, 4):+ places = slots(count)+ self.assertEqual(len(places), count)+ self.assertEqual(places[0].y, 3)+ self.assertLessEqual(places[-1].y + places[-1].h, 3 + 2 * 79 + 76 + 1)+def test_overview_preserves_quota_period_and_unknown_values(self):windows = [{"label": "5H", "used_percent": 2}, {"label": "WEEK", "used_percent": 94}]self.assertEqual(primary_window({"windows": windows})["label"], "WEEK")@@ -145,3 +164,12 @@ class LiveTests(unittest.TestCase):if __name__ == "__main__":unittest.main()+++class LoopTimingTests(unittest.TestCase):+ def test_a_new_picture_goes_as_the_loop_ends(self):+ from token_tv.live import until_loop_end+ shown = {'at': 100.0, 'loop': 8.4}+ self.assertAlmostEqual(until_loop_end(shown, 101.0), 7.4) # 1 s in+ self.assertAlmostEqual(until_loop_end(shown, 100.0 + 2 * 8.4), 0) # right at the end of the second loop+ self.assertEqual(until_loop_end({'at': None, 'loop': None}, 5), 0)diff --git a/tests/test_lockbox.py b/tests/test_lockbox.pynew file mode 100644index 0000000..8e73bd2--- /dev/null+++ b/tests/test_lockbox.py@@ -0,0 +1,583 @@+import base64+import io+import json+import tempfile+import time+import unittest+from pathlib import Path++from PIL import Image++from token_tv import arcade, lockbox+from token_tv.sample import D, snapshot+from token_tv.state import UsageStore+++def at(hour, minute=0, day=29):+ return time.mktime((2026, 10, day, hour, minute, 0, 0, 0, -1))+++def content(name, tier='unique'):+ return {'name': name, 'tier': tier, 'seconds': 6, 'height': 71, 'strip': strip(len(name))}+++def strip(frames):+ image = Image.new('RGB', (120, 71 * frames), (9, 9, 9))+ buffer = io.BytesIO()+ image.save(buffer, format='PNG')+ return base64.b64encode(buffer.getvalue()).decode()+++class LockboxTests(unittest.TestCase):+ def setUp(self):+ self.dir = tempfile.TemporaryDirectory()+ self.bundle = Path(self.dir.name) / 'eggs.bin'+ salt = b'0123456789abcdef'+ boxes = [lockbox.seal(salt, {'hour=10', 'minute=7'}, content('late'), chance=1, cooldown_days=7),+ lockbox.seal(salt, {'codex:crossed_70'}, content('jump'), chance=1, cooldown_days=7),+ lockbox.seal(salt, {'codex:active'}, content('legendary', 'legend'), chance=1, cooldown_days=28),+ lockbox.seal(salt, {'weekend=yes'}, content('maybe'), chance=.05, cooldown_days=7)]+ self.bundle.write_text(json.dumps({'salt': salt.hex(), 'boxes': boxes}))+ self.rolls = []+ self.box = lambda: lockbox.Lockbox(Path(self.dir.name) / 'history.json', self.bundle,+ roll=lambda: self.rolls.pop(0) if self.rolls else 0.0)++ def tearDown(self):+ self.dir.cleanup()++ def data(self, now, **row):+ out = snapshot(now, [('codex_a', 'CODEX A', 'codex', [('WEEK', 50, 3 * D)])])+ out['accounts']['codex_a'].update(row)+ return out++ def test_the_bundle_says_nothing_readable_about_what_opens_a_box(self):+ text = self.bundle.read_text()+ for word in ('hour', 'minute', 'jump', 'late', 'legendary', 'codex'):+ self.assertNotIn(word, text)++ def test_a_box_opens_only_in_its_situation_and_then_rests(self):+ locks = self.box()+ self.assertIsNone(locks.pick(self.data(at(10, 6)), at(10, 6)))+ box = locks.pick(self.data(at(10, 7)), at(10, 7))+ self.assertEqual((box.name, box.tier, box.key, len(box.frames)), ('late', 'unique', 'codex_a', 4))+ self.assertEqual(box.frames[0].size, (120, 71))+ self.assertIsNone(locks.pick(self.data(at(10, 7, day=30)), at(10, 7, day=30))) # a week's cooldown+ self.assertEqual(locks.pick(self.data(at(10, 7, day=36)), at(10, 7, day=36)).name, 'late') # a week on++ def test_news_counts_for_ten_minutes_and_hidden_ones_keep_apart_unless_legendary(self):+ locks = self.box()+ now = at(12)+ news = dict(news=[{'kind': 'crossed', 'value': 70, 'at': now}])+ self.assertEqual(locks.pick(self.data(now, **news), now).name, 'jump')+ self.assertIsNone(locks.pick(self.data(now + 60, **news), now + 60)) # thirty minutes apart+ legend = locks.pick(self.data(now + 120, active=True), now + 120)+ self.assertEqual(legend.tier, 'legend') # a legend does not wait+ stale = dict(news=[{'kind': 'crossed', 'value': 70, 'at': now}])+ self.assertNotIn('codex:crossed_70', lockbox.facts(self.data(now + 700, **stale), locks.history, now + 700)['codex_a'])++ def test_one_roll_each_time_a_situation_comes_about_and_sure_once_twice_its_share_has_passed(self):+ locks = self.box()+ saturday = time.mktime((2026, 10, 31, 15, 0, 0, 0, 0, -1))+ data = locks.history.data+ data['met'] = {'other': {'first': saturday - 70 * D, 'count': 70, 'tier': 'unique'}} # a daily one+ data['held'] = {'other': saturday}+ self.rolls[:] = [.99]+ self.assertIsNone(locks.pick(self.data(saturday), saturday)) # missed (two uniques met: 16 days each)+ self.rolls[:] = [.0, .0]+ self.assertIsNone(locks.pick(self.data(saturday + 60), saturday + 60)) # the same afternoon: no new roll+ self.assertEqual(self.rolls, [.0, .0])+ week = 7 * D+ for n in range(1, 5): # more Saturday afternoons, every roll a miss+ data['held']['other'] = saturday + n * week+ self.rolls[:] = [.99]+ self.assertIsNone(locks.pick(self.data(saturday + n * week), saturday + n * week))+ data['held']['other'] = saturday + 5 * week+ self.rolls[:] = [.99]+ box = locks.pick(self.data(saturday + 5 * week), saturday + 5 * week)+ self.assertEqual(box.name, 'maybe') # 35 days on, past twice its share: sure++ def test_the_odds_follow_how_often_a_situation_comes_about(self):+ self.assertAlmostEqual(lockbox.odds(14, 14, 12, first=False), 1 / 12) # daily, one opening in twelve days+ self.assertAlmostEqual(lockbox.odds(14, 14, 12, first=True), 2 / 12)+ self.assertAlmostEqual(lockbox.odds(2, 14, 12, first=False), 7 / 12) # weekly: most times it comes+ self.assertEqual(lockbox.odds(1, 0, 3, first=False), 1.0) # new to the clock, and its tier's only box++ def test_a_tier_shares_its_pace_and_keeps_apart(self):+ self.assertAlmostEqual(lockbox.shares([1, 1], 8), 16) # two daily boxes: each every 16 days+ self.assertAlmostEqual(lockbox.shares([.01, 1], 8), 1 / (1 / 8 - .01)) # a rare one opens every time+ self.assertEqual(lockbox.shares([.01, .02], 8), 0) # both too rare for the pace: every time+ locks = self.box()+ saturday = time.mktime((2026, 10, 31, 15, 0, 0, 0, 0, -1))+ locks.history.data['spaced'] = {'unique': saturday}+ self.rolls[:] = [.0, .0]+ self.assertIsNone(locks.pick(self.data(saturday + 7 * D + 3600), saturday + 7 * D + 3600 - 2 * D)) # kept apart+ self.assertEqual(self.rolls, [.0, .0])++ def test_two_won_together_keep_their_tier_apart(self):+ salt = b'0123456789abcdef'+ boxes = [lockbox.seal(salt, {'claude:idle'}, content('one', 'rare'), chance=.5, cooldown_days=3),+ lockbox.seal(salt, {'codex:idle'}, content('two', 'rare'), chance=.5, cooldown_days=3)]+ self.bundle.write_text(json.dumps({'salt': salt.hex(), 'boxes': boxes}))+ locks = self.box()+ now = at(12)+ data = snapshot(now, [('claude_a', 'A', 'claude', [('WEEK', 50, 3 * D)]), ('codex_a', 'B', 'codex', [('WEEK', 50, 3 * D)])])+ for row in data['accounts'].values():+ row['active'] = False # both at rest: both situations hold+ first = locks.pick(data, now)+ self.assertIsNotNone(first)+ self.assertIsNone(locks.pick(data, now + lockbox.GAP + 60)) # the other rare waits out the day++ def test_a_legend_plays_in_its_minute(self):+ locks = self.box()+ now = at(12)+ self.rolls[:] = [.0, .99] # won; a delay roll that would push anything else minutes on+ self.assertEqual(locks.pick(self.data(now, active=True), now).tier, 'legend')++ def test_a_pick_that_never_reached_the_clock_is_taken_back(self):+ locks = self.box()+ self.assertEqual(locks.pick(self.data(at(10, 7)), at(10, 7)).name, 'late')+ locks.forget()+ self.assertEqual(locks.collection()['hidden'], 4)+ self.assertEqual(locks.pick(self.data(at(10, 7, day=30)), at(10, 7, day=30)).name, 'late') # no cooldown++ def test_a_win_waits_a_moment_while_its_situation_still_holds(self):+ locks = self.box()+ saturday = time.mktime((2026, 10, 31, 15, 0, 0, 0, 0, -1))+ self.rolls[:] = [.0, .5] # won; plays half the delay later+ self.assertIsNone(locks.pick(self.data(saturday), saturday))+ self.assertIsNone(locks.pick(self.data(saturday + 60), saturday + 60))+ box = locks.pick(self.data(saturday + lockbox.DELAY / 2 + 1), saturday + lockbox.DELAY / 2 + 1)+ self.assertEqual(box.name, 'maybe')++ def test_found_scenes_fill_the_collection_and_play_again(self):+ locks = self.box()+ self.assertEqual(locks.collection(), {'found': [], 'total': 4, 'hidden': 4})+ locks.pick(self.data(at(10, 7)), at(10, 7))+ book = locks.collection()+ self.assertEqual((book['hidden'], len(book['found'])), (3, 1))+ seen = book['found'][0]+ self.assertEqual((seen['name'], seen['tier'], seen['count']), ('late', 'unique', 1))+ self.assertNotIn('combo', seen) # the page never learns what opened it+ again = locks.replay(seen['check'])+ self.assertEqual((again.name, again.key), ('late', 'codex_a'))+ self.assertIsNone(locks.replay('not-a-box'))++ def test_the_dashboard_lists_the_collection_and_queues_a_replay(self):+ import http.client+ import threading+ from http.server import ThreadingHTTPServer+ from token_tv import live+ locks = self.box()+ locks.pick(self.data(at(10, 7)), at(10, 7))+ check = locks.collection()['found'][0]['check']+ store = UsageStore([{'key': 'codex_a', 'alias': 'A', 'provider': 'codex'}], fetch=lambda _: None)+ replays, wake = [], threading.Event()+ server = ThreadingHTTPServer(('127.0.0.1', 0), live.handler(store, None, locks, replays, wake))+ threading.Thread(target=server.serve_forever, daemon=True).start()+ try:+ def ask(method, path, body=None):+ conn = http.client.HTTPConnection('127.0.0.1', server.server_port, timeout=10)+ conn.request(method, path, body, {'Content-Type': 'application/json'} if body else {})+ reply = conn.getresponse()+ return reply.status, reply.read()+ status, body = ask('GET', '/collection')+ self.assertEqual((status, json.loads(body)['hidden']), (200, 3))+ self.assertEqual(ask('POST', '/collection/replay', json.dumps({'check': check}))[0], 200)+ self.assertEqual((replays, wake.is_set()), ([check], True))+ self.assertEqual(ask('POST', '/collection/replay', json.dumps({'check': 'nope'}))[0], 400)+ finally:+ server.shutdown()++ def test_no_bundle_means_no_hidden_one_offs(self):+ locks = lockbox.Lockbox(Path(self.dir.name) / 'history.json', Path(self.dir.name) / 'none.bin')+ self.assertIsNone(locks.pick(self.data(at(10, 7)), at(10, 7)))+++class FactTests(unittest.TestCase):+ def test_the_facts_of_a_moment(self):+ with tempfile.TemporaryDirectory() as directory:+ history = lockbox.History(Path(directory) / 'history.json')+ now = time.mktime((2026, 10, 30, 23, 15, 0, 0, 0, -1)) # a Friday, late+ data = snapshot(now, [(f'{p}_a', p, p, [('WEEK', 40, 3 * D)]) for p in lockbox.PROVIDERS])+ for row in data['accounts'].values():+ row.update(active=True, rose_at=now - 60, active_since=now - 7300)+ found = lockbox.facts(data, history, now)['claude_a']+ for fact in ('hour=23', 'minute=15', 'weekday=fri', 'weekend=no', 'daypart=late', 'date=10-30',+ 'all_active', 'all_used_today', 'claude:active', 'claude:active_1h', 'claude:active_2h',+ 'claude:worked_today'):+ self.assertIn(fact, found)+ self.assertNotIn('codex:active', found) # an account sees only its own facts and the shared ones++ def test_four_full_weeks_in_a_row_and_the_anniversary(self):+ with tempfile.TemporaryDirectory() as directory:+ history = lockbox.History(Path(directory) / 'history.json')+ start = time.mktime((2026, 10, 5, 12, 0, 0, 0, 0, -1))+ for week in range(4):+ when = start + week * 7 * D+ history.observe(snapshot(when, [('codex_a', 'A', 'codex', [('WEEK', 100, D)])]), when)+ self.assertEqual(history.full_streak('codex_a', start + 3 * 7 * D), 4)+ self.assertEqual(history.full_streak('codex_a', start + 4 * 7 * D), 0) # this week is not full yet+ for month in range(4): # a monthly limit counts months, a budget too+ when = time.mktime((2026, 7 + month, 15, 12, 0, 0, 0, 0, -1))+ history.observe(snapshot(when, [('copilot_a', 'C', 'copilot', [('MONTH', 100, None)]),+ ('grok_a', 'G', 'grok', [('BUDGET', 100, None)])]), when)+ self.assertEqual(history.full_streak('copilot_a', time.mktime((2026, 10, 20, 9, 0, 0, 0, 0, -1))), 4)+ self.assertEqual(history.full_streak('grok_a', time.mktime((2026, 10, 20, 9, 0, 0, 0, 0, -1))), 4)+ self.assertFalse(history.anniversary(start + 30 * D))+ self.assertTrue(history.anniversary(time.mktime((2027, 10, 5, 9, 0, 0, 0, 0, -1))))++ def test_a_reading_brings_its_news(self):+ readings = [(70, 1), (85, 1), (88, 0)] # a third and fourth reading follow+ def fetch(_):+ used, count = readings.pop(0)+ return {'key': 'a', 'alias': 'A', 'provider': 'codex', 'status': 'ok', 'fetched_at': time.time(),+ 'windows': [{'label': 'WEEK', 'used_percent': used, 'resets_at': None}],+ 'reset_credits': {'count': count, 'expires_at': time.time() + 3600}}+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}], fetch=fetch)+ store.refresh()+ store.refresh()+ news = {item['kind']: item['value'] for item in store.snapshot()['accounts']['a']['news']}+ self.assertEqual((news['jump'], news['crossed']), (15, 80))+ self.assertTrue(store.snapshot()['accounts']['a']['active_since'])+ store.refresh()+ spent = [i for i in store.snapshot()['accounts']['a']['news'] if i['kind'] == 'ticket_spent']+ self.assertLess(spent[0]['value'], 1) # spent on its last day+ readings.append((88, 0))+ store.refresh() # an unchanged reading keeps the news, so a rare event played first does not swallow it+ self.assertTrue(any(i['kind'] == 'ticket_spent' for i in store.snapshot()['accounts']['a']['news']))+++class ReviewFixTests(unittest.TestCase):+ def test_a_badge_leaves_the_reset_countdown_alone(self):+ now = time.time()+ data = snapshot(now, [('codex_a', 'CODEX A', 'codex', [('WEEK', 50, 3 * D)])])+ stage = tuple(Image.new('RGB', (120, 71)) for _ in range(2))+ panel = (120, 172, 240, 240)+ after = arcade.BURST_FRAMES['unique'] + 1 # once the cut-in has gone+ plain = arcade.arcade_frames(data, now)[after].crop(panel)+ boxed = arcade.arcade_frames(data, now, lockbox.Box('x', 'unique', 'codex_a', stage, 6))[after].crop(panel)+ self.assertEqual(plain.tobytes(), boxed.tobytes())++ def test_unique_and_legend_open_with_a_whole_screen_cut_in_and_rare_without(self):+ now = time.time()+ data = snapshot(now, [('codex_a', 'CODEX A', 'codex', [('WEEK', 50, 3 * D)])])+ stage = tuple(Image.new('RGB', (120, 71)) for _ in range(2))+ header, panel = (0, 0, 240, 26), (0, 172, 240, 240)+ plain = arcade.arcade_frames(data, now)[3]+ for tier, cut in (('rare', False), ('unique', True), ('legend', True)):+ shown = arcade.arcade_frames(data, now, lockbox.Box('x', tier, 'codex_a', stage, 6))[3]+ self.assertEqual(shown.crop(panel).tobytes() != plain.crop(panel).tobytes(), cut, tier)+ quiet = arcade.arcade_frames(data, now, lockbox.Box('x', tier, 'codex_a', stage, 6, intro=False))[3]+ self.assertEqual(quiet.crop(panel).tobytes(), plain.crop(panel).tobytes(), tier) # the quiet loop: no cut-in++ def test_unavailable_accounts_are_neither_working_nor_idle(self):+ with tempfile.TemporaryDirectory() as directory:+ now = time.time()+ data = snapshot(now, [('copilot_a', 'C', 'copilot', [('MONTH', 40, None)])])+ data['accounts']['copilot_a']['status'] = 'auth_required'+ found = lockbox.facts(data, lockbox.History(Path(directory) / 'h.json'), now)['copilot_a']+ self.assertFalse({'copilot:idle', 'copilot:active'} & found)++ def test_a_streak_counts_calendar_weeks_across_a_clock_change(self):+ import os+ saved = os.environ.get('TZ')+ os.environ['TZ'] = 'America/New_York'+ time.tzset()+ try:+ with tempfile.TemporaryDirectory() as directory:+ history = lockbox.History(Path(directory) / 'h.json')+ history.data['peaks'] = {'a': {'WEEK': {'2026-W42': 100, '2026-W43': 100, '2026-W44': 100}}}+ now = time.mktime((2026, 11, 1, 23, 30, 0, 0, 0, -1)) # the day the clocks go back+ self.assertEqual(history.full_streak('a', now), 3)+ finally:+ if saved is None:+ os.environ.pop('TZ', None)+ else:+ os.environ['TZ'] = saved+ time.tzset()++ @unittest.skipUnless((Path(__file__).resolve().parents[1] / 'pyproject.toml').exists(), 'a source copy without packaging')+ def test_the_bundle_is_packaged(self):+ self.assertIn('"*.bin"', (Path(__file__).resolve().parents[1] / 'pyproject.toml').read_text())+++class TimingTests(unittest.TestCase):+ """When a reading counts as what: rates for jumps, the provider's reset time for resets, a margin for worry."""++ @staticmethod+ def row(used, at, resets_at=None, status='ok', **fields):+ return dict({'key': 'a', 'alias': 'A', 'provider': 'codex', 'status': status, 'fetched_at': at,+ 'windows': [{'label': '5H', 'used_percent': used, 'resets_at': resets_at}]}, **fields)++ def test_a_jump_is_a_rate_so_a_long_gap_is_not_a_sudden_one(self):+ from token_tv.state import news_of+ now = time.time()+ jump = lambda gap, rise: next(i['value'] for i in news_of(self.row(40, now - gap), self.row(40 + rise, now))+ if i['kind'] == 'jump')+ self.assertEqual(jump(120, 12), 12) # twelve points in two minutes+ self.assertLess(jump(3600, 15), 10) # fifteen over an hour++ def test_a_jump_adds_up_the_last_ten_minutes_and_an_outage_is_not_one(self):+ start = time.time() - 4000+ def jumps(readings):+ readings = list(readings)+ def fetch(_):+ at, used = readings.pop(0)+ return self.row(used, start + at, status='ok' if used is not None else 'error')+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}], fetch=fetch)+ for _ in range(len(readings)):+ store.refresh()+ news = store.snapshot()['accounts']['a'].get('news', [])+ return max([i['value'] for i in news if i['kind'] == 'jump'] or [0])+ self.assertEqual(jumps([(0, 40), (250, 45), (500, 51)]), 11) # two small steps, one sharp ten minutes+ self.assertLess(jumps([(0, 40), (3540, None), (3600, 55)]), 10) # the kept 40% is an hour old++ def test_a_reset_needs_its_reset_time_to_pass_or_move_on(self):+ from token_tv.state import event_of+ now = time.time()+ due, later = now + 30, now + 3 * 3600+ self.assertIsNone(event_of(self.row(60, now - 60, later), self.row(5, now, later))) # a correction+ self.assertEqual(event_of(self.row(60, now - 60, due), self.row(5, now, now + 5 * 3600)), 'reset')+ self.assertEqual(event_of(self.row(60, now - 60, later), self.row(5, now, later + 5 * 3600)), 'reset')+ self.assertEqual(event_of(self.row(60, now - 60), self.row(5, now)), 'reset') # no reset time known++ def test_a_reading_with_other_windows_is_not_compared(self):+ from token_tv.state import event_of, news_of, rose+ now = time.time()+ before = self.row(80, now - 60)+ before['windows'] = [{'label': 'WEEK', 'used_percent': 80, 'resets_at': None},+ {'label': 'WEEK2', 'used_percent': 5, 'resets_at': None}]+ after = self.row(5, now)+ after['windows'] = [{'label': 'WEEK', 'used_percent': 5, 'resets_at': None}] # the first went missing+ self.assertIsNone(event_of(before, after))+ self.assertFalse(rose(after, before))+ self.assertFalse({'jump', 'crossed'} & {i['kind'] for i in news_of(after, before)})++ def test_a_saved_reset_that_ran_out_was_not_spent(self):+ from token_tv.state import event_of, news_of+ now = time.time()+ before = self.row(40, now - 60, reset_credits={'count': 1, 'expires_at': now - 30})+ after = self.row(40, now, reset_credits={'count': 0, 'expires_at': None})+ self.assertIsNone(event_of(before, after))+ self.assertNotIn('ticket_spent', {i['kind'] for i in news_of(before, after)})+ before['reset_credits']['expires_at'] = now + 3600 # still good an hour more: used+ self.assertEqual(event_of(before, after), 'reset')++ def test_worry_starts_at_90_and_ends_below_85_and_an_outage_changes_nothing(self):+ readings = [(91, 'ok'), (87, 'ok'), (None, 'error'), (84, 'ok')]+ def fetch(_):+ used, status = readings.pop(0)+ row = self.row(used, time.time(), status=status)+ if used is None:+ row['windows'] = []+ return row+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}], fetch=fetch)+ seen = []+ for _ in range(4):+ store.refresh()+ seen.append(bool(store.snapshot()['accounts']['a'].get('worry')))+ self.assertEqual(seen, [True, True, True, False])++ def test_a_crossing_names_its_window_so_a_picture_drawn_ahead_stays_true(self):+ now = time.time()+ data = snapshot(now, [('codex_a', 'A', 'codex', [('5H', 81, 3600), ('WEEK', 82, 3 * D)])])+ with tempfile.TemporaryDirectory() as directory:+ history = lockbox.History(Path(directory) / 'history.json')+ for label, main in (('5H', False), ('WEEK', True)):+ data['accounts']['codex_a']['news'] = [{'kind': 'crossed', 'value': 80, 'label': label, 'at': now}]+ found = lockbox.facts(data, history, now)['codex_a']+ self.assertIn('codex:crossed_80', found)+ self.assertEqual('codex:main_crossed_80' in found, main) # the picture follows the week+ data['accounts']['codex_a']['windows'][1]['used_percent'] = 100 # gone on to full: the garden is complete+ self.assertNotIn('codex:main_crossed_80', lockbox.facts(data, history, now)['codex_a'])++ def test_five_hour_windows_in_a_row_count_for_the_full_points(self):+ now = time.time()+ with tempfile.TemporaryDirectory() as directory:+ history = lockbox.History(Path(directory) / 'history.json')+ for k, used in enumerate((100, 60, 100, 100)):+ data = snapshot(now, [('anti_a', 'A', 'antigravity', [('5H', used, 3600)])])+ data['accounts']['anti_a']['windows'][0]['resets_at'] = now + k * 5 * 3600+ history.observe(data, now)+ self.assertEqual(history.five_hour_run('anti_a'), 2)++ def test_coming_back_after_an_hour_and_the_first_use_of_the_day(self):+ from token_tv.state import news_of+ now = time.time()+ kinds = lambda news: {i['kind'] for i in news}+ self.assertIn('back', kinds(news_of(self.row(10, now - 60, rose_at=now - 2 * 3600), self.row(12, now))))+ self.assertNotIn('back', kinds(news_of(self.row(10, now - 60, rose_at=now - 600), self.row(12, now))))+ data = snapshot(now, [('codex_a', 'CODEX A', 'codex', [('WEEK', 50, 3 * D)]),+ ('claude_a', 'CLAUDE A', 'claude', [('WEEK', 50, 3 * D)])])+ data['accounts']['codex_a']['news'] = [{'kind': 'first_today', 'value': True, 'at': now}]+ with tempfile.TemporaryDirectory() as directory:+ found = lockbox.facts(data, lockbox.History(Path(directory) / 'history.json'), now)+ self.assertIn('day_start', found['claude_a']) # the day's first use counts for every account+++class GardenTests(unittest.TestCase):+ def test_five_spots_show_at_every_reading_and_only_a_full_fifth_blooms(self):+ marks = {arcade.PLOT, arcade.STEM, arcade.BUD, arcade.PETAL}+ def garden(used):+ stage = Image.new('RGB', (120, 71))+ arcade.codex_scene(stage, arcade.ImageDraw.Draw(stage), (0, 0, 120, 71), 0, 10, False, 1, {'used': used})+ return stage+ def spots(stage): # a plot, a sprout or a flower at each of the five places+ return sum(any(stage.getpixel((x + d, y)) in marks for d in range(-6, 6) for y in range(71))+ for x in (12, 36, 60, 84, 108))+ def blooms(stage):+ return sum(1 for p in stage.getdata() if p == arcade.HEART)+ for used in (0, 20, 40, 41, 60, 80, 99):+ self.assertEqual(spots(garden(used)), 5, used)+ self.assertEqual(blooms(garden(58)), blooms(garden(40))) # 58% is a bud on the third spot, not a bloom+ self.assertGreater(blooms(garden(60)), blooms(garden(58)))+++NOON = time.mktime((2026, 10, 28, 12, 0, 0, 0, 0, -1)) # exact colours: the stage dims at night+++class PropTests(unittest.TestCase):+ def test_a_trace_is_the_prop_standing_in_the_scene_not_a_header_mark(self):+ now = NOON+ art = Image.new('RGBA', (7, 6), (255, 0, 255, 255))+ buffer = io.BytesIO()+ art.save(buffer, format='PNG')+ prop = base64.b64encode(buffer.getvalue()).decode()+ for provider in ('claude', 'codex', 'grok', 'copilot', 'antigravity'):+ data = snapshot(now, [(f'{provider}_a', 'A', provider, [('WEEK', 40, 3 * D)])])+ plain = arcade.arcade_frames(data, now)[0]+ data['accounts'][f'{provider}_a'].update(trace='legend', trace_prop=prop)+ left = arcade.arcade_frames(data, now)[0]+ self.assertIn((255, 0, 255), [p for p in left.crop((0, 28, 240, 170)).getdata()], provider)+ self.assertEqual(plain.crop((0, 0, 240, 28)).tobytes(), left.crop((0, 0, 240, 28)).tobytes())+++class GaugeTests(unittest.TestCase):+ """The pictures read as gauges: Grok's fuel is what is left; Copilot's clouds fill as it is used."""++ def stage(self, provider, used, active=False, label='WEEK'):+ now = NOON+ data = snapshot(now, [(f'{provider}_a', 'A', provider, [(label, used, 3 * D)])])+ data['accounts'][f'{provider}_a']['active'] = active+ return arcade.arcade_frames(data, now)[0].convert('RGB').crop((0, 28, 240, 170))++ def count(self, image, colours):+ return sum(1 for p in image.getdata() if p in colours)++ def test_grok_fuel_drains_as_the_limit_is_used(self):+ fuel = {arcade.FUEL, arcade.FUEL_TOP}+ self.assertGreater(self.count(self.stage('grok', 20), fuel), self.count(self.stage('grok', 70), fuel))+ self.assertGreater(self.count(self.stage('grok', 95), {arcade.FUEL_LOW}), 0) # the last of it, red++ def test_copilot_counts_its_use_in_clouds(self):+ def clouds(used, active=False):+ sky = self.stage('copilot', used, active).crop((0, 0, 240, 56)) # the row of five, above the plane+ return self.count(sky, {arcade.CLOUD_TOP}), self.count(sky, {arcade.CLOUD_SPOT})+ (none, clear), (two, _), (all_, left) = clouds(5), clouds(45), clouds(100)+ self.assertLess(none, two)+ self.assertLess(two, all_)+ self.assertEqual(left, 0) # all five clouds out+ self.assertGreater(clear, 0) # the clear patches still show+ self.assertEqual(clouds(45, True)[0], two) # the same count at work++ def test_a_jog_meets_its_start_when_two_accounts_share_the_loop(self):+ data = snapshot(NOON, [('claude_a', 'A', 'claude', [('WEEK', 50, 3 * D)]), ('codex_a', 'B', 'codex', [('WEEK', 50, 3 * D)])])+ for row in data['accounts'].values():+ row['active'] = True+ frames = arcade.arcade_frames(data, NOON)+ def clawd_x(frame):+ xs = [x for y in range(100, 170, 2) for x in range(0, 240, 2) if frame.getpixel((x, y))[0] > 190+ and frame.getpixel((x, y))[1] < 140 and frame.getpixel((x, y))[2] < 120]+ return min(xs)+ spots = [clawd_x(frames[k]) for k in range(arcade.FRAMES // 2)] # Claude's half of the loop+ self.assertLessEqual(max(abs(a - b) for a, b in zip(spots, spots[1:])), 8)++ def test_the_stage_dims_late_at_night_and_the_numbers_do_not(self):+ night = time.mktime((2026, 10, 29, 2, 0, 0, 0, 0, -1))+ def frame(now):+ data = snapshot(now, [('codex_a', 'A', 'codex', [('WEEK', 40, 3 * D)])])+ return arcade.arcade_frames(data, now)[0].convert('L')+ day, dark = frame(NOON), frame(night)+ bright = lambda image, box: sum(image.crop(box).getdata())+ self.assertLess(bright(dark, (0, 28, 240, 170)), bright(day, (0, 28, 240, 170)) * .8)+ self.assertEqual(day.crop((0, 170, 240, 240)).tobytes(), dark.crop((0, 170, 240, 240)).tobytes())+++class FifthAccountTests(unittest.TestCase):+ def test_more_than_four_take_turns_round_by_round_of_the_rest_flow(self):+ rows = [(f'codex_{n}', f'CODEX {n.upper()}', 'codex', [('WEEK', 40 + i, 3 * D)]) for i, n in enumerate('abcdef')]+ data = snapshot(NOON, rows)+ for row in data['accounts'].values():+ row['active'] = True+ seen, rounds = set(), set()+ for minute in range(0, 12):+ turn = arcade.shown_rows(data, NOON - NOON % 360 + 60 * minute)+ self.assertEqual(len(turn), 4)+ seen.update(row['key'] for row in turn)+ rounds.add(tuple(row['key'] for row in turn))+ self.assertEqual(seen, set(data['accounts']))+ self.assertEqual(len(rounds), 2) # the same four for six minutes, then the next++ def test_a_restart_remembers_when_each_account_last_worked(self):+ from token_tv.state import news_of+ store = UsageStore([{'key': 'a', 'alias': 'A', 'provider': 'codex'}], fetch=lambda _: None)+ earlier = time.time() - 60+ store.restore({'accounts': {'a': {'rose_at': earlier, 'active_since': earlier - 3600}}})+ previous = dict(store.rows['a'], windows=[{'label': 'WEEK', 'used_percent': 10}], status='ok', fetched_at=earlier)+ row = {'status': 'ok', 'fetched_at': time.time(), 'windows': [{'label': 'WEEK', 'used_percent': 11}]}+ self.assertNotIn('first_today', {i['kind'] for i in news_of(previous, row)}) # it already worked today++ def test_a_one_off_plays_for_an_account_the_clock_does_not_cycle_through(self):+ rows = [(f'{p}_{n}', f'{p.upper()} {n}', p, [('WEEK', used, 3 * D)])+ for (p, n, used) in (('claude', 'a', 81), ('claude', 'b', 82), ('codex', 'a', 83), ('codex', 'b', 84),+ ('codex', 'c', 1))]+ data = snapshot(NOON, rows)+ usual = arcade.arcade_frames(data, NOON)+ played = arcade.arcade_frames(data, NOON, egg='reset@codex_c')+ self.assertNotEqual(usual[30].tobytes(), played[30].tobytes())+++class UnknownReadingTests(unittest.TestCase):+ def test_no_reading_draws_no_gauge_and_no_fret(self):+ for provider, label in (('grok', 'BUDGET'), ('copilot', 'MONTH'), ('antigravity', '5H'), ('codex', 'WEEK')):+ data = snapshot(NOON, [(f'{provider}_a', 'A', provider, [(label, 50, 3 * D)])])+ row = data['accounts'][f'{provider}_a']+ row['windows'], row['worry'] = [], True+ plan = arcade.scene_plan(row, NOON)+ self.assertNotEqual(plan['mood'], 'worried', provider)+ stage = arcade.arcade_frames(data, NOON)[0].convert('RGB').crop((0, 28, 240, 170))+ gauge_inks = {arcade.FUEL, arcade.FUEL_TOP, arcade.FUEL_LOW, arcade.CLOUD_SPOT, arcade.PLOT}+ self.assertFalse(gauge_inks & {p for p in stage.getdata()}, provider)++ def test_the_moon_is_dark_when_nothing_is_left_and_labels_spell_out(self):+ stage = Image.new('RGB', (40, 40))+ draw = arcade.ImageDraw.Draw(stage)+ arcade.moon_gauge(draw, 20, 20, 8, 0)+ self.assertNotIn(arcade.MOON_LIT, set(stage.getdata()))+ self.assertTrue(all(c in arcade.LABEL_GLYPHS for c in 'CHAT WINDOW DAY MO BUD 5H WK'.replace(' ', '')))+++class TierTests(unittest.TestCase):+ def test_each_tier_marks_the_header_and_a_legend_runs_a_rainbow(self):+ now = time.time()+ data = snapshot(now, [('codex_a', 'CODEX A', 'codex', [('WEEK', 50, 3 * D)])])+ stage = tuple(Image.new('RGB', (120, 71), (20, 20, 20)) for _ in range(3))+ corner = lambda image: image.crop((8, 6, 26, 24))+ plain = arcade.arcade_frames(data, now)[0]+ marks = {}+ for tier in ('unique', 'legend'):+ frames = arcade.arcade_frames(data, now, lockbox.Box('x', tier, 'codex_a', stage, 6))+ marks[tier] = corner(frames[5])+ self.assertNotEqual(corner(plain).tobytes(), marks[tier].tobytes(), tier)+ rare = arcade.arcade_frames(data, now, lockbox.Box('x', 'rare', 'codex_a', stage, 11))[5]+ self.assertNotEqual(corner(rare).tobytes(), marks['unique'].tobytes()) # blue, not purple+ everyday = arcade.arcade_frames(data, now, 'reset@codex_a')[5] # a reset is common: no mark+ self.assertEqual(corner(everyday).tobytes(), corner(plain).tobytes())+ border = lambda image: image.crop((0, 28, 4, 170))+ legend = arcade.arcade_frames(data, now, lockbox.Box('x', 'legend', 'codex_a', stage, 11))[5]+ unique = arcade.arcade_frames(data, now, lockbox.Box('x', 'unique', 'codex_a', stage, 6))[5]+ self.assertNotEqual(border(legend).tobytes(), border(unique).tobytes())+++if __name__ == '__main__':+ unittest.main()diff --git a/token_tv/__init__.py b/token_tv/__init__.pyindex b3928e0..6339498 100644--- a/token_tv/__init__.py+++ b/token_tv/__init__.py@@ -1,2 +1,2 @@"""TokenTV: AI usage limits on a tiny desk clock."""-__version__ = "0.2.0"+__version__ = "0.3.0"diff --git a/token_tv/arcade.py b/token_tv/arcade.pynew file mode 100644index 0000000..be50650--- /dev/null+++ b/token_tv/arcade.py@@ -0,0 +1,1772 @@+"""Arcade: the mascots act out whether their account is in use right now, and each picture is a gauge.++An account counts as working while its used % rose within the last ten minutes (`active` in+state.py). Working, Clawd jogs to and fro, the Codex cloud rains digits and code symbols on its garden,+Grok fuels its rocket or works the console, Copilot flies across under its clouds and Anti patrols its+maze; at rest they breathe, look round now and then and stretch, a minute at a time. Each picture also+reads one limit: Claude's moon, the garden, the fuel tank, the clouds, the power pellets.++Clawd's poses are the sprites of Clawd's Quest (claude.dev/game), kept in assets/clawd.json in+the game's own encoding; the others are the bundled pixel mascots. Arcade shows one account at+a time: one character on the screen reads best on the clock. It is a GIF loop of 120 even frames that+depends only on the readings, the working flags, a coarse reset time and the minute of rest,+so equal inputs give identical bytes and the clock is not rewritten.+"""+import base64+import functools+import hashlib+import io+import json+import math+import random+import time++from PIL import Image, ImageDraw, ImageEnhance++from token_tv import gif+from token_tv.readout import draw_readout+from token_tv.display import (ASSETS, MAX_ROWS, PROVIDERS, SHORT_NAME, account_label, fit_pixel, overview_rows, pixel_text, quota_period,+ reading, shown_windows)+from token_tv.space import sprite as mascot_sprite+from token_tv.themes import bot_sprite++SIZE = 240+FPS = 12 # Clawd's own frame rate+PACE = 1.5 # Clawd's idle moves play half again as fast as in the game+SPEED = 2 # every scene runs at twice its drawn pace; a loop plays twice in the 10 s, a one-off in 5 s+FRAMES = 10 * FPS+FRAME_MS = 70 # each frame on the clock: 120 of them make an 8.4 s loop, a fifth brisker than the drawn 10 s+LOOP_SECONDS = FRAMES * FRAME_MS / 1000+TEXT = (226, 230, 238)+MUTED = (128, 138, 160)+WARN = (255, 96, 110)+TRACK = (40, 46, 62)+PANEL, DIVIDER = (11, 13, 19), (30, 34, 46)+BUDGET = 380_000 # bytes; the clock takes GIFs up to 400 kB+BANDS = ((76, 201, 140), (140, 214, 92), (255, 160, 64), (255, 84, 96)) # below 50, 50–79, 80–89, 90++# Clawd's Quest night palette: near-black ground with grey dots.+LAND, DOT, DOT_DIM, DOT_BRIGHT = (23, 23, 23), (122, 122, 122), (66, 66, 66), (170, 170, 170)+SKY = {'grok': (6, 9, 22), 'codex': (18, 20, 52)}+STARS = ((52, 60, 92), (112, 122, 166), (228, 234, 255))+DECK, DECK_EDGE, LEG = (54, 58, 70), (112, 118, 134), (150, 158, 176)++# The game's idle flourishes and emotes: (sprite, first frame, last frame), all played at 12 fps.+IDLE_MOVES = {'look': ('LookingAround', 4, 30), 'sway': ('Swaying', 4, 48), 'turn': ('Turning', 2, 26),+ 'dance': ('DancingHappy', 4, 38), 'meditate': ('Meditating', 2, 59), 'break': ('BreakDancing', 2, 27),+ 'wave': ('Waving', 3, 16), 'think': ('Thinking', 2, 36)}+RUN = ('Running', 5, 16) # the game's run loop+JUMP_RISE, JUMP_TOP, JUMP_FALL, JUMP_LAND = (5, 6), 7, (10, 11), (13, 14) # Jumping frames by vertical speed++# Rain glyphs, 3×5: zeros and ones with a few code symbols, in one blue at falling brightness.+RAIN_GLYPHS = {+ '0': '111/101/101/101/111', '1': '010/110/010/010/111', '{': '011/010/110/010/011', '}': '110/010/011/010/110',+ '<': '001/010/100/010/001', '>': '100/010/001/010/100', ';': '000/010/000/010/100', '/': '001/001/010/100/100',+ '=': '000/111/000/111/000', '+': '000/010/111/010/000', '*': '101/010/111/010/101', '#': '101/111/101/111/101',+ '(': '010/100/100/100/010', ')': '010/001/001/001/010', '[': '110/100/100/100/110', ']': '011/001/001/001/011',+}+RAIN_CHARS = '01' * 7 + '{}<>;/=+*#()[]'+# Small capitals for the limit a gauge picture follows (5H, WK, MO, BUD, DAY), in the same 3 x 5 cells.+LABEL_GLYPHS = {'5': '111/100/111/001/110', 'H': '101/101/111/101/101', 'W': '101/101/101/111/101',+ 'K': '101/101/110/101/101', 'M': '101/111/101/101/101', 'O': '111/101/101/101/111',+ 'B': '110/101/110/101/110', 'U': '101/101/101/101/111', 'D': '110/101/101/101/110',+ 'A': '010/101/111/101/101', 'Y': '101/101/010/010/010', 'C': '111/100/100/100/111',+ 'T': '111/010/010/010/010', 'I': '111/010/010/010/111', 'N': '101/111/111/111/101',+ 'R': '110/101/110/101/101', 'E': '111/100/110/100/111', 'S': '111/100/111/001/111',+ 'L': '100/100/100/100/111', 'G': '111/100/101/101/111', 'P': '110/101/110/100/100',+ 'X': '101/101/010/101/101', '0': '111/101/101/101/111', '1': '010/110/010/010/111',+ '2': '111/001/111/100/111', '3': '111/001/111/001/111', '4': '101/101/111/001/001',+ '6': '111/100/111/101/111', '7': '111/001/001/001/001', '8': '111/101/111/101/111',+ '9': '111/101/111/001/111'}+LABEL_INK = (104, 112, 140)+++def gauge_label(draw, x, y, text, align='left'):+ """The limit a gauge picture follows, small and dim, at (x, y) on the stage."""+ text = ''.join(c for c in text if c in LABEL_GLYPHS)+ x -= {'left': 0, 'centre': (4 * len(text) - 1) // 2, 'right': 4 * len(text) - 1}[align]+ for n, char in enumerate(text):+ for yy, line in enumerate(LABEL_GLYPHS[char].split('/')):+ for xx, bit in enumerate(line):+ if bit == '1':+ draw.point((x + 4 * n + xx, y + yy), fill=LABEL_INK)+RAIN_BLUE = (150, 166, 255)+RAIN_SHADES = tuple(tuple(min(255, round(c * k)) for c in RAIN_BLUE) for k in (1.45, 1.15, .9, .65))+++def coarse_left(reset, now=None):+ """Time to reset in its largest unit (3D, 5H, 38M); the minute only shows in the last hour."""+ if not reset:+ return '--'+ minutes = max(0, int((reset - (time.time() if now is None else now) + 59) // 60))+ return f'{minutes // 1440}D' if minutes >= 1440 else f'{minutes // 60}H' if minutes >= 60 else f'{minutes}M'+++def loop_offset(f, length, cycles):+ """Position along a strip of `length` that wraps `cycles` times per loop, so frame 100 meets frame 0."""+ return (f * length * cycles / FRAMES) % length+++def paste(frame, art, x, y):+ frame.paste(art, (round(x), round(y)), art)+++def band_color(used):+ return BANDS[0 if used < 50 else 1 if used < 80 else 2 if used < 90 else 3]+++def gauge(draw, x, y, width, height, used, old=False):+ """Ten cells across `width`; an old reading keeps its level in a muted colour."""+ step = width / 10+ for cell in range(10):+ left, right = round(x + cell * step), round(x + (cell + 1) * step) - 2+ draw.rectangle((left, y, right, y + height - 1), fill=TRACK)+ if used is not None and used > cell * 10:+ fill = min(1, used / 10 - cell)+ draw.rectangle((left, y, left + max(1, round((right - left + 1) * fill)) - 1, y + height - 1),+ fill=MUTED if old else band_color(used))+++# --- Clawd -----------------------------------------------------------------------------------+[email protected]_cache(maxsize=1)+def clawd_data():+ """Clawd's animations; the hidden scenes' own few, where this copy has them, from clawd-eggs.json."""+ data = json.loads((ASSETS / 'clawd.json').read_text())+ extra = ASSETS / 'clawd-eggs.json'+ if extra.exists():+ data.update(json.loads(extra.read_text()))+ return data++[email protected]_cache(maxsize=None)+def clawd_frames(name):+ """All frames of one animation, decoded as the game does: a base grid plus per-frame changes."""+ sheet = clawd_data()[name]+ current = [255 if c == '.' else int(c, 36) for c in sheet['base']]+ frames = [current[:]]+ for delta in sheet['deltas']:+ for change in filter(None, delta.split(',')):+ current[int(change[:-1], 36)] = 255 if change[-1] == '.' else int(change[-1], 36)+ frames.append(current[:])+ return frames++[email protected]_cache(maxsize=None)+def clawd(name, index, scale):+ sheet = clawd_data()[name]+ palette = [tuple(int(c[i:i + 2], 16) for i in (1, 3, 5)) + (255,) for c in sheet['palette']]+ art = Image.new('RGBA', (sheet['w'], sheet['h']))+ art.putdata([(0, 0, 0, 0) if v == 255 else palette[v] for v in clawd_frames(name)[index]])+ return art.resize((art.width * scale, art.height * scale), Image.Resampling.NEAREST)+++def place_clawd(frame, name, index, scale, foot_x, foot_y, flip=False):+ """Stand the frame on (foot_x, foot_y): the game anchors every pose at the bottom centre of its body box.+ `flip` faces it left."""+ x, y, w, h = clawd_data()[name]['a0']+ art = clawd(name, index, scale)+ if flip:+ art = art.transpose(Image.Transpose.FLIP_LEFT_RIGHT)+ x = art.width / scale - x - w+ paste(frame, art, foot_x - (x + w / 2) * scale, foot_y - (y + h) * scale)++[email protected]_cache(maxsize=None)+def clawd_spun(name, index, scale, degrees):+ return rotsprite(clawd(name, index, scale), degrees)+++def place_clawd_spun(frame, name, index, scale, foot_x, foot_y, degrees):+ """Clawd turned by `degrees` round the middle of its body box, which stays where it would stand."""+ x, y, w, h = clawd_data()[name]['a0']+ art = clawd(name, index, scale)+ spun = clawd_spun(name, index, scale, degrees)+ cx = foot_x - (x + w / 2) * scale + art.width / 2 # where the unturned art's centre would be+ cy = foot_y - (y + h) * scale + art.height / 2+ paste(frame, spun, cx - spun.width / 2, cy - spun.height / 2)+++# Rest is one flow, a minute at a time: look round, keep still a while, stretch, keep still, and now and then a+# rarer move in place of a still minute. Between, the pets only breathe.+REST_FLOW = ('look', None, None, 'stretch', None, None)+REST_MOVES = {'look': ('look',), 'stretch': ('sway', 'turn'), 'rare': ('dance', 'break', 'meditate', 'wave', 'think')}+FLOW_MOVES = {'codex': {'look': 'drift', 'stretch': 'yawn', 'rare': 'drift'},+ 'grok': {'look': 'gaze', 'stretch': 'wander', 'rare': 'wander'},+ 'copilot': {'look': 'look', 'stretch': 'hop', 'rare': 'hop'},+ 'antigravity': {'look': 'look', 'stretch': 'bob', 'rare': 'look'}}+++def rest_step(provider, now):+ """What a resting pet does this minute ('look', 'stretch', 'rare' or None to keep still), and a random source+ fixed for the minute."""+ minute = int((time.time() if now is None else now) // 60)+ step = REST_FLOW[minute % len(REST_FLOW)]+ rnd = random.Random(f'{provider}|{minute // len(REST_FLOW)}')+ if minute % len(REST_FLOW) == 4 and rnd.random() < .2:+ step = 'rare'+ return step, random.Random(f'{provider}|{minute}')+++def idle_plan(row, now, span=FRAMES / FPS):+ """Clawd's move for this minute of rest, if any (REST_FLOW), early in the turn."""+ step, rnd = rest_step(row['provider'], now)+ if not step:+ return []+ name, first, last = IDLE_MOVES[rnd.choice(REST_MOVES[step])]+ t = .4+ return [(t, min(span - .2, t + (last - first + 1) / (12 * PACE)), name, first, last)]++[email protected]_cache(maxsize=None)+def land_layers(depth, period, pits, pit_w, ridge_h):+ """Dotted ground (with pits) and far hills, each drawn twice over one period so any crop wraps."""+ rnd = random.Random(period * 31 + depth)+ ground = Image.new('RGBA', (period * 2, depth))+ gd = ImageDraw.Draw(ground)+ for u in range(0, period, 2):+ if any(abs(u - p) < pit_w / 2 for p in pits):+ continue+ for v in range(0, depth, 2):+ k = rnd.random()+ color = DOT_BRIGHT if k < .05 else DOT if v == 0 or k < .7 else DOT_DIM+ for dx in (0, period):+ gd.point((u + dx, v), fill=color)+ hills = Image.new('RGBA', (480, ridge_h))+ hd = ImageDraw.Draw(hills)+ for u in range(0, 240, 2):+ ridge = ridge_h * (.55 + .3 * math.sin(2 * math.pi * u / 240 * 2 + 1) + .15 * math.sin(2 * math.pi * u / 240 * 5))+ top = ridge_h - round(ridge)+ for v in range(top - top % 2, ridge_h, 2):+ inside = (v - top) / max(1, ridge_h - top)+ if rnd.random() < (.85 if v - top < 3 else .35 * (1 - inside) + .05):+ for dx in (0, 240):+ hd.point((u + dx, v), fill=DOT if v - top < 3 else DOT_DIM)+ return ground, hills+++def claude_backdrop(frame, draw, box, f, s, active, pit=True):+ """Clawd's Quest at night: stars, the dotted moon and hills, and dotted ground scrolling while Clawd runs."""+ x, y, w, h = box+ draw.rectangle((x, y, x + w - 1, y + h - 1), fill=LAND)+ ground_y = y + h - max(10, h // 6)+ rnd = random.Random(w * 7 + h)+ for _ in range(w * h // 900): # a few stars+ draw.point((x + rnd.randrange(w), y + rnd.randrange(max(1, ground_y - y - 30))), fill=DOT_DIM)+ if w >= 200: # the game's dotted crescent moon, where there is room for it+ cx, cy, r = x + w - 34, y + 22, 11+ for yy in range(cy - r, cy + r + 1, 2):+ for xx in range(cx - r, cx + r + 1, 2):+ if (xx - cx) ** 2 + (yy - cy) ** 2 <= r * r and (xx - cx - 5) ** 2 + (yy - cy + 3) ** 2 > (r - 2) ** 2:+ draw.point((xx, yy), fill=DOT)+ period = 80 * max(3, round(w * 1.3 / 80)) # one pit per strip, two strips a loop+ pits, pit_w = (period * .6,) if pit else (), 9 * s+ ground, hills = land_layers(y + h - ground_y, period, pits, pit_w, max(12, h // 4))+ shift = loop_offset(f, period, 3) if active else 0+ far = loop_offset(f, 240, 2) if active else 0+ crop = hills.crop((round(far), 0, round(far) + w, hills.height))+ frame.paste(crop, (x, ground_y - hills.height), crop)+ crop = ground.crop((round(shift), 0, round(shift) + w, ground.height))+ frame.paste(crop, (x, ground_y), crop)+ return ground_y, period, pits, pit_w, shift+++MOON_LIT, MOON_DARK = (238, 228, 190), (58, 58, 68)+++def moon_gauge(draw, cx, cy, r, left):+ """Claude's moon is its 5-hour window: full while there is plenty left, waning through half to a thin+ crescent as it is used, and only a dark ring once it is gone; a reset brings the full moon back."""+ for yy in range(-r, r + 1):+ half = math.sqrt(max(0, r * r - yy * yy))+ terminator = (2 * left - 1) * half # lit to the left of it+ for xx in range(-r, r + 1):+ if xx * xx + yy * yy <= r * r:+ lit = left > 0 and xx <= terminator # nothing left: only the dark ring+ edge = xx * xx + yy * yy > (r - 1) * (r - 1)+ if lit or edge:+ draw.point((cx + xx, cy + yy), fill=MOON_LIT if lit else MOON_DARK)+++def claude_scene(frame, draw, box, f, span, active, s, plan):+ x, y, w, h = box+ ground_y, period, pits, pit_w, shift = claude_backdrop(frame, draw, box, f, s, False) # the world stands still+ if isinstance(plan, dict) and plan.get('moon') is not None:+ moon_gauge(draw, x + w - 12 * s, y + 11 * s, 8 * s, plan['moon'])+ if s == 1:+ gauge_label(draw, x + w - 12, y + 21, '5H', 'centre')+ foot_x, foot_y = x + round(w * .3), ground_y+ if not active and isinstance(plan, dict) and plan.get('mood') == 'worried':+ t = f % 40 # nearly out: pacing to and fro, looking round at each end+ back = t >= 20+ at = foot_x + min(14, t if not back else max(0, 34 - t)) * 2 * s+ if t < 14 or 20 <= t < 34:+ name, first, last = RUN+ place_clawd(frame, name, first + t % (last - first + 1), s, at, foot_y, flip=back)+ else:+ name, first, _ = IDLE_MOVES['look']+ place_clawd(frame, name, first + (t % 20 - 14) * 3, s, at, foot_y, flip=back)+ mood_marks(draw, at + 10 * s, foot_y - 22 * s, s, f, 'worried')+ return+ if not active:+ t = f / FPS+ moves = plan.get('moves', []) if isinstance(plan, dict) else plan+ for start, end, name, first, last in moves:+ if start <= t < end:+ index = min(last, first + int((t - start) * 12 * PACE))+ if name == 'BreakDancing': # a full spin through the move, so it reads as breaking at a glance+ turn = round((index - first) / (last - first + 1) * 8) % 8 * 45+ place_clawd_spun(frame, name, index, s, foot_x, foot_y - 3 * s, turn)+ else:+ place_clawd(frame, name, index, s, foot_x, foot_y)+ break+ else: # keeping still: a slow breath, one every two and a half seconds+ breath = s if (f / (FPS * SPEED)) % 2.5 < 1 else 0+ place_clawd(frame, 'LookingAround', 0, s, foot_x, foot_y - breath)+ if isinstance(plan, dict):+ mood_marks(draw, foot_x + 10 * s, foot_y - 22 * s, s, f, plan.get('mood'))+ return+ # At work Clawd jogs to and fro along the ground, a stride a second; nearly out, twice as fast and sweating.+ worried = isinstance(plan, dict) and plan.get('mood') == 'worried'+ pace = 2 if worried else 1+ t = (f / span * pace) % 1 # a lap a loop of the scene, so it meets its start however short the turn+ back = t >= .5+ reach = .54 * min(1, span / FRAMES) # a shorter turn, a shorter lap: the same easy pace+ at = x + round(w * (.18 + reach * (2 * t if not back else 2 - 2 * t)))+ name, first, last = RUN+ cycle = last - first + 1+ strides = max(1, round(span / (FPS * SPEED))) * pace # about a stride a second+ place_clawd(frame, name, first + int(f / span * strides * cycle) % cycle, s, at, foot_y, flip=back)+ if worried:+ mood_marks(draw, at + 10 * s, foot_y - 22 * s, s, f, 'worried')+++# --- Codex -----------------------------------------------------------------------------------+# The bundled cloud keeps its '>_' face; each frame sets the eye, the mouth and a squash by hand.++CODEX_INK = (34, 40, 120, 255) # the cloud's '>_', deep indigo on its light body+++def is_light(p):+ """A pixel of the '>_' strokes, as opposed to the cloud around them."""+ return p[3] and max(p[:3]) < 140++[email protected]_cache(maxsize=None)[email protected]_cache(maxsize=None)+def codex_cloud(width=28, height=26):+ """The Codex mascot a little smaller than the shared one (it looked big next to the others), same shape:+ the outline resampled to the new size, each pixel the cloud tone of its row, the '>_' moved over stroke+ for stroke."""+ art = mascot_sprite('codex')+ w, h = art.size+ mask = art.getchannel('A').resize((w * 8, h * 8), Image.Resampling.NEAREST).resize((width, height),+ Image.Resampling.BOX)+ out = Image.new('RGBA', (width, height))+ for y in range(height):+ sy = min(h - 1, int((y + .5) * h / height))+ tones = [(x, art.getpixel((x, sy))) for x in range(w)]+ tones = [(x, p) for x, p in tones if p[3] and not is_light(p)]+ for x in range(width):+ if mask.getpixel((x, y)) >= 128 and tones:+ sx = (x + .5) * w / width+ out.putpixel((x, y), min(tones, key=lambda t: abs(t[0] - sx))[1])+ face = [(x, y) for y in range(h) for x in range(w) if is_light(art.getpixel((x, y)))]+ fx, fy = sum(x for x, _ in face) / len(face), sum(y for _, y in face) / len(face)+ for x, y in face:+ out.putpixel((round(fx * width / w + x - fx), round(fy * height / h + y - fy)), art.getpixel((x, y)))+ return out+++def codex_pose(eye='open', mouth='long', squash=0):+ """The Codex cloud at one pixel per pixel. `squash` > 0 is wider and shorter, < 0 narrower and taller."""+ art = codex_cloud().copy()+ px = art.load()+ w, h = art.size+ light = [(x, y) for y in range(h) for x in range(w) if is_light(px[x, y])]+ eye_px = [(x, y) for x, y in light if x < w // 2 - 1]+ mouth_px = [(x, y) for x, y in light if x >= w // 2 - 1]+ erase = (eye_px if eye != 'open' else []) + (mouth_px if mouth != 'long' else [])+ for x, y in erase: # paint over with the nearest cloud colour on the row+ for dx in (1, -1, 2, -2, 3, -3, 4, -4, 5, -5):+ if 0 <= x + dx < w and px[x + dx, y][3] and not is_light(px[x + dx, y]):+ px[x, y] = px[x + dx, y]+ break+ white = CODEX_INK # the face's own ink+ if eye == 'closed' and eye_px: # a sleepy dash where the '>' was+ ey = round(sum(y for _, y in eye_px) / len(eye_px))+ left = min(x for x, _ in eye_px)+ for x in range(left, left + 5):+ px[x, ey] = white+ if mouth == 'short' and mouth_px: # the '_' hums: shorter by a pixel at each end+ xs = sorted(x for x, _ in mouth_px)+ for x, y in mouth_px:+ if xs[0] < x < xs[-1]:+ px[x, y] = white+ if eye == 'happy' and eye_px: # '^', the eye of a grin+ ex = round(sum(x for x, _ in eye_px) / len(eye_px))+ ey = round(sum(y for _, y in eye_px) / len(eye_px)) - 2+ for i in range(4):+ for x in (ex - i, ex - i + 1, ex + i, ex + i + 1):+ px[x, ey + i] = white+ if mouth == 'smile' and mouth_px: # the '_' bends into a wide open grin+ left, right = min(x for x, _ in mouth_px), max(x for x, _ in mouth_px)+ top = min(y for _, y in mouth_px) - 1+ for i, inset in enumerate((0, 0, 1, 2)):+ for x in range(left + inset, right - inset + 1):+ px[x, top + i] = white+ if mouth == 'open' and mouth_px: # a little 'o', gasping+ mx = round(sum(x for x, _ in mouth_px) / len(mouth_px))+ my = round(sum(y for _, y in mouth_px) / len(mouth_px))+ for dx, dy in ((-1, -1), (0, -1), (1, -1), (-1, 0), (1, 0), (-1, 1), (0, 1), (1, 1)):+ px[mx + dx, my + dy] = white+ if squash:+ art = art.resize((w + 2 * squash, h - 2 * squash), Image.Resampling.NEAREST)+ return art++[email protected]_cache(maxsize=None)+def codex_art(scale, eye='open', mouth='long', squash=0):+ art = codex_pose(eye, mouth, squash)+ return art.resize((art.width * scale, art.height * scale), Image.Resampling.NEAREST)+++def rain_glyph(draw, char, x, y, scale, color):+ x, y = round(x), round(y)+ for yy, line in enumerate(RAIN_GLYPHS[char].split('/')):+ for xx, bit in enumerate(line):+ if bit == '1':+ draw.rectangle((x + xx * scale, y + yy * scale, x + xx * scale + scale - 1, y + yy * scale + scale - 1),+ fill=color)+++def shade(k):+ return tuple(min(255, round(c * k)) for c in RAIN_BLUE)+++# One wring every 40 frames: press (wider), release (taller), wobble back; the rain bursts on release.+WRING = (0, 1, 1, 2, 2, 2, -1, -2, -1, 0, 1, 0)+++def splash(draw, x, ground, age, s, color):+ """Two droplets hop off and a ripple widens on the puddle, for four frames after a hit."""+ if not 0 <= age < 4:+ return+ rise = (0, 2, 2, 1)[age] * s+ spread = (1, 2, 3, 4)[age] * s+ for side in (-1, 1):+ draw.rectangle((x + side * spread, ground - rise - s, x + side * spread + s - 1, ground - rise - 1), fill=color)+ draw.line((x - spread - s, ground + s, x + spread + s, ground + s), fill=shade(.5))+++# Code rain grows bracket flowers: a '|' stem, '<' '>' leaves, a '( )' bud that opens to '{*}'.+# The garden keeps one flower per 20% used; while Codex works, the cloud waters the next one.+SOIL, SOIL_TOP, SOIL_DOT = (31, 27, 58), (58, 52, 96), (44, 40, 78)+PLOT = (86, 78, 138) # a dug spot waiting for its flower+STEM, LEAF, BUD, PETAL, HEART = (96, 214, 168), (70, 176, 140), (150, 142, 240), (204, 198, 255), (255, 226, 140)+SWEAT_INK = (140, 200, 255)+++def sweat_drop(draw, x, y, s):+ """A small cartoon sweat drop, pointed at the top."""+ d = max(1, s)+ draw.rectangle((x, y + d, x + 2 * d - 1, y + 3 * d - 1), fill=SWEAT_INK)+ draw.rectangle((x + d // 2, y, x + d // 2 + max(1, d // 2 + (d > 1)) - 1, y + d - 1), fill=SWEAT_INK)+ draw.point((x, y + d), fill=(220, 240, 255))+++def garden_backdrop(draw, box, f, s):+ """Banded dusk over a strip of garden soil; returns the soil's top."""+ x, y, w, h = box+ for k in range(4):+ tone = tuple(min(255, c + k * 5) for c in SKY['codex'])+ draw.rectangle((x, y + k * h // 4, x + w - 1, y + (k + 1) * h // 4 - 1), fill=tone)+ ground = y + h - 4 * s+ draw.rectangle((x, ground, x + w - 1, y + h - 1), fill=SOIL)+ draw.line((x, ground, x + w - 1, ground), fill=SOIL_TOP)+ for i in range(3, w, 7 * s):+ draw.point((x + i, ground + 2 * s + (i // 7) % 2 * s), fill=SOIL_DOT)+ return ground+++def flower(draw, cx, ground, g, stage, lean=0):+ """One bracket flower at `stage` 0..1: seed, stem, leaves, bud, bloom. `g` is the glyph pixel size."""+ if stage <= 0:+ return+ if stage < .15: # a seed in the soil+ draw.rectangle((cx - g, ground - g, cx, ground - 1), fill=BUD)+ return+ stem_h = 9 * g+ grown = round(stem_h * min(1, (stage - .15) / .35))+ top = ground - grown+ if grown > 0:+ draw.rectangle((cx - g // 2, top, cx - g // 2 + g - 1, ground - 1), fill=STEM)+ if stage >= .5:+ rain_glyph(draw, '<', cx - 4 * g, ground - 6 * g, g, LEAF)+ if stage >= .58:+ rain_glyph(draw, '>', cx + g, ground - 7 * g, g, LEAF)+ head = top - 5 * g+ if .65 <= stage < .82:+ rain_glyph(draw, '(', cx - 3 * g + lean, head, g, BUD)+ rain_glyph(draw, ')', cx + lean, head, g, BUD)+ elif stage >= .82:+ rain_glyph(draw, '{', cx - 5 * g + lean, head, g, PETAL)+ rain_glyph(draw, '*', cx - g - g // 2 + lean, head, g, HEART)+ rain_glyph(draw, '}', cx + 2 * g + lean, head, g, PETAL)+++def codex_scene(frame, draw, box, f, span, active, s, plan, centre=.5):+ x, y, w, h = box+ ground = garden_backdrop(draw, box, f, s)+ used = plan.get('used') if isinstance(plan, dict) else None+ spots = 5 # one flower per 20%, on every stage size+ xs = [x + round(w * (i + .5) / spots) for i in range(spots)]+ bloomed = 0 if used is None else min(spots, int(used * spots // 100)) # one flower per 20% (25% on 4 spots)+ fg = s + 1 if s >= 2 else s # flowers a size up on the big stage+ growing = bloomed if used is not None and bloomed < spots else None+ if s == 1 and isinstance(plan, dict) and plan.get('label'):+ gauge_label(draw, x + 1, y + 1, plan['label'])+ for i, fx in enumerate(xs):+ if used is None:+ break # no reading: no garden to read+ if i < bloomed:+ lean = s * (1 if (f // 30 + i) % 2 else 0)+ flower(draw, fx, ground, fg, 1, lean)+ else: # an empty spot, still to come (the growing one's sprout stands in it)+ draw.rectangle((fx - 2 * s, ground - s, fx + s - 1, ground - 1), fill=PLOT)+ base = codex_art(s)+ cw, ch = base.size+ cx = xs[growing] if active and growing is not None else x + round(w * centre)+ cx = min(max(cx, x + cw // 2 + 2), x + w - cw // 2 - 2)+ mid = y + max(2, round(h * .05)) + ch // 2+ hurry = isinstance(plan, dict) and plan.get('mood') == 'worried' # nearly out: rains harder, sweats more+ if active:+ phase = f % (12 if hurry else 24)+ squash = WRING[phase] if phase < len(WRING) else 0+ eye = 'closed' if f % 60 in (30, 31) else 'open'+ mouth = 'short' if f // 4 % 2 else 'long'+ mid += round(math.sin(2 * math.pi * f * 3 / FRAMES) * s)+ shiver = s * (1 if f % 2 else -1) if 1 <= phase <= 5 else 0+ else:+ idle = idle_now(plan, f, span)+ squash = 1 if 26 <= f % 60 <= 33 else 0 # breathing+ eye, mouth, shiver = 'closed', 'long', 0+ mid += round(math.sin(2 * math.pi * f / FRAMES) * 2 * s)+ if idle == 'drift': # awake, floating two steps one way, two the other, blinking now and then+ eye = 'closed' if f % 30 in (12, 13) else 'open'+ cx += round(math.sin(2 * math.pi * f / 60) * 8 * s)+ elif idle == 'yawn': # a slow stretch and a big yawn+ t = f % 60+ eye = 'closed' if 20 <= t < 36 else 'open'+ mouth = 'open' if 22 <= t < 34 else 'long'+ squash = -1 if 22 <= t < 34 else squash+ elif idle == 'fret': # worn out: sunk low, heaving, gasping through an 'o' and puffing+ beat = f % 16+ mouth = 'open' if beat < 6 else 'long'+ squash = (1, 2, 2, 1, 0, -1)[beat] if beat < 6 else 0+ mid += 5 * s+ cx = min(max(cx, x + cw // 2 + 2), x + w - cw // 2 - 2)+ cloud = codex_art(s, eye, mouth, squash)+ if growing is not None:+ # only as far as the reading has come through this fifth (a sprout at 41%, a bud at 58%); it blooms on+ # the next fifth, so a bloom always means a full 20%+ done = (used % 20) / 20 if used is not None else 0+ stage = .15 + .66 * done+ flower(draw, xs[growing], ground, fg, stage)+ if active and done >= .8 and f % 24 < 8: # nearly there: the bud glints+ for k in range(4):+ a = math.radians(45 + k * 90 + f * 12)+ draw.point((xs[growing] + round(math.cos(a) * 7 * fg), ground - 12 * fg + round(math.sin(a) * 4 * fg)),+ fill=(255, 255, 255))+ top_rain = mid + ch // 2 - 4 * s+ fall = ground - top_rain+ if active: # code rain from the cloud onto the garden+ g = s+ for col, gx in enumerate(range(cx - cw // 2 + 2 * s, cx + cw // 2 - 3 * g, 8 * s)):+ c = (9, 10, 12)[col % 3] + (5 if hurry else 0)+ travel = f * c / FRAMES + (col * .61) % 1+ depth = (travel % 1) * (fall + 12 * g)+ pick = (col * 5 + int(travel) % c * 7) % len(RAIN_CHARS)+ for t, tone in enumerate((1.55, 1.05, .6)):+ gy = top_rain + depth - t * 6 * g+ if top_rain - 2 * g <= gy < ground - 5 * g:+ rain_glyph(draw, RAIN_CHARS[(pick + t * 5) % len(RAIN_CHARS)], gx, gy, g, shade(tone))+ hit = (fall + 7 * g) / (fall + 12 * g)+ if travel % 1 >= hit:+ age = int(((travel % 1) - hit) * FRAMES / c)+ splash(draw, gx + g, ground, age, s, shade(1.2))+ elif idle == 'nap':+ t = f % 40 # sleepy z's drift up from the cloud's shoulder+ if t < 30:+ pixel_text(draw, (round(cx + cw // 2 - 2 * s + t * s / 4), round(max(y + 2, mid - ch // 4 - t * s / 2))), 'z',+ scale=2 if s > 1 and t >= 12 else 1, color=shade(1.3 if t < 22 else .8))+ if not active and idle == 'fret' and f % 16 < 5: # each gasp puffs out a little breath+ t = f % 16+ puff(draw, round(cx + cw * .5 + t * 3 * s), round(mid + ch * .1 - t * s), max(1, round((5 - t) * s * .7)))+ paste(frame, cloud, cx - cloud.width / 2 + shiver, mid - cloud.height / 2)+ if not active and isinstance(plan, dict):+ mood_marks(draw, round(cx + cw * .3), round(mid - ch * .55), s, f, plan.get('mood'), idle == 'nap')+ if active: # straining to rain: sweat drops pop off the top of its head+ drops = 10 if hurry else 20+ for k, side in enumerate((-1, 1, -1)):+ t = (f + k * 7) % drops+ if t < min(11, drops - 1):+ p = t / min(10, drops - 2)+ dx = side * (cw * .25 + p * 7 * s)+ dy = -ch * .45 - 4 * p * (1 - p) * 8 * s + p * p * 4 * s+ sweat_drop(draw, round(cx + dx), round(mid + dy), s)+++# --- Grok ------------------------------------------------------------------------------------+# Grok's world is a Falcon Heavy on its pad on the Moon, with the Earth in the sky. The rocket keeps the real+# one's slim proportions, drawn as simply as a pictogram: white cores, a pointed fairing, one black band,+# swept fins; its pieces can fly apart and land on their own pads.++LUNAR, CRATER, LUNAR_LIGHT = (70, 75, 90), (52, 56, 68), (98, 104, 122)+FALCON_INK = {'white': (238, 241, 247), 'shade': (196, 203, 218), 'black': (30, 34, 46), 'line': (14, 17, 26),+ 'lit': (255, 226, 140)}+FIRE = ((255, 250, 214), (255, 206, 84), (250, 128, 48), (214, 68, 46))+PUFF = ((244, 246, 250), (204, 209, 220), (150, 156, 172))+GROK_WHITE = (242, 244, 248, 255)+DIZZY = ('.###.', '#...#', '#.#.#', '#..##', '.##..')+# The far, tiny Falcon of the loop-the-loop, too small for parts: W white, K black, G the window.+TINY_FALCON = ('..W..', '..W..', '.WWW.', '.WGW.', '.WWW.', '.WWW.', 'W.W.W', 'WWWWW', 'WWWWW', 'WWWWW',+ 'WWWWW', 'WWWWW', 'W.W.W')+++def falcon_size(height):+ """(core half-width, distance between core centres) for a Falcon Heavy `height` px tall."""+ half = max(1, round(height * .05))+ return half, 2 * half + 2 # a dark one-pixel gap keeps the cores apart+++def falcon_window(height):+ """(drop from the art's top, radius) of the fairing's little window, lit while Grok is aboard."""+ return 3 + max(3, round(height * .16)), 1+++def outlined(art, ink):+ """`art` with a one-pixel `ink` outline all round."""+ px = art.load()+ mask = [[px[xx, yy][3] > 0 for xx in range(art.width)] for yy in range(art.height)]+ for yy in range(art.height):+ for xx in range(art.width):+ if not mask[yy][xx] and any(0 <= xx + dx < art.width and 0 <= yy + dy < art.height and mask[yy + dy][xx + dx]+ for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1))):+ px[xx, yy] = ink+ return art+++def falcon_core(d, ink, x, top, bottom, half, nose, fairing=0):+ """One white core with a pointed nose, its right side in shade; the top `fairing` rows a pixel wider."""+ wide = half + (1 if fairing else 0)+ rows = [(top + i, round(wide * (1 - (1 - i / (nose - 1)) ** 2))) for i in range(nose)]+ rows += [(yy, wide) for yy in range(top + nose, top + max(nose, fairing))]+ rows += [(yy, half) for yy in range(top + max(nose, fairing), bottom + 1)]+ for yy, hw in rows:+ d.line((x - hw, yy, x + hw, yy), fill=ink['white'])+ if hw >= 2:+ d.line((x + (hw + 1) // 2, yy, x + hw, yy), fill=ink['shade'])++[email protected]_cache(maxsize=None)+def rocket_art(height, glass='empty', squash=0, parts=('left', 'centre', 'right')):+ """A slim Falcon Heavy `height` px tall: three cores, the fairing's window lit when `glass` is 'grok'.++ `parts` draws the stack or a single core (for the side boosters' twin landing); it is the stack's+ full width either way, so the cores stay where they were.+ """+ ink = {k: v + (255,) for k, v in FALCON_INK.items()}+ if height < 20: # the far, tiny one+ art = Image.new('RGBA', (len(TINY_FALCON[0]) + 2, len(TINY_FALCON) + 2))+ colours = {'W': ink['white'], 'K': ink['black'], 'G': ink['lit'] if glass == 'grok' else ink['black']}+ for yy, row in enumerate(TINY_FALCON):+ for xx, key in enumerate(row):+ if key in colours:+ art.putpixel((xx + 1, yy + 1), colours[key])+ return outlined(art, ink['line'])+ half, step = falcon_size(height)+ flare = max(1, round(height * .05))+ width = 3 * step + 2 * flare + 6+ art = Image.new('RGBA', (width, height + 2))+ d = ImageDraw.Draw(art)+ cx, top, bottom = width // 2, 1, height+ booster_top, booster_nose = top + round(height * .36), max(2, round(height * .1))+ band = booster_top + booster_nose # one black interstage line across all three cores+ for part in parts:+ side = {'left': -1, 'centre': 0, 'right': 1}[part]+ x = cx + side * step+ if side:+ falcon_core(d, ink, x, booster_top, bottom, half, booster_nose)+ fin = max(3, round(height * .14))+ for i in range(fin): # a swept fin on the outer side+ reach = round(flare * (i + 1) / fin)+ d.line((x + side * half, bottom - fin + 1 + i, x + side * (half + reach), bottom - fin + 1 + i),+ fill=ink['white'] if side < 0 else ink['shade'])+ else:+ falcon_core(d, ink, x, top, bottom, half, max(3, round(height * .16)), round(height * .26))+ wy, _ = falcon_window(height)+ d.rectangle((x - 1, wy - 1, x + 1, wy + 1), fill=ink['black'])+ d.point((x, wy), fill=ink['lit'] if glass == 'grok' else ink['black'])+ d.line((x - half, band, x + half, band), fill=ink['black'])+ art = outlined(art, ink['line'])+ if squash:+ art = art.resize((art.width + 2 * squash, art.height - 2 * squash), Image.Resampling.NEAREST)+ return art+++def scale2x(art):+ """EPX pixel-art doubling, the first step of RotSprite."""+ w, h = art.size+ src = art.load()+ out = Image.new('RGBA', (w * 2, h * 2))+ dst = out.load()+ for y in range(h):+ for x in range(w):+ p = src[x, y]+ a, b = src[x, max(0, y - 1)], src[min(w - 1, x + 1), y]+ c, d = src[max(0, x - 1), y], src[x, min(h - 1, y + 1)]+ dst[2 * x, 2 * y] = a if c == a and c != d and a != b else p+ dst[2 * x + 1, 2 * y] = b if a == b and a != c and b != d else p+ dst[2 * x, 2 * y + 1] = c if d == c and d != b and c != a else p+ dst[2 * x + 1, 2 * y + 1] = d if b == d and b != a and d != c else p+ return out+++def rotsprite(art, degrees):+ """`art` turned clockwise by `degrees`, RotSprite style (EPX ×8, turn, back down) so edges stay clean."""+ big = scale2x(scale2x(scale2x(art)))+ big = big.rotate(-degrees, resample=Image.Resampling.NEAREST, expand=True)+ return big.resize((max(1, big.width // 8), max(1, big.height // 8)), Image.Resampling.NEAREST)++[email protected]_cache(maxsize=None)+def grok_pose(size, eyes='open', squash=0):+ """The bundled Grok bot in white with dark eyes, `size` px tall; eyes 'open', 'shut' or 'dizzy'."""+ with Image.open(ASSETS / 'grok-pixel.png') as source:+ box = source.convert('RGBA').getbbox()+ art = bot_sprite('grok', box[2] - box[0], box[3] - box[1], '#f2f4f8', (12, 14, 20)).copy()+ px = art.load()+ if eyes != 'open':+ dark = [(x, y) for y in range(art.height) for x in range(art.width) if px[x, y][3] and sum(px[x, y][:3]) < 200]+ for p in dark:+ px[p] = GROK_WHITE+ middle = sum(x for x, _ in dark) / len(dark)+ for group in ([p for p in dark if p[0] < middle], [p for p in dark if p[0] >= middle]):+ ex = round(sum(x for x, _ in group) / len(group))+ ey = round(sum(y for _, y in group) / len(group))+ if eyes == 'shut': # a sleepy 'u'+ for x, yy in ((ex - 2, ey), (ex + 1, ey), (ex - 1, ey + 1), (ex, ey + 1)):+ px[x, yy] = (12, 14, 20, 255)+ else:+ for dy, line in enumerate(DIZZY):+ for dx, bit in enumerate(line):+ if bit == '#':+ px[ex - 2 + dx, ey - 2 + dy] = (12, 14, 20, 255)+ scale = size / art.height+ art = art.resize((max(1, round(art.width * scale)), max(1, round(art.height * scale))), Image.Resampling.NEAREST)+ if squash:+ art = art.resize((art.width + 2 * squash, art.height - 2 * squash), Image.Resampling.NEAREST)+ return art+++def stars(w, h, count):+ rnd = random.Random(w * 1000 + h)+ return [(rnd.randrange(w), rnd.randrange(h), rnd.randrange(3)) for _ in range(count)]+++def plume(draw, cx, top, width, length, f):+ """A cartoon exhaust: a white-hot core inside yellow, orange and red, with a ragged, flickering edge."""+ rnd = random.Random(f % 4)+ for r in range(length):+ p = r / max(1, length)+ half = max(1, round(width / 2 * (1 - p * .75) + rnd.choice((-1, 0, 0, 1)) * (p > .3)))+ for ring, color in enumerate(FIRE):+ inner = max(0, round(half * (1 - ring * .28)) - (ring > 0) * round(p * 2))+ if ring and p < .15 * ring:+ continue+ if inner > 0:+ draw.line((cx - inner, top + r, cx + inner - 1, top + r), fill=color if ring == 0 else FIRE[min(3, ring)])+ if p > .55:+ draw.line((cx - half, top + r, cx + half - 1, top + r), fill=FIRE[3 if p > .8 else 2])+ core = max(0, round(half * .4))+ if core:+ draw.line((cx - core, top + r, cx + core - 1, top + r), fill=FIRE[1])+++def puff(draw, cx, cy, r):+ """A round cartoon smoke puff: grey body, white crown."""+ if r < 1:+ return+ draw.ellipse((cx - r, cy - r, cx + r, cy + r), fill=PUFF[1])+ draw.ellipse((cx - r, cy + r // 3, cx + r, cy + r), fill=PUFF[2])+ draw.ellipse((cx - r * 2 // 3, cy - r, cx + r // 3, cy), fill=PUFF[0])+++def ease_out(p):+ return 1 - (1 - p) ** 3+++def grok_backdrop(draw, box, f, s):+ """Stars, a small Earth, the Moon's surface, the main deck and two side pads; returns the scene's layout."""+ x, y, w, h = box+ u = s / 2 # ½ on Arcade's 2 px grid+ draw.rectangle((x, y, x + w - 1, y + h - 1), fill=SKY['grok'])+ for i, (sx, sy, layer) in enumerate(stars(w, h, w * h // 500)):+ draw.point((x + sx, y + sy), fill=STARS[layer]) # still: the background does not move+ ex, ey, er = x + w - round(26 * u), y + round(20 * u), max(3, round(8 * u)) # a small Earth+ draw.ellipse((ex - er, ey - er, ex + er, ey + er), fill=(64, 124, 214))+ draw.ellipse((ex - er // 2, ey - er // 2, ex + er // 3, ey + er // 4), fill=(86, 172, 104))+ draw.point((ex - er // 2, ey - er + 1), fill=(220, 236, 255))+ ground = y + h - max(6, round(14 * u))+ draw.rectangle((x, ground, x + w - 1, y + h - 1), fill=LUNAR)+ draw.line((x, ground, x + w - 1, ground), fill=LUNAR_LIGHT)+ for cxr, wr in ((.1, 10), (.42, 6), (.86, 12)): # craters+ ccx, cw2 = x + round(w * cxr), max(2, round(wr * u))+ draw.ellipse((ccx - cw2, ground + 3 * u, ccx + cw2, ground + 3 * u + max(2, cw2 // 2)), fill=CRATER)+ hr = max(29, round(86 * u))+ rx = x + round(w * .64)+ deck = ground - max(2, round(3 * u))+ rest_art = rocket_art(hr)+ _, step = falcon_size(hr)+ sep = round(3.2 * step) # the side boosters' own landing pads+ for cx, half in ((rx, rest_art.width // 2 + round(4 * u)), (rx - sep, step // 2 + round(3 * u)),+ (rx + sep, step // 2 + round(3 * u))):+ draw.rectangle((cx - half, deck, cx + half - 1, ground - 1), fill=DECK)+ draw.line((cx - half, deck, cx + half - 1, deck), fill=DECK_EDGE)+ return u, ground, deck, hr, rx, rest_art, max(12, round(31 * u)), x + round(w * .2), sep+++def draw_stage(frame, draw, rx, deck, hr, u, parts, dx, lift, glass, squash, burn, legs, shiver, f):+ """One flying piece of the Falcon Heavy (the whole stack or one core), its plume and landing legs."""+ art = rocket_art(hr, glass, squash, parts)+ half, step = falcon_size(hr)+ top = deck - art.height + 1 - lift+ centres = [rx + dx + {'left': -step, 'centre': 0, 'right': step}[p] for p in parts]+ if burn:+ if len(parts) == 3:+ plume(draw, rx + dx, round(top + art.height - 1), max(4, round(art.width * .55)), burn, f)+ else:+ plume(draw, centres[0], round(top + art.height - 1), max(3, 2 * half + 2), burn, f)+ if legs:+ left, right = min(centres) - half, max(centres) + half+ for root_x, side in ((left + 1, -1), (right - 1, 1)):+ root = (root_x, top + art.height - round(hr * .16))+ foot = (root_x + side * round(4 * u * legs), top + art.height + round(2 * u * legs))+ draw.line((*root, *foot), fill=LEG, width=max(1, round(u)))+ paste(frame, art, rx + dx - art.width / 2 + shiver, top)+++TANK, TANK_DARK = (150, 160, 176), (30, 34, 46)+FUEL, FUEL_TOP, FUEL_LOW = (240, 150, 50), (255, 204, 110), (236, 72, 64)+++def fuel_tank(draw, x, ground, s, left, label=''):+ """Grok's fuel: a tank by the pad, full while there is plenty left and draining as the limit is used (red in+ the last 10%), with marks at a quarter, a half and three quarters; `left` None draws it empty and unread."""+ tw, th = 9 * s, 24 * s+ top = ground - th+ draw.rounded_rectangle((x, top, x + tw - 1, ground - 1), radius=2 * s, fill=TANK_DARK, outline=TANK)+ inner = th - 2 * s+ if left is not None:+ level = round(inner * max(0, min(1, left)))+ if level:+ colour = FUEL_LOW if left < .1 else FUEL+ draw.rectangle((x + s, ground - s - level, x + tw - 1 - s, ground - s - 1), fill=colour)+ draw.line((x + s, ground - s - level, x + tw - 1 - s, ground - s - level), fill=FUEL_LOW if left < .1 else FUEL_TOP)+ for q in (.25, .5, .75):+ my = ground - s - round(inner * q)+ draw.line((x + tw, my, x + tw + s, my), fill=TANK)+ draw.line((x + tw, ground - 3 * s, x + tw + 3 * s, ground - 3 * s), fill=TANK) # the pipe toward the pad+ if s == 1 and label:+ gauge_label(draw, x + tw // 2, ground + 2, label, 'centre')+++HOSE, CONSOLE, CONSOLE_GLASS, CODE_GREEN = (44, 46, 56), (120, 128, 144), (16, 24, 30), (110, 220, 160)+++def grok_fuelling(draw, x, ground, k, s, size, rocket_left, worried):+ """Grok's first job at work: it walks the hose from the tank to the rocket, fills it (the fuel running along the+ hose), taps it twice with a wrench and walks back, a step a second; nearly out, it hurries to and fro twice.+ Returns where Grok stands (centre x, bottom, eyes, squash, size) and whether it faces left."""+ home, far = x + 2 * s + 9 * s + size // 2 + 2 * s, rocket_left - size // 2 - 3 * s+ t = (k * (2 if worried else 1)) % FRAMES+ if t < 24:+ gx, flip, sq = home + (far - home) * t / 24, False, 0+ elif t < 84:+ gx, flip, sq = far, False, 1 if t % 12 == 0 else 0+ elif t < 96:+ gx, flip, sq = far, False, 1 if (t - 84) % 6 < 3 else 0 # two taps with the wrench+ else:+ gx, flip, sq = far + (home - far) * (t - 96) / 24, True, 0+ bob = s if t % 12 < 6 and (t < 24 or t >= 96) else 0+ nozzle, hand = (x + 11 * s, ground - 20 * s), (round(gx) + (-size // 3 if flip else size // 3), ground - size // 2 - bob)+ sag = (round((nozzle[0] + hand[0]) / 2), max(nozzle[1], hand[1]) + 4 * s)+ draw.line((*nozzle, *sag), fill=HOSE, width=max(1, s))+ draw.line((*sag, *hand), fill=HOSE, width=max(1, s))+ if 24 <= t < 84: # fuel running down the hose into the rocket+ for n in range(3):+ p = ((t * 2 + n * 8) % 24) / 24+ a, b = (nozzle, sag) if p < .5 else (sag, hand)+ q = p * 2 if p < .5 else p * 2 - 1+ draw.point((round(a[0] + (b[0] - a[0]) * q), round(a[1] + (b[1] - a[1]) * q)), fill=FUEL_TOP)+ if worried and t % 24 < 12:+ pixel_text(draw, (round(gx) - 2, ground - size - 12 * s), '!', color=(255, 226, 120))+ return (gx, ground - bob, 'open', sq, size), flip+++def grok_at_console(draw, x, w, ground, k, s, size, worried):+ """Grok's other job: at the console by the pad, typing (a beat a second), lines of code going up the screen;+ now and then a hand to its headset, a look over at the rocket and back. Nearly out, the screen is red and it+ types twice as fast, hopping and looking from screen to rocket. Returns where Grok stands and whether it faces left."""+ cx0, top = x + w - 16 * s, ground - 12 * s+ draw.rectangle((cx0, top, cx0 + 12 * s, ground - 1), fill=CONSOLE)+ draw.rectangle((cx0 + 2 * s, top + 2 * s, cx0 + 10 * s, top + 7 * s), fill=(150, 24, 36) if worried else CONSOLE_GLASS)+ for n in range(3): # the lines scroll up a row each half second+ ly = top + 3 * s + ((n * 2 - k // 6) % 5) * s+ if top + 2 * s <= ly <= top + 6 * s:+ draw.line((cx0 + 3 * s, ly, cx0 + (6 + 2 * ((n + k // 6) % 2)) * s, ly),+ fill=(255, 220, 220) if worried else CODE_GREEN)+ gx = cx0 - size // 2 - 2 * s+ # a hand to the headset, a glance at the rocket; nearly out, hopping from foot to foot and glancing from screen+ # to rocket twice a second+ look = (k // 6) % 2 == 1 if worried else 40 <= k % 60 < 48+ beat = 3 if worried else 6+ sq = 1 if (k % (2 * beat) < beat and not look) else 0+ lift = 2 * s if worried and k % 6 < 3 else 0+ if worried and k % 24 < 12:+ pixel_text(draw, (round(gx) - 2, ground - size - 12 * s), '!', color=(255, 226, 120))+ return (gx, ground - lift, 'open', sq, size), look+++def grok_scene(frame, draw, box, f, span, active, s, plan, centre=.5):+ x, y, w, h = box+ u, ground, deck, hr, rx, rest_art, gsize, gx0, sep = grok_backdrop(draw, box, f, s)+ if isinstance(plan, dict):+ used = plan.get('used')+ if used is not None: # no reading, no tank: an empty one would say it ran dry+ fuel_tank(draw, x + 2 * s, ground, s, 1 - used / 100, plan.get('label', ''))+ _, step = falcon_size(hr)+ k = (f * FRAMES // span) % FRAMES if active else f # one whole flight a turn (it runs at its own pace)+ glass, squash, shiver = 'empty', 0, 0+ whole = {'lift': 0.0, 'burn': 0, 'legs': 1.0} # the stack in one piece, unless split below+ split = None # [(parts, dx, lift, squash, burn, legs)] while the cores fly apart+ grok = None # (centre x, bottom y, eyes, squash, size)+ lamp = active # the pad's light is on, steady, while the rocket is being readied+ win_y = deck - rest_art.height + 1 + falcon_window(hr)[0]+ flip = False+ if not active:+ idle = idle_now(plan, f, span)+ breath = 1 if 20 <= f % 48 < 28 else 0+ blink = 'shut' if f % 40 in (20, 21) else 'open'+ if idle == 'wander': # two steps out, two steps back, a little bob on each+ t = f % 48+ reach = (0, 1, 2, 2, 1, 0, 0, 0)[t // 6]+ flip = 18 <= t < 36+ bob = round(2 * u) if t % 6 < 3 and t < 36 else 0+ grok = (gx0 + reach * round(7 * u), ground - bob, blink, 0, gsize)+ elif idle == 'fret': # pacing up and down by the rocket in quick little steps, '!' now and then+ t = f % 24+ flip = t >= 12+ p = t / 12 if t < 12 else 2 - t / 12+ bob = round(abs(math.sin(f * math.pi / 3)) * 3 * u)+ grok = (gx0 + p * 26 * u, ground - bob, blink, 1 if f % 3 == 0 else 0, gsize)+ if (f // 12) % 2 == 0:+ pixel_text(draw, (round(grok[0] - 2), round(ground - gsize - 14 * u)), '!', color=(255, 226, 120))+ elif idle == 'gaze': # up at the Earth, with a hop now and then+ lift = round(4 * (f % 24) / 6 * (1 - (f % 24) / 6) * 5 * u) if f % 24 < 6 else 0+ grok = (gx0, ground - lift, blink, 1 if f % 24 == 6 else 0, gsize)+ else:+ grok = (gx0, ground, 'shut', breath, gsize)+ t = f % 40+ if t < 30:+ pixel_text(draw, (round(gx0 + gsize // 2 + t * u * .8), round(ground - gsize - 4 - t * u * 1.2)), 'z',+ scale=2 if u >= 1 and t >= 12 else 1, color=PUFF[1] if t < 22 else PUFF[2])+ if isinstance(plan, dict):+ mood_marks(draw, round(grok[0] + gsize * .3), ground - gsize - round(4 * u), max(1, s // 2 + (s > 2)), f,+ plan.get('mood'), idle == 'nap')+ else: # at work, outside: fuelling the rocket from the tank, or at the console running the checks+ worried = isinstance(plan, dict) and plan.get('mood') == 'worried'+ role = plan.get('role', 'crew') if isinstance(plan, dict) else 'crew'+ for start in (0, 30, 60, 90): # the Falcon vents steam from both sides+ age = k - start+ if 0 <= age < 12:+ for side in (-1, 1):+ puff(draw, rx + side * (rest_art.width // 2 + age * u * 1.5), deck - age * u * .6, round((2 + age / 3) * u))+ if role == 'control':+ grok, flip = grok_at_console(draw, x, w, ground, k, s, gsize, worried)+ if 64 <= k < 80 and not worried: # the console fires a short test burn: a rumble, a lift, a flame+ t = k - 64+ whole = {'lift': round(min(t, 16 - t) * u * .5), 'burn': round((4 + min(t, 6)) * u), 'legs': 1.0}+ shiver = 1 if t % 2 else -1+ elif worried: # nearly dry: the rocket rattles on the pad+ shiver = 1 if (k // 3) % 2 else -1+ else:+ grok, flip = grok_fuelling(draw, x, ground, k, s, gsize, rx - rest_art.width // 2, worried)+ if whole is not None:+ draw_stage(frame, draw, rx, deck, hr, u, ('left', 'centre', 'right'), 0, whole['lift'], glass, squash,+ whole['burn'], whole['legs'], shiver, f)+ for parts, dx, lift, sq, burn, legs in split or ():+ draw_stage(frame, draw, rx, deck, hr, u, parts, dx, lift, glass, sq, burn, legs, 0, f)+ if not active or k < 37:+ draw.rectangle((rx - rest_art.width // 2 - round(4 * u), deck - 1, rx - rest_art.width // 2 - round(4 * u) + max(1, round(u)), deck - 1),+ fill=(255, 90, 90) if lamp else DECK_EDGE)+ if grok:+ gx, bottom, eyes, sq, size = grok+ if active and isinstance(plan, dict) and plan.get('mood') == 'worried':+ mood_marks(draw, round(gx + size * .3), round(bottom - size - 4 * u), max(1, s // 2 + (s > 2)), f, 'worried')+ art = grok_pose(size, eyes, sq)+ if flip:+ art = art.transpose(Image.Transpose.FLIP_LEFT_RIGHT)+ paste(frame, art, gx - art.width / 2, bottom - art.height)+++# --- Copilot ---------------------------------------------------------------------------------+# Copilot flies a little propeller plane through the clouds, a teal-to-blue trail behind it;+# idle, it dozes on a cloud.++COPILOT_SKY = ((9, 26, 66), (11, 38, 84), (12, 52, 98), (14, 68, 112)) # night blue to teal, top to bottom+CLOUD_TOP, CLOUD_BASE = (232, 244, 255), (176, 204, 232)+PLANE = {'body': (242, 246, 251), 'shade': (190, 204, 222), 'wing': (46, 196, 206), 'trim': (37, 99, 235),+ 'dark': (30, 40, 62), 'prop': (170, 180, 200)}+TRAIL = ((54, 216, 180), (38, 194, 204), (31, 167, 226), (37, 99, 235))+++# Copilot's mascot (assets/copilot-pixel.png, after the owner's pixel reference) scales down cleanly to the+# head Arcade draws on its cloud (COPILOT_HEAD px tall); on the plane it is only 8 px, so that one is placed by+# hand in the same colours: N navy (visor, goggle glass), C cyan dome, B blue ear pods, E the eyes.+COPILOT_HEAD = 20+COPILOT_INK = {'N': (25, 29, 57), 'C': (168, 247, 248), 'B': (112, 173, 239), 'E': (224, 252, 250)}+COPILOT_SMALL = {8: ('..CCCC..', '.CNCCNC.', 'BCCCCCCB', 'BNNNNNNB', 'BNENNENB', 'BNENNENB', '.CCCCCC.')}++[email protected]_cache(maxsize=None)+def copilot_pose(size, eyes='open'):+ """Copilot's face `size` px tall; with eyes 'shut' the glowing pills close to their bottom row."""+ small = COPILOT_SMALL.get(size)+ if small:+ rows = small+ if eyes == 'shut': # every eye row but the last turns to visor+ last = max(y for y, line in enumerate(rows) if 'E' in line)+ rows = [line.replace('E', 'N') if y < last else line for y, line in enumerate(rows)]+ art = Image.new('RGBA', (len(rows[0]), len(rows)))+ for y, line in enumerate(rows):+ for x, key in enumerate(line):+ if key in COPILOT_INK:+ art.putpixel((x, y), COPILOT_INK[key] + (255,))+ return art+ with Image.open(ASSETS / 'copilot-pixel.png') as source:+ art = source.convert('RGBA')+ art = art.crop(art.getbbox())+ scale = size / art.height+ art = art.resize((max(1, round(art.width * scale)), max(1, round(art.height * scale))), Image.Resampling.NEAREST)+ if eyes == 'shut': # the eyes are the light pixels with dark visor on both sides, low on the face+ px = art.load()+ dark = lambda p: p[3] and sum(p[:3]) < 200+ light = lambda p: p[3] and sum(p[:3]) > 450+ eye = [(x, y) for y in range(art.height // 2, art.height) for x in range(1, art.width - 1)+ if light(px[x, y]) and dark(px[x - 1, y]) and (dark(px[x + 1, y]) or (light(px[x + 1, y]) and dark(px[min(x + 2, art.width - 1), y])))]+ if eye:+ bottom = max(y for _, y in eye)+ for x, y in eye:+ if y < bottom:+ px[x, y] = COPILOT_INK['N'] + (255,)+ return art+++def cloud(draw, cx, cy, r, top=CLOUD_TOP, base=CLOUD_BASE):+ """A puffy pixel cloud of radius r: three bumps on a flat base, lit from above."""+ for dx, dy, k in ((-r, r // 3, .75), (0, 0, 1), (r, r // 3, .7)):+ rr = round(r * k)+ draw.ellipse((cx + dx - rr, cy + dy - rr, cx + dx + rr, cy + dy + rr), fill=top)+ draw.rectangle((cx - r - round(r * .7), cy + r // 3, cx + r + round(r * .7), cy + r // 3 + max(2, r // 2)), fill=base)+++# The plane, 30 × 15 at u = ½: W body, S belly, B blue (fin, cheat line), T teal (wing, tailplane), K spinner.+PLANE_ROWS = (+ '.BB...........................',+ '.BBB..........................',+ '..BBB.........................',+ '..BBBB........................',+ '...BBBB.......................',+ '...BBBBB......................',+ '...BBBBWWWWWWWWWWWWWWWWWWW....',+ '...WWWWWWWWWWWWWWWWWWWWWWWWW..',+ 'TTTTTWBBBBBBBBBBBBBBBBBBBBBWW.',+ '...WWWWWWWWWWWWWWWWWWWWWWWWWWK',+ '....SSSSSSSSSSSSSSSSSSSSSSSSSK',+ '......SSSSSSTTTTTTTTSSSSSSSS..',+ '...........TTTTTTTT...........',+ '..........TTTTTTT.............',+ '.........TTTTTT...............',+)++[email protected]_cache(maxsize=None)+def plane(u, blade):+ """Copilot's plane facing right, `u` units big: a tall fin, a swept wing, a cheat line; `blade` 0/1 spins the prop."""+ ink = {'W': PLANE['body'], 'S': PLANE['shade'], 'B': PLANE['trim'], 'T': PLANE['wing'], 'K': PLANE['dark']}+ art = Image.new('RGBA', (len(PLANE_ROWS[0]) + 2, len(PLANE_ROWS)))+ for y, row in enumerate(PLANE_ROWS):+ for x, key in enumerate(row):+ if key in ink:+ art.putpixel((x, y), ink[key] + (255,))+ for y in (range(3, 15) if blade else range(8, 12)): # the blade end-on, or edge-on and short+ art.putpixel((art.width - 1, y), PLANE['prop'] + (255,))+ k = max(1, round(2 * u))+ return art.resize((art.width * k, art.height * k), Image.Resampling.NEAREST) if k > 1 else art+++def copilot_backdrop(draw, box, f, s, far=0, clouds=True):+ """Night blue to teal, a few stars and (unless the scene counts its own) the far clouds, `far` px along."""+ x, y, w, h = box+ u = s / 2+ for k, tone in enumerate(COPILOT_SKY):+ draw.rectangle((x, y + k * h // 4, x + w - 1, y + (k + 1) * h // 4 - 1), fill=tone)+ for i, (sx, sy, layer) in enumerate(stars(w, h // 2, w * h // 900)):+ draw.point((x + sx, y + sy), fill=STARS[layer])+ period = w + round(80 * u)+ for i, (fx, fy, r) in enumerate(((.15, .3, 7), (.6, .22, 6), (.95, .36, 8)) if clouds else ()): # far, drifting+ cx = x + (round(fx * period) - far) % period - round(40 * u)+ cloud(draw, cx, y + round(fy * h), max(3, round(r * u)))+ return period+++CLOUD_SPOT = (24, 48, 86) # a patch of sky still waiting for its cloud+++def cloud_count(draw, box, s, used, label=''):+ """Copilot's gauge: five clouds across the sky, one for each 20% used, the next one growing with the+ reading through its fifth; the patches still clear show faintly, so the five places always read."""+ x, y, w, h = box+ done = 0 if used is None else min(5, int(used // 20))+ part = 0 if used is None or done == 5 else (used % 20) / 20+ for i in range(5):+ cx, cy = x + round(w * (i + .5) / 5), y + round(h * (.2 if i % 2 else .16))+ if i < done:+ cloud(draw, cx, cy, 5 * s)+ else:+ cloud(draw, cx, cy, 5 * s, CLOUD_SPOT, CLOUD_SPOT)+ if i == done and part:+ cloud(draw, cx, cy, max(1, round((1 + 3 * part) * s))) # never full until the fifth is done+ if s == 1 and label:+ gauge_label(draw, x + 1, y + 1, label)+++def copilot_scene(frame, draw, box, f, span, active, s, plan, centre=.5):+ x, y, w, h = box+ u = s / 2+ period = copilot_backdrop(draw, box, f, s, clouds=False) # the sky stands still; the plane crosses it+ used = plan.get('used') if isinstance(plan, dict) else None+ level = y + round(h * .52) # where it flies, under the clouds that count its use+ if isinstance(plan, dict) and used is not None:+ cloud_count(draw, box, s, used, plan.get('label', ''))+ if active:+ # One crossing a loop of the scene, in from the left and out on the right with its trail; it bobs about+ # once a second, and twice as fast, shaking, its trail sputtering, when nearly out.+ worried = isinstance(plan, dict) and plan.get('mood') == 'worried'+ bobs = max(1, round(span / (FPS * SPEED))) * (2 if worried else 1)+ art = plane(u, (f // 2) % 2) # f is even at twice the pace, so f % 2 would freeze the prop+ pace = plan.get('pace', 3) if isinstance(plan, dict) else 3+ segments = 4 + min(6, round(pace)) # the trail, teal to blue: longer the harder it works+ reach = w + art.width + segments * round(5 * u)+ bob = round(math.sin(2 * math.pi * f / span * bobs) * (3 if worried else 2) * u)+ px_ = x - art.width + round(reach * (f / span))+ py_ = level - art.height // 2 + bob+ for k in range(segments):+ if worried and (k + f // 4) % 3 == 0:+ continue # sputtering+ tx = px_ + round(4 * u) - k * round(5 * u)+ ty = py_ + round(18 * u) - bob + round(math.sin(k / 2) * u)+ if x <= tx < x + w:+ c = TRAIL[min(len(TRAIL) - 1, k * len(TRAIL) // 10)]+ d = max(1, round(2 * u))+ draw.rectangle((tx, ty, tx + d - 1, ty + d - 1), fill=c)+ head = copilot_pose(max(8, round(17 * u)))+ paste(frame, head, px_ + round(30 * u) - head.width / 2, py_ + round(17 * u) - head.height)+ paste(frame, art, px_, py_)+ if isinstance(plan, dict) and plan.get('mood') == 'worried': # nearly out, still flying: sweating+ mood_marks(draw, round(px_ + 30 * u), round(py_ + 17 * u - head.height - 3 * u), max(1, s // 2 + (s > 2)),+ f, 'worried')+ else:+ base_y = y + round(h * .78) # resting on its cloud, low in the sky+ idle = idle_now(plan, f, span)+ if idle == 'fret': # nearly out: the plane parked on the next cloud, its warning light on+ centre = .3+ px_ = x + round(w * .72)+ cloud(draw, px_, base_y, max(5, round(14 * u)))+ art = plane(u, 0)+ paste(frame, art, px_ - art.width / 2, base_y - art.height + round(3 * u))+ lamp = (round(px_ - art.width / 2 + 2 * u), round(base_y - art.height + round(3 * u) - 2 * u))+ draw.rectangle((*lamp, lamp[0] + max(2, round(4 * u)) - 1, lamp[1] + max(2, round(4 * u)) - 1),+ fill=(255, 84, 84)) # the warning light, on and steady+ cloud(draw, x + round(w * centre), base_y, max(5, round(14 * u)))+ eyes = 'shut' if idle == 'nap' or f % 40 in (14, 15) else 'open'+ head = copilot_pose(max(10, round(COPILOT_HEAD * s)), eyes)+ if idle == 'look' and (f // 20) % 2: # looking about, one side then the other+ head = head.transpose(Image.Transpose.FLIP_LEFT_RIGHT)+ if idle == 'fret' and (f // 6) % 2: # glancing at the plane and back, quickly+ head = head.transpose(Image.Transpose.FLIP_LEFT_RIGHT)+ breath = 1 if idle == 'nap' and 20 <= f % 48 < 28 else 0+ lift = round(4 * (f % 16) / 8 * (1 - (f % 16) / 8) * 6 * u) if idle == 'hop' and f % 16 < 8 else 0+ if idle == 'fret': # fidgeting on its cloud, twice a second+ lift = round(2 * u) if f % 12 < 4 else 0+ hy = base_y - head.height - round(4 * u) + breath - lift+ paste(frame, head, x + round(w * centre - head.width / 2), hy)+ if idle == 'nap':+ t = f % 40+ if t < 30:+ pixel_text(draw, (round(x + w * centre + head.width / 2 + t * u * .8), round(base_y - head.height - 6 * u - t * u)),+ 'z', scale=2 if u >= 1 and t >= 12 else 1, color=CLOUD_BASE if t < 22 else (120, 150, 190))+ if isinstance(plan, dict):+ mood_marks(draw, round(x + w * centre + head.width * .25), hy - round(3 * u), max(1, s // 2 + (s > 2)), f,+ plan.get('mood'), idle == 'nap')+++# --- Anti (Antigravity) -------------------------------------------------------------------------+# Antigravity is Anti, a ghost made of its logo: the logo's 12 x 10 blocks (assets/antigravity-logo.png) at+# 2 x 2, one chin row under the mouth, a ghost's hem along its feet, bean eyes and a cat's mouth. It lives in a+# maze after the old arcade halls (none of their characters, only the maze, the dots and the pellets): at work it+# patrols the loop round the centre wall, eyes on the next turn; at rest it waits in the house behind the pink+# door; the four power pellets are what is left of its 5 hours. Near the limit it turns blue, like a frightened+# ghost: slow and backing off at work, hiding its face at rest.++ANTI_NAVY, ANTI_PEACH, ANTI_RED = (14, 16, 30), (255, 184, 174), (255, 0, 0)+ANTI_SCARED, ANTI_FLASH = (33, 33, 222), (222, 222, 255)+MAZE_WALL, MAZE_DOT, MAZE_BG, MAZE_DOOR = (33, 33, 222), (255, 184, 174), (2, 2, 8), (255, 184, 255)+ANTI_CHIN = ((10, (88, 149, 216)), (11, (88, 149, 216)), (12, (86, 125, 221)), (13, (86, 125, 221)))+ANTI_FEET = frozenset((x, 19) for x in (0, 1, 2, 3, 20, 21, 22, 23))+BEAN, BEAN_SHUT, CAT_MOUTH = ('XX', 'XX', 'XX'), ('XX',), ('X.X.X', '.X.X.')+DOT_EYE, SMILE_EYE, ZED = ('XX', 'XX'), ('.X.', 'X.X'), ('XXX', '..X', '.X.', 'X..', 'XXX')+# The patrol: the sprite's corner round the centre wall, and the pellets, used from the top left round to the+# bottom left (what is left sits in the last corners).+ANTI_LOOP = ((3, 9), (93, 9), (93, 41), (3, 41))+ANTI_PELLETS = ((15, 19), (105, 19), (105, 51), (15, 51))+ANTI_HOME = (48, 36) # Anti in the house+++def grid_stamp(draw, x, y, rows, ink):+ for yy, line in enumerate(rows):+ for xx, key in enumerate(line):+ if key != '.':+ draw.point((x + xx, y + yy), fill=ink)+++def wavy(draw, x0, x1, y, ink):+ for i, xx in enumerate(range(x0, x1 + 1)):+ draw.point((xx, y + (i // 2) % 2), fill=ink)+++def anti_face(draw, face, dx=0, dy=0):+ """Anti's faces on its 24 x 20 sprite, eyes looking (dx, dy): 'normal' (beans and the cat's mouth), 'blink' or+ 'sleep', 'happy' (^ ^), 'curious' (dots), 'roll' (dots rolled up), 'scared', 'wide_scared' and 'low_scared'+ (hiding) with their 'flash' versions, and 'eaten' (the eyes alone)."""+ if face in ('normal', 'curious'):+ eye = BEAN if face == 'normal' else DOT_EYE+ grid_stamp(draw, 9 + dx, 4 + dy, eye, ANTI_NAVY)+ grid_stamp(draw, 13 + dx, 4 + dy, eye, ANTI_NAVY)+ grid_stamp(draw, 10, 8, CAT_MOUTH, ANTI_NAVY)+ elif face in ('blink', 'sleep'):+ grid_stamp(draw, 9 + dx, 5, BEAN_SHUT, ANTI_NAVY)+ grid_stamp(draw, 13 + dx, 5, BEAN_SHUT, ANTI_NAVY)+ grid_stamp(draw, 10, 8, CAT_MOUTH, ANTI_NAVY)+ elif face == 'roll':+ grid_stamp(draw, 9, 3, DOT_EYE, ANTI_NAVY)+ grid_stamp(draw, 13, 3, DOT_EYE, ANTI_NAVY)+ grid_stamp(draw, 10, 8, CAT_MOUTH, ANTI_NAVY)+ elif face == 'happy':+ grid_stamp(draw, 8, 4, SMILE_EYE, ANTI_NAVY)+ grid_stamp(draw, 13, 4, SMILE_EYE, ANTI_NAVY)+ elif face == 'eaten':+ grid_stamp(draw, 9 + dx, 4 + dy, BEAN, ANTI_PEACH)+ grid_stamp(draw, 13 + dx, 4 + dy, BEAN, ANTI_PEACH)+ else:+ ink = ANTI_RED if face.endswith('flash') else ANTI_PEACH+ if face.startswith('wide'):+ eyes, mouth = ((8, 5), (14, 5)), (6, 17, 8)+ elif face.startswith('low'):+ eyes, mouth = ((9, 14), (13, 14)), (7, 16, 17)+ else:+ eyes, mouth = ((9, 5), (13, 5)), (8, 15, 8)+ for ex, ey in eyes:+ draw.rectangle((ex, ey, ex + 1, ey + 1), fill=ink)+ wavy(draw, *mouth, ink)++[email protected]_cache(maxsize=None)+def anti_logo():+ return Image.open(ASSETS / 'antigravity-logo.png').convert('RGBA')++[email protected]_cache(maxsize=1024)+def anti_art(face='normal', body='logo', step=0, dx=0, dy=0, flip=False, scale=1):+ """Anti, 24 x 20 at scale 1: its logo body ('logo', 'scared' blue, 'flash' pale, or 'none' for the eyes alone),+ the hem stepping with `step`, the face looking (dx, dy), upside down with `flip`."""+ art = Image.new('RGBA', (24, 20))+ draw = ImageDraw.Draw(art)+ if body != 'none':+ logo = anti_logo()+ tone = {'scared': ANTI_SCARED, 'flash': ANTI_FLASH}.get(body)+ for by in range(logo.height):+ for bx in range(logo.width):+ colour = logo.getpixel((bx, by))+ if not colour[3]:+ continue+ for px_ in (2 * bx, 2 * bx + 1):+ for py_ in (2 * by, 2 * by + 1):+ if (px_, py_) not in ANTI_FEET or (px_ + step) % 2 == 0: # the hem, alternate pixels+ draw.point((px_, py_), fill=tone or colour[:3])+ for cx, colour in ANTI_CHIN:+ draw.point((cx, 10), fill=tone or colour)+ anti_face(draw, face, dx, dy)+ if flip:+ art = art.transpose(Image.Transpose.FLIP_TOP_BOTTOM)+ return art.resize((24 * scale, 20 * scale), Image.Resampling.NEAREST) if scale != 1 else art+++def anti_pellets(draw, box, left, label=''):+ """The gauge: a power pellet in each corner for every 25% left of the 5 hours, the last one smaller as it+ runs down; used ones leave a faint mark, so the four places always read. They never blink."""+ x, y, w, h = box+ count = 0 if left is None else max(0.0, min(1.0, left)) * 4+ full, part = int(count), count - int(count)+ for i in range(4):+ px_, py_ = ANTI_PELLETS[3 - i]+ px_, py_ = x + px_, y + py_+ if i < full:+ draw.ellipse((px_ - 3, py_ - 3, px_ + 3, py_ + 3), fill=MAZE_DOT)+ elif i == full and part > .05:+ r = 2 if part >= .5 else 1+ draw.ellipse((px_ - r, py_ - r, px_ + r, py_ + r), fill=MAZE_DOT)+ else:+ draw.point((px_, py_), fill=(90, 70, 80))+ if label:+ gauge_label(draw, x + 1, y + 1, label)+++def anti_maze(draw, box, f, s, left, house=False, label='', wall=MAZE_WALL, door=True, pellets=True):+ """The still maze: an outer wall, rows of dots, and in the middle the centre wall (work) or the house with+ its pink door (rest), with the pellets (left out where the scene cannot know the reading: a gauge may go+ missing for a scene, never show a wrong value)."""+ x, y, w, h = box+ draw.rectangle((x, y, x + w - 1, y + h - 1), fill=MAZE_BG)+ draw.rounded_rectangle((x + 1, y + 7, x + 118, y + 63), radius=4, outline=wall)+ if house:+ draw.rectangle((x + 44, y + 31, x + 76, y + 59), outline=wall)+ draw.rectangle((x + 45, y + 32, x + 75, y + 58), outline=wall)+ draw.rectangle((x + 54, y + 31, x + 66, y + 32), fill=MAZE_DOOR if door else MAZE_BG)+ else:+ draw.rounded_rectangle((x + 29, y + 31, x + 91, y + 39), radius=3, outline=wall)+ for dx in range(30, 92, 6):+ for dy in (19, 51):+ draw.rectangle((x + dx, y + dy, x + dx + 1, y + dy + 1), fill=MAZE_DOT)+ for dy in (31, 37):+ for dx in (15, 105):+ draw.rectangle((x + dx, y + dy, x + dx + 1, y + dy + 1), fill=MAZE_DOT)+ if pellets:+ anti_pellets(draw, box, left, label)+++def anti_on_loop(s_):+ """Where the patrol is at distance `s_` round the loop, and which way the eyes look: along the way, and toward+ the next turn just before each corner."""+ corners = ANTI_LOOP+ lengths = [abs(b[0] - a[0]) + abs(b[1] - a[1]) for a, b in zip(corners, corners[1:] + corners[:1])]+ s_ %= sum(lengths)+ for i, length in enumerate(lengths):+ a, b = corners[i], corners[(i + 1) % 4]+ if s_ <= length:+ p = s_ / length+ ux, uy = (b[0] > a[0]) - (b[0] < a[0]), (b[1] > a[1]) - (b[1] < a[1])+ if length - s_ < 8:+ c = corners[(i + 2) % 4]+ ux, uy = (c[0] > b[0]) - (c[0] < b[0]), (c[1] > b[1]) - (c[1] < b[1])+ return a[0] + (b[0] - a[0]) * p, a[1] + (b[1] - a[1]) * p, ux, uy+ s_ -= length+ return corners[0][0], corners[0][1], 1, 0+++def anti_left(plan, row=None):+ """What is left of the window the pellets follow: the 5 hours where there is one, else the scene's own."""+ if isinstance(plan, dict) and plan.get('anti') is not None:+ return plan['anti']+ used = plan.get('used') if isinstance(plan, dict) else None+ return None if used is None else 1 - used / 100+++def anti_scene(frame, draw, box, f, span, active, s, plan, centre=.5):+ x, y, w, h = box+ worried = isinstance(plan, dict) and plan.get('mood') == 'worried'+ happy = isinstance(plan, dict) and plan.get('mood') == 'happy'+ label = plan.get('anti_label', '') if isinstance(plan, dict) and s == 1 else ''+ anti_maze(draw, box, f, s, anti_left(plan), house=not active, label=label, pellets=anti_left(plan) is not None)+ if active and worried: # frightened: blue, backing and forth along the top, slowly+ t = f / span+ px_ = x + 20 + 50 * (1 - math.cos(2 * math.pi * t)) / 2+ paste(frame, anti_art('scared', 'scared', (f // 3) % 2), px_, y + 9)+ return+ if active: # the patrol: one round of the loop a turn, eyes on the way ahead+ lengths = 2 * (abs(ANTI_LOOP[1][0] - ANTI_LOOP[0][0]) + abs(ANTI_LOOP[2][1] - ANTI_LOOP[1][1]))+ px_, py_, ux, uy = anti_on_loop(f / span * lengths)+ face = 'happy' if happy else 'blink' if f % 36 in (30, 31) else 'normal'+ paste(frame, anti_art(face, 'logo', (f // 6) % 2, ux if face == 'normal' else 0, uy if face == 'normal' else 0),+ x + px_, y + py_)+ return+ hx, hy = x + ANTI_HOME[0], y + ANTI_HOME[1]+ idle = idle_now(plan, f, span)+ if idle == 'fret': # frightened at rest: blue in the house, bobbing fast, hiding its face+ paste(frame, anti_art('low_scared', 'scared', (f // 3) % 2), hx, hy + round(math.sin(2 * math.pi * f / 6)))+ elif idle == 'look': # looking round: one side, the other, up at the door, down+ dx, dy = ((-1, 0), (1, 0), (0, -1), (0, 1))[min(3, int(f / max(1, span / 2) * 4)) % 4]+ paste(frame, anti_art('happy' if happy else 'curious', 'logo', 0, dx, dy), hx, hy - (1 if dy < 0 else 0))+ elif idle == 'bob': # awake, bobbing gently, a blink every three seconds+ face = 'happy' if happy else 'blink' if f % 36 in (30, 31) else 'normal'+ paste(frame, anti_art(face, 'logo', 0), hx, hy + round(2 * math.sin(2 * math.pi * f / 24)))+ else: # asleep: a slow breath and the z's+ paste(frame, anti_art('sleep', 'logo', 0), hx, hy + 2 + round(math.sin(2 * math.pi * f / 36)))+ t = f % 36+ if t < 30:+ grid_stamp(draw, hx + 22 + t // 9, hy - 6 - t // 3, ZED, (230, 230, 240))+++SCENES = {'claude': claude_scene, 'codex': codex_scene, 'grok': grok_scene, 'copilot': copilot_scene,+ 'antigravity': anti_scene}+++# --- Layouts ---------------------------------------------------------------------------------++def label_of(row):+ return account_label(row)+++def info(row, now, value=None):+ """(used, window name, old?, coarse time left) for one window; by default the row's weekly one."""+ if value is None:+ wins = shown_windows(row, 3)+ value = wins[0] if wins else None+ used, period, old, _ = reading(row, value)+ left = coarse_left(value.get('resets_at'), now) if value else '--'+ return used, period, old, left+++IDLE_SETS = {'codex': ('nap', 'drift', 'yawn'), 'grok': ('nap', 'wander', 'gaze'), 'copilot': ('nap', 'look', 'hop'),+ 'antigravity': ('nap', 'look', 'bob')}+++def mood(used):+ """How the reading feels: 'worried' near the limit, 'happy' with plenty left (the store keeps 'worried' on until+ the reading drops below 85%, so it does not flicker at the edge)."""+ if used is None:+ return 'calm'+ return 'worried' if used >= 90 else 'happy' if used < 20 else 'calm'+++def scene_plan(row, now, span=FRAMES / FPS):+ """What a scene needs beyond the frame: the used % (Codex's garden, everyone's mood), the limit its picture+ follows, the pace of work, and this minute of rest (REST_FLOW): Clawd's move, or the others' two behaviours."""+ used = info(row, now)[0]+ wins = shown_windows(row, 3)+ plan = {'used': used, 'mood': 'worried' if row.get('worry') and used is not None else mood(used), 'moves': [],+ 'idle': ('nap', 'nap'),+ 'label': quota_period(wins[0]) if wins else ''}+ stamp = now if now is not None else time.time()+ plan['pace'] = max([item['value'] for item in row.get('news') or () if item.get('kind') == 'jump'+ and stamp - item.get('at', 0) < 600] or [0]) if 'news' in row else 3 # % per ten minutes+ five = next((w for w in row.get('windows', []) if w.get('label') == '5H'), None)+ if row['provider'] == 'claude' and five and five.get('used_percent') is not None:+ plan['moon'] = max(0, 100 - five['used_percent']) / 100 # what is left of the 5-hour window+ if row['provider'] == 'grok': # its job at work, fuelling or at the console, picked at random ten minutes at a time+ plan['role'] = row.get('role') or random.Random(f"{row.get('key')}|{int(stamp // 600)}").choice(('crew', 'control'))+ if row['provider'] == 'antigravity': # Anti's pellets: the 5 hours where there is such a window+ follow = five if five and five.get('used_percent') is not None else (wins[0] if wins else None)+ if follow and follow.get('used_percent') is not None:+ plan['anti'] = max(0, 100 - follow['used_percent']) / 100+ plan['anti_label'] = quota_period(follow)+ if row.get('showcase'): # a preview can ask for particular moves, to show each one+ named = row['showcase']+ if row['provider'] == 'claude':+ t = .5+ for move in named:+ name, first, last = IDLE_MOVES[move]+ length = (last - first + 1) / (12 * PACE)+ plan['moves'].append((t, t + length, name, first, last))+ t += length + .4+ else:+ plan['idle'] = (named[0], named[-1])+ elif row['provider'] == 'claude':+ plan['moves'] = idle_plan(row, now, span)+ elif row['provider'] in FLOW_MOVES:+ step, _ = rest_step(row['provider'], now)+ plan['idle'] = (FLOW_MOVES[row['provider']][step], 'nap') if step else ('nap', 'nap')+ if plan['mood'] == 'worried' and row['provider'] in IDLE_SETS: # nearly out: each frets its own way+ plan['idle'] = ('fret', 'fret') # (Clawd paces, in its own scene)+ return plan+++def idle_now(plan, f, span):+ """Which idle behaviour plays at frame `f`: the first half of the turn, then the second."""+ idle = plan.get('idle', ('nap', 'nap')) if isinstance(plan, dict) else ('nap', 'nap')+ return idle[0] if f < span / 2 else idle[1]+++NOTE_ROWS = ('..##', '..#.', '..#.', '###.', '##..')+++def mood_marks(draw, x, y, s, f, feeling, asleep=False):+ """Over a head at (x, y): sweat when the quota is nearly gone, a note now and then when it is fresh+ (not in its sleep: a napper shows only its z's)."""+ if feeling == 'worried':+ for k, side in enumerate((1, -1)):+ t = (f + k * 9) % 18+ if t < 10:+ sweat_drop(draw, round(x + side * (3 + t // 3) * s), round(y + t * s // 2), s)+ elif feeling == 'happy' and not asleep and f % 40 < 16:+ t = f % 40+ for yy, line in enumerate(NOTE_ROWS):+ for xx, key in enumerate(line):+ if key == '#':+ draw.rectangle((x + (xx + t // 4) * s, y - t * s // 2 + yy * s, x + (xx + t // 4) * s + s - 1,+ y - t * s // 2 + yy * s + s - 1), fill=(255, 226, 140))+++def shown_rows(snapshot, now=None):+ """The accounts Arcade takes turns on: the working ones, or every one while all are idle. Four at most share+ a loop; with more, the four move on with each round of the rest flow (six minutes), so every account gets its+ turns and each four rest through one look round and one stretch. A new four is a new picture for the clock,+ and the clock's animation holds while it takes one."""+ if not snapshot.get('accounts'):+ return overview_rows(snapshot) # placeholders+ order = list(PROVIDERS)+ every = [dict(row, key=key) for key, row in snapshot['accounts'].items()]+ every.sort(key=lambda row: order.index(row['provider']) if row['provider'] in order else len(order))+ pool = [row for row in every if row.get('active')] or every+ if len(pool) <= MAX_ROWS:+ return pool+ start = int((time.time() if now is None else now) // (60 * len(REST_FLOW))) * MAX_ROWS % len(pool)+ return [pool[(start + k) % len(pool)] for k in range(MAX_ROWS)]+++def egg_scene(egg, row):+ """The one-off that replaces `row`'s usual scene, as (scene, tier): an event ('reset@key' or+ 'full@key', common: every pet has them, often) or an opened hidden box (`lockbox.Box`) for this very+ account; else None."""+ if not egg or not row:+ return None+ if hasattr(egg, 'frames'): # a box from lockbox: its frames are already drawn, one per clock frame+ if row.get('key') != egg.key:+ return None+ play = lambda frame, draw, box, f, span, active, s, plan, **_: frame.paste(+ egg.frames[min(f // SPEED, len(egg.frames) - 1)], box[:2])+ return play, egg.tier+ kind, _, key = egg.partition('@')+ if row.get('key') != key or kind not in ('reset', 'full'):+ return None+ from token_tv import events+ scene = events.event_scene(kind, row['provider'], row.get('full_streak', 1))+ return (lambda frame, draw, box, f, span, active, s, plan, **_: scene(frame, draw, box, f, s, plan)), 'common'+++# A saved limit reset (Codex has them): a golden ticket in the header with how many are left; when the+# first one expires within three days it blinks and counts the days down instead.+TICKET = ('###########', '#######.###', '.#########.', '.######.##.', '.#########.', '#######.###', '###########')+GOLD, GOLD_DIM = (255, 200, 70), (110, 88, 40)+EXPIRING_DAYS = 3+++def reset_ticket(row, now):+ """(count, days left) for the saved resets `row` holds, days only when the first expires soon; or None."""+ credits = row.get('reset_credits') or {}+ if not credits.get('count'):+ return None+ at = credits.get('expires_at')+ left = (at - now) / 86400 if at else None+ return credits['count'], max(0, math.ceil(left)) if left is not None and left <= EXPIRING_DAYS else None+++def draw_ticket(draw, right, y, count, days, f):+ """The ticket and its count (or 'D-n', blinking) ending at `right`; returns the width it took."""+ text = str(count) if days is None else f'D-{days}'+ width = 2 * len(TICKET[0]) + 4 + (len(text) * 6 - 1) * 2+ on = True # steady: something that blinks all day wears on the eye+ for yy, line in enumerate(TICKET):+ for xx, key in enumerate(line):+ if key == '#':+ x0 = right - width + 2 * xx+ draw.rectangle((x0, y + 2 * yy, x0 + 1, y + 2 * yy + 1), fill=GOLD if on else GOLD_DIM)+ pixel_text(draw, (right, y), text, scale=2, color=GOLD if days is None else WARN, align='right')+ return width+++# A one-off's tier shows before the account name: rare a blue diamond, unique a purple one, legend a gold+# star, and a legend runs a rainbow round the stage as well.+BADGES = {'rare': ('...#...', '..###..', '.#####.', '#######', '.#####.', '..###..', '...#...'),+ 'unique': ('...#...', '..###..', '.#####.', '#######', '.#####.', '..###..', '...#...'),+ 'legend': ('...#...', '...#...', '#######', '.#####.', '..###..', '.##.##.', '#.....#')}+BADGE_INK = {'rare': (74, 163, 255), 'unique': (176, 124, 255), 'legend': (255, 197, 74)}+RAINBOW = ((255, 90, 82), (255, 167, 38), (255, 213, 79), (102, 187, 106), (66, 165, 245), (171, 71, 188))+++# A cut-in at the start of a unique or legend one-off: the whole screen bursts into light, rays shooting out+# from a point, brightest along the diagonal, then they thin away and the scene shows through. Meant to+# catch the eye of someone working next to the clock.+BURST = {'unique': ((176, 124, 255), (214, 166, 255), (242, 228, 255), (236, 226, 255)),+ 'legend': ((255, 170, 60), (255, 214, 107), (255, 244, 200), (255, 248, 230))} # rays..., the flash+BURST_FRAMES = {'unique': 14, 'legend': 20}+++def light_burst(draw, f, tier, night=False):+ """The cut-in: rays from the middle, a flash and a white core; at night only the coloured rays."""+ rays, flash = BURST[tier][:3], BURST[tier][3]+ n, cx, cy = BURST_FRAMES[tier], SIZE * .42, SIZE * .58+ grow = min(1, (f + 1) / 4) # the rays reach the edges in four frames+ thin = 1 if f < n * .55 else max(0, (n - f) / (n * .45)) # then thin away+ if 2 <= f < n * .5 and not night:+ draw.rectangle((0, 0, SIZE - 1, SIZE - 1), fill=flash)+ for i in range(18):+ angle = math.radians(i * 20 + f * 1.5 + (7 if i % 2 else 0))+ diagonal = abs(math.cos(angle - math.radians(-40))) # longer and wider toward the upper right and lower left+ length = SIZE * 1.6 * grow * (.45 + .55 * diagonal)+ width = math.radians((2 + 6 * diagonal) * thin)+ if width <= 0:+ continue+ tip = [(cx + math.cos(angle + side * width) * length, cy + math.sin(angle + side * width) * length) for side in (-1, 1)]+ draw.polygon([(cx, cy), *tip], fill=rays[i % len(rays)])+ core = round((10 + 26 * grow) * thin)+ if core > 0:+ draw.ellipse((cx - core, cy - core, cx + core, cy + core), fill=rays[2] if night else (255, 255, 255))+++def draw_badge(draw, x, y, tier, f):+ """The tier mark at (x, y), 14 px square; it twinkles now and then. Returns its width and a gap."""+ for yy, line in enumerate(BADGES[tier]):+ for xx, key in enumerate(line):+ if key == '#':+ tone = (255, 255, 255) if f % 24 < 2 and (xx + yy) % 3 == 0 else BADGE_INK[tier]+ draw.rectangle((x + 2 * xx, y + 2 * yy, x + 2 * xx + 1, y + 2 * yy + 1), fill=tone)+ return 18+++def rainbow_border(draw, top, bottom, f):+ """Coloured beads running round the stage edge."""+ edge = [(x, top) for x in range(0, 240, 4)] + [(236, y) for y in range(top, bottom, 4)] + \+ [(x, bottom - 4) for x in range(236, -1, -4)] + [(0, y) for y in range(bottom - 4, top - 1, -4)]+ for k, (x, y) in enumerate(edge):+ draw.rectangle((x, y, x + 3, y + 3), fill=RAINBOW[(k // 3 + f) % len(RAINBOW)])+++READOUT_TOP = 171 # the numbers and the bar, under the stage+NIGHT_HOURS, NIGHT_GLOW = (23, 0, 1, 2, 3, 4, 5), .7 # the stage dims to 70% from 11 pm to 6 am++# Where a one-off's prop is left, on the stage: (centre x, bottom), clear of each pet's usual ground.+PROP_SPOT = {'claude': (108, 60), 'codex': (96, 67), 'grok': (58, 62), 'copilot': (26, 68), 'antigravity': (92, 60)}++[email protected]_cache(maxsize=8)+def prop_art(png):+ return Image.open(io.BytesIO(base64.b64decode(png))).convert('RGBA')+++def leave_prop(stage, row):+ """The prop a unique or legend one-off left behind (row['trace_prop'], from live.py), standing in the scene."""+ try:+ art = prop_art(row['trace_prop'])+ except (OSError, ValueError):+ return+ cx, bottom = PROP_SPOT.get(row['provider'], (108, 66))+ stage.paste(art, (cx - art.width // 2, bottom - art.height), art)+++def scene_speed(row, eggy):+ """Scenes run at twice their pace, except Grok's jobs at work and Anti, which take the whole loop for one+ round."""+ if eggy:+ return SPEED+ if row['provider'] == 'antigravity':+ return 1 # Anti keeps the old arcade's own pace: a round of the maze in the whole loop+ return 1 if row['provider'] == 'grok' and row.get('active') else SPEED+++def arcade_frames(snapshot, now, egg=None):+ shown = shown_rows(snapshot, now)+ # a one-off plays for its own account even when that account is not among the rows the clock cycles through+ every = [dict(row, key=key) for key, row in snapshot.get('accounts', {}).items()]+ eggy = [row for row in every if egg_scene(egg, row)]+ if eggy: # an egg takes the whole loop+ shown = eggy[:1]+ starts = [k * FRAMES // len(shown) for k in range(len(shown))] + [FRAMES]+ plans = [scene_plan(row, now, (starts[k + 1] - starts[k]) / FPS) for k, row in enumerate(shown)]+ night = time.localtime(time.time() if now is None else now).tm_hour in NIGHT_HOURS+ frames, readouts = [], {}+ for f in range(FRAMES):+ index = max(k for k in range(len(shown)) if starts[k] <= f)+ row = shown[index]+ frame = Image.new('RGB', (SIZE, SIZE), PANEL)+ draw = ImageDraw.Draw(frame)+ used, period, old, left = info(row, now)+ oneoff = egg_scene(egg, row)+ scene, tier = oneoff if oneoff else (SCENES[row['provider']], None)+ # Every scene draws on its own half-size stage, then doubles: one 2 px grid for every sprite,+ # glyph and spark, and nothing spills over the header.+ stage = Image.new('RGB', (SIZE // 2, 71), PANEL)+ span = starts[index + 1] - starts[index]+ local = (f - starts[index]) * scene_speed(row, eggy)+ scene(stage, ImageDraw.Draw(stage), (0, 0, SIZE // 2, 71), local if eggy else local % span, span,+ bool(row.get('active')), 1, plans[index])+ if not oneoff and row.get('trace_prop'):+ leave_prop(stage, row)+ if night: # late at night the stage glows lower, so nothing flares in a dark room+ stage = ImageEnhance.Brightness(stage).enhance(NIGHT_GLOW)+ frame.paste(stage.resize((SIZE, 142), Image.Resampling.NEAREST), (0, 28))+ if tier == 'legend':+ rainbow_border(draw, 28, 170, f)+ both = len(shown_windows(row, 1)) == 2+ note = ('OLD' if old else '') if both else period + (' OLD' if old else '')+ room = 220 - ((len(note) * 6 - 1) * 2 + 8 if note else 0)+ pixel_text(draw, (230, 8), note, scale=2, color=WARN if old else MUTED, align='right')+ ticket = reset_ticket(row, time.time() if now is None else now)+ if ticket:+ room -= draw_ticket(draw, 230 - (220 - room), 8, *ticket, f) + 8+ label_x = 10 + (draw_badge(draw, 10, 8, tier, f) if tier in BADGES else 0) # while a one-off plays+ pixel_text(draw, (label_x, 8), fit_pixel(label_of(row), 2, room - (label_x - 10)), scale=2, color=TEXT)+ if index not in readouts: # the readout does not move: drawn once per account, pasted on every frame+ wins = shown_windows(row, 1)+ canvas = Image.new('RGB', (SIZE, SIZE), PANEL)+ if len(wins) == 2: # one account at a time has room for both windows: 5H above WEEK+ draw_readout(canvas, ImageDraw.Draw(canvas),+ [(p, u, l, o) for u, p, o, l in (info(row, now, value) for value in wins)])+ else:+ draw_readout(canvas, ImageDraw.Draw(canvas), [(period, used, left, old)])+ readouts[index] = canvas.crop((0, READOUT_TOP, SIZE, SIZE))+ frame.paste(readouts[index], (0, READOUT_TOP))+ if len(shown) > 1:+ for k in range(len(shown)):+ bx = 120 - len(shown) * 4 + k * 8+ draw.rectangle((bx, 175, bx + 3, 178), fill=TEXT if k == index else TRACK)+ if tier in BURST and getattr(egg, 'intro', True) and f < BURST_FRAMES[tier]:+ light_burst(draw, f, tier, night) # the cut-in over the whole screen+ frames.append(frame)+ return frames+++def encode(frames, scale=1):+ if scale != 1:+ frames = [f.resize((SIZE * scale, SIZE * scale), Image.Resampling.NEAREST) for f in frames]+ indexed = gif.indexed(frames, 'Arcade')+ # Every frame the same length: a mix of 80 and 90 ms read as a stutter on the clock.+ data = gif.encode(indexed, [FRAME_MS] * len(indexed))+ if len(data) > BUDGET and scale == 1: # a rare busy loop: every other frame, the same loop, still uploads+ data = gif.encode(indexed[::2], [2 * FRAME_MS] * len(indexed[::2]))+ return data+++def gif_seconds(image):+ """How long one loop of a GIF lasts."""+ loop = Image.open(io.BytesIO(image))+ total = 0+ for n in range(getattr(loop, 'n_frames', 1)):+ loop.seek(n)+ total += loop.info.get('duration', 0)+ return total / 1000+++def render_arcade(snapshot, now=None, scale=1, egg=None):+ return encode(arcade_frames(snapshot, now, egg), scale)diff --git a/token_tv/assets/README.md b/token_tv/assets/README.mdindex 1fb3e5c..d37fe1e 100644--- a/token_tv/assets/README.md+++ b/token_tv/assets/README.md@@ -17,3 +17,41 @@ The three requests preserve the reference silhouette, use a logical 32×32 pixelFinal Claude prompt:> Make this exact orange pixel crab into a crisp flat game UI sprite. Use only ONE opaque solid peach-orange color (#D9845E) and opaque black rectangular eyes. Identical stepped silhouette, two side arms and four short square legs. This is a flat 32 by 32 logical pixel sprite, enlarged with nearest-neighbor square pixels. Transparent empty canvas. Absolutely NO glow, NO light, NO smoke, NO shadows, NO texture, NO gradients, NO highlights, NO blur, NO scene or background, NO white outline. Center the icon with a little transparent margin. Preserve the original simple pixel geometry. Pure solid opaque fills and hard right-angle edges. Output just the sprite.++## Clawd's Quest poses++`clawd.json` holds ten of Clawd's animations from Clawd's Quest (https://claude.dev/game/, Anthropic),+copied as published in the game's `game.js` on 2026-10-28: Running, Jumping, LookingAround,+Swaying, Turning, DancingHappy, BreakDancing, Meditating, Waving, Thinking, and for the reset and full+events Excited, Disappointed and Dizzy. Each keeps the game's+encoding (a base grid of palette indexes plus per-frame changes in base 36) and its anchor box;+`token_tv/arcade.py` decodes them the way the game does. The Arcade and World faces use them.++## Grok mascot++`grok-pixel.png` keeps the generated black ball, with both eyes redrawn a third larger. Every full-colour face+draws Grok white with dark eyes; the single-colour faces tint it like the others.++## Codex mascot++`codex-pixel.png` keeps the generated Codex cloud's silhouette and colours, cleaned to seven tones, with its+face redrawn by hand as a two-pixel `>_` (after the Codex app icon).++## Copilot mascot++`copilot-pixel.png` is the owner's own pixel drawing after GitHub Copilot's goggled face: a pastel blue robot+head with ear pods, a dark visor and two glowing eyes. On the plane, where it is only 8 px tall, Arcade places+it by hand in the same colours.++## Antigravity mascot (Anti)++`antigravity-logo.png` holds the Antigravity logo's 12 × 10 blocks, one pixel each. Arcade draws Anti from+it at 2 × 2, adding a chin row under the mouth, a ghost's hem along the feet, bean eyes and a cat's mouth;+`antigravity-pixel.png` is that sprite for the dashboard. Anti's maze is drawn after the old arcade halls,+with none of their characters.++## Names and marks++Claude, Clawd and Clawd's Quest are Anthropic's; Codex is OpenAI's; Grok is xAI's; GitHub Copilot is+GitHub's; Antigravity and Gemini are Google's. TokenTV is an independent project, not affiliated with or+endorsed by any of them; the mascots are fan drawings that point at each service.diff --git a/token_tv/assets/antigravity-logo.png b/token_tv/assets/antigravity-logo.pngnew file mode 100644index 0000000..db531beBinary files /dev/null and b/token_tv/assets/antigravity-logo.png differdiff --git a/token_tv/assets/antigravity-pixel.png b/token_tv/assets/antigravity-pixel.pngnew file mode 100644index 0000000..ac2e651Binary files /dev/null and b/token_tv/assets/antigravity-pixel.png differdiff --git a/token_tv/assets/clawd.json b/token_tv/assets/clawd.jsonnew file mode 100644index 0000000..2e4e6ed--- /dev/null+++ b/token_tv/assets/clawd.json@@ -0,0 +1 @@+{"Running":{"w":25,"h":17,"palette":["#d97757","#bf694d","#000000"],"base":".............................0000000000000000.........0000000000000000.........0022000000002200.........0022000000002200.....000000000000000000000000.000000000000000000000000.000000000000000000000000.000000000000000000000000.....0000000000000000.........0000000000000000.........0000000000000000.........0000000000000000.........00..00....00..00.........00..00....00..00.........00..00....00..00.........00..00....00..00.....","deltas":["","","","t1,u1,v1,1i1,1j1,1k1,271,281,291,2a0,2c2,2d2,2j0,2k0,2l2,2m2,2w1,2x1,2y1,2z0,312,322,380,390,3a2,3b2,3h.,3i1,3j1,3k1,411,44.,46.,471,481,491,4q1,4t.,4v.,4w1,4x1,4y1,5f1,5i.,5k.,5l1,5m1,5n1,641,67.,6d1,6e1,6f1,721,731,741,7r1,7s1,7t1,8g1,8h1,8i1,8w0,951,961,9j.,9l0,9u1,9v1,a8.,aa0,aj1,ak1,ax.,az0,b81,b91,bc.,bd.,bm.,bn.","61,71,81,90,a0,b0,c0,d0,e0,f0,g0,h0,i0,j0,k0,l0,t.,u.,w1,x1,190,1a0,1i.,1j.,1l1,1m1,1p2,1q2,1y2,1z2,27.,28.,2a1,2b1,2c0,2d0,2e2,2f2,2l0,2m0,2n2,2o2,2v1,2y0,310,320,3a0,3b0,3c0,3d0,3e1,3f0,3g0,3i.,3j.,3l1,3m1,410,431,440,450,47.,48.,4a1,4b1,4q0,4s1,4t0,4u0,4w.,4x.,4z1,501,5f0,5h1,5i0,5j0,5l.,5m.,5n.,5o.,5p1,5q1,640,66.,6t0,7i0,8i.,8m.,8n.,8o.,8p.,8t.,8w.,941,980,9a.,9f.,9h0,9j0,9s1,9t1,9v.,9x0,9z.,a4.,a60,ah1,ai1,aj.,ak.,am0,ao.,at.,au.,b8.,b9.,bb0,bc0,bi.,bj.,bn0,bo0","201,210,220,2p1,2q0,2r0,2v.,2y1,3k.,3n1,49.,4c1,4s.,4t.,4u.,4y.,511,5h.,5i.,5j.,870,8q.,8t0,8u.,8w0,9g.,9i0,9j.,9s.,a5.,a70,ah.,aj1,av0,aw0,b71,b81,bb.,bc.,bk0,bl0,bn.,bo.","6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,k.,l.,1p0,1q0,1y0,1z0,20.,21.,22.,2p.,2q.,2r.,2w.,2x.,2z1,301,332,342,3c2,3d2,3k1,3n0,491,4c0,4s1,4t0,4u0,4y1,510,5h1,5i0,5j0,5n1,5o1,5q0,6c1,6f0,6u0,8f1,8i1,8m0,8q0,8u0,96.,98.,9a0,9g0,9i.,9j0,9l.,9x.,9z0,a50,a7.,a80,aa.,am.,ao0,au0,aw.,ax0,az.,b7.,b8.,bc0,bd0,bj0,bl.,bm0,bn0","2u1,2v1,2w1,2x0,2y0,2z0,300,3e.,3f.,3g.,3j1,3m0,43.,44.,45.,481,4b0,4u.,4x1,500,5j.,5n.,5o.,5q1,661,670,6c.,6f1,6v1,6w0,8f.,8n0,8o0,8p0,94.,961,9f0,9h.,9j.,9l0,9t.,9v1,a40,a6.,a8.,aa0,ai.,ak1,at0,av.,ax.,az0,b80,b91,bc.,bd.,bi0,bk.,bm.,bn.","60,71,81,90,a0,b0,c0,d0,e0,f0,g0,h0,i0,j0,k0,l0,1p2,1q2,1y2,1z2,2u.,2x1,330,340,3c0,3d0,3e1,3f0,3g0,3j.,3m1,431,440,450,48.,4b1,4u0,4x.,501,5j0,66.,67.,6u.,6v.,6w.,87.,8f1,8i.,8m.,8n.,8o.,8p.,8t.,8w.,941,980,9a.,9f.,9h0,9t1,9v.,9x0,9z.,a4.,a60,ai1,ak.,am0,ao.,at.,au.,b8.,b9.,bb0,bc0,bi.,bj.,bn0,bo0","61,2p1,2q0,2r0,2v.,2w.,2x.,2y1,2z1,301,5h.,5i.,5j.,5n1,5o1,5q0,6d.,870,8f.,8q.,8t0,8u.,8w0,96.,9g.,9i0,a5.,a70,av0,aw0,b71,b81,bb.,bc.,bk0,bl0,bn.,bo.","6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,k.,l.,1p0,1q0,1y0,1z0,2p.,2q.,2r.,332,342,3c2,3d2,3e.,3f.,3g.,3k.,3l.,3m.,3n1,3o1,3p1,481,4b0,4x1,500,5h1,5i0,5j0,5m1,5p0,661,670,680,6b1,6c1,6d1,6e0,6f0,6u0,72.,8f1,8i1,8m0,8n0,8o0,8p0,8q0,8u0,98.,9a0,9g0,9i.,9j0,9l.,9x.,9z0,a50,a7.,a80,aa.,am.,ao0,au0,aw.,ax0,az.,b7.,b8.,bc0,bd0,bj0,bl.,bm0,bn0","3j1,3k1,3l1,3m0,3n0,3o0,3p0,43.,44.,45.,4u.,5j.,68.,6b.,6c.,6d.,6e1,6f1,6v1,6w0,721,8f.,94.,961,9f0,9h.,9j.,9l0,9t.,9v1,a40,a6.,a8.,aa0,ai.,ak1,at0,av.,ax.,az0,b81,b91,bc.,bd.,bi0,bk.,bm.,bn.","61,71,81,90,a0,b0,c0,d0,e0,f0,g0,h0,i0,j0,k0,l0,1p2,1q2,1y2,1z2,2v1,2w1,2x1,2y0,2z0,300,330,340,3c0,3d0,3e1,3f0,3g0,3j.,3m1,431,440,450,48.,4b1,4u0,4x.,501,5j0,5m.,5n.,5o.,5p1,5q1,66.,67.,6d1,6u.,6v.,6w.,87.,8f1,8i.,8m.,8n.,8o.,8p.,8t.,8w.,941,980,9a.,9f.,9h0,9j0,9t1,9v.,9x0,9z.,a4.,a60,ai1,ak.,am0,ao.,at.,au.,b8.,b9.,bb0,bc0,bi.,bj.,bn0,bo0","2p1,2q0,2r0,2v.,2w.,2x.,2y1,2z1,301,5h.,5i.,5j.,5n1,5o1,5q0,6d.,870,8f.,8q.,8t0,8u.,8w0,9g.,9i0,9j.,a5.,a70,av0,aw0,b71,b81,bb.,bc.,bk0,bl0,bn.,bo.","6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,k.,l.,1p0,1q0,1y0,1z0,2p.,2q.,2r.,332,342,3c2,3d2,3e.,3f.,3g.,3j1,3m0,481,4b0,4x1,500,5h1,5i0,5j0,5m1,5p0,661,670,680,6u0,8f1,8i1,8m0,8q0,8u0,96.,98.,9a0,9g0,9i.,9j0,9l.,9x.,9z0,a50,a7.,a80,aa.,am.,ao0,au0,aw.,ax0,az.,b7.,b8.,bc0,bd0,bj0,bl.,bm0,bn0","2v1,2w1,2x1,2y0,2z0,300,3j.,3m1,43.,44.,45.,48.,4b1,4u.,4x.,501,5j.,5m.,5n.,5o.,5p1,5q1,68.,6v1,6w0,8f.,8n0,8o0,8p0,94.,961,9f0,9h.,9j.,9l0,9t.,9v1,a40,a6.,a8.,aa0,ai.,ak1,at0,av.,ax.,az0,b80,b91,bc.,bd.,bi0,bk.,bm.,bn.","60,71,81,90,a0,b0,c0,d0,e0,f0,g0,h0,i0,j0,k0,l0,1p2,1q2,1y2,1z2,2v.,2y1,330,340,3c0,3d0,3e1,3f0,3g0,3k.,3n1,431,440,450,49.,4c1,4u0,4y.,511,5j0,66.,67.,6u.,6v.,6w.,87.,8f1,8i.,8m.,8n.,8o.,8p.,8t.,8w.,941,980,9a.,9f.,9h0,9t1,9v.,9x0,9z.,a4.,a60,ai1,ak.,am0,ao.,at.,au.,b8.,b9.,bb0,bc0,bi.,bj.,bn0,bo0","61,2p1,2q0,2r0,2w.,2x.,2z1,301,3k1,3n0,491,4c0,4y1,510,5h.,5i.,5j.,5n1,5o1,5q0,6d1,870,8f.,8q.,8t0,8u.,8w0,96.,9g.,9i0,a5.,a70,av0,aw0,b71,b81,bb.,bc.,bk0,bl0,bn.,bo.","6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,k.,l.,1p0,1q0,1y0,1z0,2p.,2q.,2r.,332,342,3c2,3d2,3e.,3f.,3g.,3j1,3m0,481,4b0,4x1,500,5h1,5i0,5j0,5m1,5p0,661,670,680,6u0,8f1,8i1,8m0,8n0,8o0,8p0,8q0,8u0,98.,9a0,9g0,9i.,9j0,9l.,9x.,9z0,a50,a7.,a80,aa.,am.,ao0,au0,aw.,ax0,az.,b7.,b8.,bc0,bd0,bj0,bl.,bm0,bn0"],"a0":[0,1,24,16]},"Jumping":{"w":24,"h":30,"palette":["#141413","#be684d","#d97757"],"base":"....................................................................................................................................................................................................................................................................................................................................................2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","9g.,9h.,9i.,9j.,9k.,9l.,9m.,9n.,9o.,9p.,9q.,9r.,9s.,9t.,9u.,9v.,a4.,a5.,a6.,a7.,a8.,a9.,aa.,ab.,ac.,ad.,ae.,af.,ag.,ah.,ai.,aj.,au2,av2,b42,b52,bg1,bi2,bj2,bs2,bt2,c0.,c1.,c2.,c3.,ck.,cl.,cm.,cn.,co.,cp.,cq.,cr.,d8.,d9.,da.,db.,dc.,dd.,de.,df.,dw.,dx.,dy.,dz.,e0.,e1.,e2.,e3.,e60,e70,eg0,eh0,ek.,el.,em.,en.,eo2,ep2,eq2,er2,eu0,ev0,f40,f50,f82,f92,fa2,fb2,fc2,fd2,fe2,ff2,fw2,fx2,fy2,fz2,g02,g12,g22,g32,gk2,gl2,gm2,gn2,go2,gp2,gq2,gr2,h82,h92,ha2,hb2,hi2,hj2,hm2,hn2,ho2,hp2,hs2,ht2,i62,i72,ia2,ib2,ic2,id2,ig2,ih2,is1,it1,iw1,ix1,j21,j31,j61,j71","422,432,442,452,4i2,4j2,4k2,4l2,4q2,4r2,4s2,4t2,562,572,582,592,5e2,5f2,5g2,5h2,5i2,5j2,5k2,5l2,5m2,5n2,5o2,5p2,5q2,5r2,5s2,5t2,5u2,5v2,5w2,5x2,622,632,642,652,662,672,682,692,6a2,6b2,6c2,6d2,6e2,6f2,6g2,6h2,6i2,6j2,6k2,6l2,6s2,6t2,6u0,6v0,6w2,6x2,6y2,6z2,702,712,722,732,740,750,762,772,7g2,7h2,7i0,7j0,7k2,7l2,7m2,7n2,7o2,7p2,7q2,7r2,7s0,7t0,7u2,7v2,842,852,860,870,882,892,8a2,8b2,8c2,8d2,8e2,8f2,8g0,8h0,8i2,8j2,8s2,8t2,8u0,8v0,8w2,8x2,8y2,8z2,902,912,922,932,940,950,962,972,9g2,9h2,9i2,9j2,9k2,9l2,9m2,9n2,9o2,9p2,9q2,9r2,9s2,9t2,9u2,9v2,a42,a52,a62,a72,a82,a92,aa2,ab2,ac2,ad2,ae2,af2,ag2,ah2,ai2,aj2,bg2,e62,e72,eg2,eh2,eo.,ep.,eq.,er.,eu.,ev.,ey.,ez.,f0.,f1.,f4.,f5.,f8.,f9.,fa.,fb.,fc.,fd.,fe.,ff.,fi.,fj.,fm.,fn.,fo.,fp.,fs.,ft.,fw.,fx.,fy.,fz.,g0.,g1.,g2.,g3.,g6.,g7.,ga.,gb.,gc.,gd.,gg.,gh.,gk.,gl.,gm.,gn.,go.,gp.,gq.,gr.,gu.,gv.,gy.,gz.,h0.,h1.,h4.,h5.,h8.,h9.,ha.,hb.,hi.,hj.,hm.,hn.,ho.,hp.,hs.,ht.,i4.,i5.,i6.,i7.,i8.,i9.,ia.,ib.,ic.,id.,ie.,if.,ig.,ih.,ii.,ij.,is.,it.,iw.,ix.,j2.,j3.,j6.,j7.,jg.,jh.,jk.,jl.,jq.,jr.,ju.,jv.","t2,u2,v2,w2,132,142,152,162,1h2,1i2,1j2,1k2,1r2,1s2,1t2,1u2,252,262,272,282,2f2,2g2,2h2,2i2,2t2,2u2,2v2,2w2,332,342,352,362,3g2,3h2,3i2,3j2,3k2,3l2,3m2,3n2,3o2,3p2,3q2,3r2,3s2,3t2,3u2,3v2,42.,43.,462,472,482,492,4a2,4b2,4c2,4d2,4e2,4f2,4g2,4h2,4k.,4l.,4q.,4r.,4u0,4v0,4w2,4x2,4y2,4z2,502,512,522,532,540,550,58.,59.,5e.,5f.,5i0,5j0,5s0,5t0,5w.,5x.,62.,63.,6k.,6l.,6u2,6v2,742,752,7i2,7j2,7s2,7t2,862,872,8g2,8h2,8u2,8v2,942,952,bi.,bj.,bm.,bn.,bo.,bp.,bs.,bt.,c6.,c7.,ca.,cb.,cc.,cd.,cg.,ch.,cu.,cv.,cy.,cz.,d0.,d1.,d4.,d5.,di.,dj.,dm.,dn.,do.,dp.,ds.,dt.,e4.,e5.,e6.,e7.,e8.,e9.,ea.,eb.,ec.,ed.,ee.,ef.,eg.,eh.,ei.,ej.,es.,et.,ew.,ex.,f2.,f3.,f6.,f7.,fg.,fh.,fk.,fl.,fq.,fr.,fu.,fv.,g4.,g5.,g8.,g9.,ge.,gf.,gi.,gj.,gs.,gt.,gw.,gx.,h2.,h3.,h6.,h7.,hg.,hh.,hk.,hl.,hq.,hr.,hu.,hv.","62,72,82,92,e2,f2,g2,h2,t.,x2,122,16.,1h.,1l2,1q2,1u.,25.,292,2e2,2i.,2s2,2x2,2y2,2z2,302,312,322,372,460,470,4g0,4h0,5i2,5j2,5s2,5t2,au.,av.,ay.,az.,b0.,b1.,b4.,b5.,dg.,dh.,dk.,dl.,dq.,dr.,du.,dv.","52,9.,e.,i2,t2,x.,12.,162,1h2,1l.,1q.,1u2,252,29.,2e.,2i2","5.,92,e2,i.,t.,x2,122,16.,1h.,1l2,1q2,1u.,25.,292,2e2,2i.","6.,7.,8.,9.,e.,f.,g.,h.,t2,x.,12.,162,1h2,1l.,1q.,1u2,252,29.,2e.,2i2,2s.,2x.,2y.,2z.,30.,31.,32.,37.,462,472,4g2,4h2,5i0,5j0,5s0,5t0,au2,av2,ay2,az2,b02,b12,b42,b52,dg2,dh2,dk2,dl2,dq2,dr2,du2,dv2","","t.,u.,v.,w.,13.,14.,15.,16.,1h.,1i.,1j.,1k.,1r.,1s.,1t.,1u.,25.,26.,27.,28.,2f.,2g.,2h.,2i.,2t.,2u.,2v.,2w.,33.,34.,35.,36.,3f2,3j.,3k.,3l.,3m.,3n.,3o.,3p.,3q.,3r.,3s.,3w2,432,47.,48.,49.,4a.,4b.,4c.,4d.,4e.,4f.,4g.,4k2,4r2,4u2,4v.,4w.,4x.,4y.,4z.,50.,51.,52.,53.,54.,552,582,5f2,5i2,5j2,5s2,5t2,5w2,6u0,6v0,740,750,7i0,7j0,7s0,7t0,bi2,bj2,bm2,bn2,bo2,bp2,bs2,bt2,c62,c72,ca2,cb2,cc2,cd2,cg2,ch2,cu2,cv2,cy2,cz2,d02,d12,d42,d52,e42,e52,e82,e92,ee2,ef2,ei2,ej2,es2,et2,ew2,ex2,f22,f32,f62,f72,fg2,fh2,fk2,fl2,fq2,fr2,fu2,fv2","3f.,3g.,3h.,3i.,3t.,3u.,3v.,3w.,43.,44.,45.,46.,4h.,4i.,4j.,4k.,4r.,4s.,4t.,4u.,55.,56.,57.,58.,5f.,5g.,5h.,5i.,5j.,5k.,5l.,5m.,5n.,5o.,5p.,5q.,5r.,5s.,5t.,5u.,5v.,5w.,64.,65.,66.,67.,68.,69.,6a.,6b.,6c.,6d.,6e.,6f.,6g.,6h.,6i.,6j.,6s.,6t.,6u.,6v.,6w.,6x.,6y.,6z.,70.,71.,72.,73.,74.,75.,76.,77.,7i2,7j2,7s2,7t2,7v.,8u0,8v0,940,950,9i0,9j0,9s0,9t0,a60,a70,ag0,ah0,ao2,ap2,aq2,ar2,au0,av0,b40,b50,b82,b92,ba2,bb2,bc2,bd2,be2,bf2,bi0,bj0,bs0,bt0,bw2,bx2,by2,bz2,c02,c12,c22,c32,ck2,cl2,cm2,cn2,co2,cp2,cq2,cr2,d82,d92,da2,db2,dc2,dd2,de2,df2,di2,dj2,dm2,dn2,do2,dp2,ds2,dt2,dw2,dx2,dy2,dz2,e12,e22,e32,e62,e72,ea2,eb2,ec2,ed2,eg2,eh2,ek2,el2,em2,eq2,er2,eu2,ev2,ey2,ez2,f02,f12,f42,f52,f82,f92,fi2,fj2,fm2,fn2,fo2,fp2,fs2,ft2,g42,g52,g62,g72,g82,g92,ga2,gb2,gc2,gd2,ge2,gf2,gg2,gh2,gi2,gj2,gs2,gt2,gu2,gv2,gw2,gx2,gy2,gz2,h02,h12,h22,h32,h42,h52,h62,h72,hf2,hg2,hh2,hj2,hk2,hl2,hm2,hq2,hr2,hs2,hu2,hv2,hw2,i32,i42,i72,i82,if2,ig2,ij2,ik2,ir2,is2,it2,iv2,iw2,ix2,j22,j32,j42,j62,j72,j82,jg2,jh2,jk2,jl2,jq2,jr2,ju2,jv2","7g.,7h.,7i.,7j.,7k.,7l.,7m.,7n.,7o.,7p.,7q.,7r.,7s.,7t.,7u.,84.,85.,86.,87.,88.,89.,8a.,8b.,8c.,8d.,8e.,8f.,8g.,8h.,8i.,8j.,8s.,8t.,8u.,8v.,8w.,8x.,8y.,8z.,90.,91.,92.,93.,94.,95.,96.,97.,9g.,9h.,9i.,9j.,9k.,9l.,9m.,9n.,9o.,9p.,9q.,9r.,9s.,9t.,9u.,9v.,a62,a72,ag2,ah2,ao.,ap.,aq.,ar.,au2,av2,b42,b52,b8.,b9.,ba.,bb.,bc.,bd.,be.,bf.,bw.,bx.,by.,bz.,c0.,c1.,c2.,c3.,c60,c70,cg0,ch0,ck.,cl.,cm.,cn.,co.,cp.,cq.,cr.,cu0,cv0,d40,d50,d8.,d9.,da.,db.,dc.,dd.,de.,df.,dw.,dx.,dy.,dz.,e02,en2,eo2,ep2,fa2,fb2,fc2,fd2,fe2,ff2,fw2,fx2,fy2,fz2,g02,g12,g22,g32,gk2,gl2,gm2,gn2,hi2,hn2,ho2,hp2,ht2,i92,ia2,ib2,ic2,id2,ie2","8s2,8t2,8u2,8v2,8w2,8x2,8y2,8z2,902,912,922,932,942,952,962,972,9g2,9h2,9i2,9j2,9k2,9l2,9m2,9n2,9o2,9p2,9q2,9r2,9s2,9t2,9u2,9v2,a60,a70,ag0,ah0,au0,av0,b40,b50,bi2,bj2,bs2,bt2,c62,c72,cg2,ch2,cu2,cv2,d42,d52,gu.,gv.,gy.,gz.,h0.,h1.,h4.,h5.,hf.,hi.,hj.,hm.,hn.,ho.,hp.,hs.,ht.,hw.,i3.,i52,i7.,ia.,ib.,ic.,id.,ig.,ii2,ik.,ir.,iv.,j4.,j8.","8s.,8t.,8u.,8v.,8w.,8x.,8y.,8z.,90.,91.,92.,93.,94.,95.,96.,97.,a62,a72,ag2,ah2,bi0,bj0,bs0,bt0,c02,c12,c22,c32,ck2,cl2,cm2,cn2,co2,cp2,cq2,cr2,d82,d92,da2,db2,dc2,dd2,de2,df2,dw2,dx2,dy2,dz2,eo.,ep.,eq.,er.,f8.,f9.,fa.,fb.,fc.,fd.,fe.,ff.,fw.,fx.,fy.,fz.,g0.,g1.,g2.,g3.,gk.,gl.,gm.,gn.,gu2,gv2,gy2,gz2,h02,h12,h42,h52","","","",""],"a0":[0,14,24,16]},"LookingAround":{"w":24,"h":16,"palette":["#141413","#be684d","#d97757"],"base":"....2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","","","41,51,s1,t1,1g1,1h1,1i2,1j2,1k0,1l0,1s2,1t2,1u0,1v0,241,251,262,272,280,290,2g2,2h2,2i0,2j0,2o1,2p1,381,3a.,3b.,3c1,3d1,3w1,3y.,3z.,401,411,4k1,4m.,4n.,4o1,4p1,581,5a.,5b.,5g1,5h1,641,651,6s1,6t1,7g1,7h1,841,851,8s1,8t1,9g1,9h1,a41,a51","42,52,j.,r1,s2,t2,v0,w0,150,160,1f1,1g2,1h2,1j0,1l2,1t0,1v2,231,242,252,282,292,2i2,2j2,2o.,2p.,2q.,2r1,38.,39.,3d2,3y2,412,4m2,4p2,5a2,5c1,5d2,5e2,5f2,5g2,5h2,5w1,5x2,5y2,652,6t2,7h2,852,8t2,9h2,a52","4.,r.,u0,w2,140,162,1f.,1i0,1k2,1s0,1u2,23.,2r.,3c2,3w2,3z2,402,4k2,4n2,4o2,582,5b2,5c2,5w2,5z2,642,6s2,7g2,842,8s2,9g2,a42","t0,v2,130,152,171,1h0,1j2,1r0,1t2,1v1,2j1,371,3c.,3f1,3z1,40.,431,4n1,4o.,4r1,5b1,5c.,5f1,5z1,6j1,771,7v1,8j1,971,9v1,aj1","42,i1,j1,t2,u2,132,142,161,1g0,1i2,1q0,1s2,1u1,240,250,2e0,2f0,2i1,2q2,2r1,372,382,392,3a1,3b1,3d.,3y1,41.,4m1,4p.,5a1,5d.,5e.,5f.,5u1,5v1,5w.,5x.,5y.,5z.,6i1,761,7u1,8i1,961,9u1,ai1","1g2,1h2,1q2,1r2,2s0,2t0,320,330","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,r2,17.,1f2,1v.,212,221,232,242,252,2e2,2f2,2i2,2j2,2k2,2l2,2m1,2p2,2q1,2r2,2s2,2t2,322,332,3b.,3d2,3e1,3f2,3g0,3h0,3q0,3r0,3z.,412,440,450,4e0,4f0,4n.,4q.,4r.,571,58.,59.,5a.,5b.,5u2,6i2,762,7u2,862,872,8a2,8b2,8c2,8d2,8g2,8h2,8i2,8s1,8t1,8w1,8x1,921,931,9u2,ai2","r.,162,172,1f.,1u2,1v2,202,222,2m2,2n2,2o2,2q2,3a2,3b2,3c2,3e2,3g2,3h2,3i0,3j0,3q2,3r2,3s0,3t0,3y2,3z2,402,432,442,452,460,470,4e2,4f2,4g0,4h0,4m2,4n2,572,5v2,6j2,772,7v2,8j2,9v2,aj2","s.,t1,182,1g.,1h1,1w2,20.,211,2l1,2n.,2o.,2p1,391,3b.,3c.,3d1,3i2,3j2,3k0,3l0,3s2,3t2,3u0,3v0,3x1,3z.,40.,411,462,472,480,490,4g2,4h2,4i0,4j0,4k1,4n.,4s1,5g1,641,6s1,7g1,841,9g1,a41","41,51,62,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,s1,18.,1g1,1w.,21.,22.,23.,241,251,280,290,2i0,2j0,2k.,2l.,2m.,2o1,2w0,2x0,360,370,381,392,3a.,3c1,3k2,3l2,3u2,3v2,3w1,3x2,3y.,401,482,492,4i2,4j2,4m.,4o1,4p1,4q2,4r2,4s2,581,592,5h1,651,6t1,7h1,851,86.,87.,8a.,8b.,8c.,8d.,8g.,8h.,8w2,8x2,922,932,962,972,9h1,a51","1k0,1l0,1u0,1v0,2w2,2x2,362,372","42,52,j.,r1,s2,t2,v0,w0,150,160,1f1,1g2,1h2,1j0,1l2,1t0,1v2,231,242,252,282,292,2i2,2j2,2o.,2p.,2q.,2r1,38.,39.,3d2,3y2,412,4m2,4p2,5a2,5c1,5d2,5e2,5f2,5g2,5h2,5w1,5x2,5y2,652,6t2,7h2,852,8t2,9h2,a52","4.,r.,u0,w2,140,162,1f.,1i0,1k2,1s0,1u2,23.,2r.,3c2,3w2,3z2,402,4k2,4n2,4o2,582,5b2,5c2,5w2,5z2,642,6s2,7g2,842,8s2,9g2,a42","t0,v2,130,152,171,1h0,1j2,1r0,1t2,1v1,2j1,371,3c.,3f1,3z1,40.,431,4n1,4o.,4r1,5b1,5c.,5f1,5z1,6j1,771,7v1,8j1,971,9v1,aj1","42,i1,j1,t2,u2,132,142,161,1g0,1i2,1q0,1s2,1u1,240,250,2e0,2f0,2i1,2q2,2r1,372,382,392,3a1,3b1,3d.,3y1,41.,4m1,4p.,5a1,5d.,5e.,5f.,5u1,5v1,5w.,5x.,5y.,5z.,6i1,761,7u1,8i1,961,9u1,ai1","1g2,1h2,1q2,1r2,2s0,2t0,320,330","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,r2,17.,1f2,1v.,212,221,232,242,252,2e2,2f2,2i2,2j2,2k2,2l2,2m1,2p2,2q1,2r2,2s2,2t2,322,332,3b.,3d2,3e1,3f2,3g0,3h0,3q0,3r0,3z.,412,440,450,4e0,4f0,4n.,4q.,4r.,571,58.,59.,5a.,5b.,5u2,6i2,762,7u2,862,872,8a2,8b2,8c2,8d2,8g2,8h2,8i2,8s1,8t1,8w1,8x1,921,931,9u2,ai2","r.,162,172,1f.,1u2,1v2,202,222,2m2,2n2,2o2,2q2,3a2,3b2,3c2,3e2,3g2,3h2,3i0,3j0,3q2,3r2,3s0,3t0,3y2,3z2,402,432,442,452,460,470,4e2,4f2,4g0,4h0,4m2,4n2,572,5v2,6j2,772,7v2,8j2,9v2,aj2","s.,t1,182,1g.,1h1,1w2,20.,211,2l1,2n.,2o.,2p1,391,3b.,3c.,3d1,3i2,3j2,3k0,3l0,3s2,3t2,3u0,3v0,3x1,3z.,40.,411,462,472,480,490,4g2,4h2,4i0,4j0,4k1,4n.,4s1,5g1,641,6s1,7g1,841,9g1,a41","41,51,62,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,s1,18.,1g1,1w.,21.,22.,23.,241,251,280,290,2i0,2j0,2k.,2l.,2m.,2o1,2w0,2x0,360,370,381,392,3a.,3c1,3k2,3l2,3u2,3v2,3w1,3x2,3y.,401,482,492,4i2,4j2,4m.,4o1,4p1,4q2,4r2,4s2,581,592,5h1,651,6t1,7h1,851,86.,87.,8a.,8b.,8c.,8d.,8g.,8h.,8w2,8x2,922,932,962,972,9h1,a51","1k0,1l0,1u0,1v0,2w2,2x2,362,372","42,52,s2,t2,1g2,1h2,1i0,1j0,1k2,1l2,1s0,1t0,1u2,1v2,242,252,260,270,282,292,2g0,2h0,2i2,2j2,2o2,2p2,382,3a2,3b2,3c2,3d2,3w2,3y2,3z2,402,412,4k2,4m2,4n2,4o2,4p2,582,5a2,5b2,5g2,5h2,642,652,6s2,6t2,7g2,7h2,842,852,8s2,8t2,9g2,9h2,a42,a52","","",""],"a0":[0,0,24,16]},"Swaying":{"w":28,"h":17,"palette":["#141413","#d97757"],"base":"..................................1111111111111111............1111111111111111............1100111111110011............1100111111110011........111111111111111111111111....111111111111111111111111....111111111111111111111111....111111111111111111111111........1111111111111111............1111111111111111............1111111111111111............1111111111111111............11..11....11..11............11..11....11..11............11..11....11..11............11..11....11..11......","deltas":["","","","","","y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,1a.,1b.,1c.,1d.,2k1,2l1,2u1,2v1,3y.,3z.,40.,41.,440,450,4e0,4f0,4i.,4j.,4k.,4l.,4q.,4r.,4s.,4t.,5a.,5b.,5c.,5d.,5i.,5j.,5k.,5l.,62.,63.,64.,65.,721,731,741,751,7m1,7n1,7o1,7p1,7u1,7v1,7w1,7x1,8e1,8f1,8g1,8h1,8m1,8n1,8o1,8p1,961,971,981,991,a91,ac1,ad1,ag1,ah1,ai1,aj1,am1,an1,aq1,b11,b3.,b51,b81,b91,ba1,bb1,be1,bg.,bi1,bt1,bx1,c61,ca1","","d1,e1,f1,g1,h1,i1,j1,k1,x1,y1,z1,101,111,121,131,141,151,161,171,181,191,1a1,1b1,1c1,1p1,210,220,25.,2h1,2j0,2k0,2t0,2u0,2y1,2z1,301,391,3b0,3d1,3m1,3n1,3q1,3r1,3s1,411,441,451,4e1,4f1,4i1,4j1,4k1,4p1,4q1,4r1,4s1,4t1,5a1,5b1,5c1,5h1,5i1,5j1,5k1,5l1,61.,691,6t.,6u.,6v.,6w.,6x.,711,7l.,7m.,7n.,7o.,7p.,7u.,7v.,7w.,8d.,8e.,8f.,8g.,8h.,8m.,8n.,8o.,8p.,96.,97.,98.,99.,9u.,9v.,a9.,ac.,ad.,ag.,ah.,ai.,aj.,am.,an.,b1.,b31,b5.,b8.,b9.,ba.,bb.,be.,bt.,bx.,c6.,c8.,d0.,d1.","","c1,k.,w1,1c.,1o1,200,221,251,261,271,2g1,2i0,2k1,2s0,2u1,30.,381,3a0,3c1,3s.,401,4k.,4p.,4q.,4r.,58.,59.,5a.,5b.,5c.,5g1,60.,681,6s.,701,7s1,7t1,7u1,7v1,7w1,8d1,8p1,9h1,9t.,9y1,a91,ab.,ad1,af.,aj1,al.,ao.,b11,b51,bb1,c9.,ca.","","","c.,k1,w.,1c1,1o.,201,220,25.,26.,27.,2g.,2i1,2k0,2s1,2u0,301,38.,3a1,3c0,3s1,40.,4k1,4p1,4q1,4r1,581,591,5a1,5b1,5c1,5g.,601,68.,6s1,70.,7s.,7t.,7u.,7v.,7w.,8d.,8p.,9h.,9t1,9y.,a9.,ab1,ad.,af1,aj.,al1,ao1,b1.,b5.,bb.,c91,ca1","","d.,e.,f.,g.,h.,i.,j.,k.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,1a.,1b.,1c.,1p.,211,221,251,2h.,2j1,2k1,2t1,2u1,2y.,2z.,30.,39.,3b1,3d0,3m0,3n0,3q.,3r.,3s.,41.,440,450,4e0,4f0,4i.,4j.,4k.,4p.,4q.,4r.,4s.,4t.,5a.,5b.,5c.,5h.,5i.,5j.,5k.,5l.,611,69.,6t1,6u1,6v1,6w1,6x1,71.,7l1,7m1,7n1,7o1,7p1,7u1,7v1,7w1,8d1,8e1,8f1,8g1,8h1,8m1,8n1,8o1,8p1,961,971,981,991,9u1,9v1,a91,ac1,ad1,ag1,ah1,ai1,aj1,am1,an1,b11,b3.,b51,b81,b91,ba1,bb1,be1,bt1,bx1,c61,c81,d01,d11","","71,81,91,a1,b1,c1,d1,e1,z1,101,111,121,131,141,151,161,171,181,191,1a1,1b1,1c1,1d1,1e1,1q.,1t0,1u0,261,2f1,2g1,2h1,2l0,2m0,2v0,2w0,2y1,371,381,391,3c1,3d1,3m1,3o0,3q1,3z1,401,411,441,451,4e1,4f1,4i1,4r1,4s1,4t1,5a1,5b1,5c1,5d1,5e1,5m.,621,631,641,651,661,6a.,6b.,6c.,6d.,6e.,6y1,72.,73.,74.,75.,76.,7q1,7u.,7v.,7w.,7x.,7y.,8f.,8g.,8h.,8m.,8n.,8o.,8p.,96.,97.,98.,99.,9k.,9l.,ac.,ad.,ag.,ah.,ai.,aj.,am.,an.,aq.,b5.,b8.,b9.,ba.,bb.,be.,bg1,bi.,bv.,bx.,c6.,ca.,cm.,cn.","","7.,f1,z.,1f1,1o1,1p1,1q1,1t1,1v0,271,2f.,2l1,2n0,2v1,2x0,2z1,37.,3n1,3p0,3r1,3z.,4j1,4r.,4s.,4t.,4u.,4v.,5c.,5d.,5e.,5n.,671,6f.,6z1,7r1,7y1,8f1,8g1,8h1,8i1,8j1,961,9h1,9m.,9y1,ab.,ae.,ag1,ak.,am1,ao.,aq1,b81,be1,bi1,bt.,bu.","","","71,f.,z1,1f.,1o.,1p.,1q.,1t0,1v1,27.,2f1,2l0,2n1,2v0,2x1,2z.,371,3n0,3p1,3r.,3z1,4j.,4r1,4s1,4t1,4u1,4v1,5c1,5d1,5e1,5n1,67.,6f1,6z.,7r.,7y.,8f.,8g.,8h.,8i.,8j.,96.,9h.,9m1,9y.,ab1,ae1,ag.,ak1,am.,ao1,aq.,b8.,be.,bi.,bt1,bu1","","7.,8.,9.,a.,b.,c.,d.,e.,z.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,1a.,1b.,1c.,1d.,1e.,1q1,1t1,1u1,26.,2f.,2g.,2h.,2l1,2m1,2v1,2w1,2y.,37.,38.,39.,3c0,3d0,3m0,3o1,3q.,3z.,40.,41.,440,450,4e0,4f0,4i.,4r.,4s.,4t.,5a.,5b.,5c.,5d.,5e.,5m1,62.,63.,64.,65.,66.,6a1,6b1,6c1,6d1,6e1,6y.,721,731,741,751,761,7q.,7u1,7v1,7w1,7x1,7y1,8f1,8g1,8h1,8m1,8n1,8o1,8p1,961,971,981,991,9k1,9l1,ac1,ad1,ag1,ah1,ai1,aj1,am1,an1,aq1,b51,b81,b91,ba1,bb1,be1,bg.,bi1,bv1,bx1,c61,ca1,cm1,cn1","","d1,e1,f1,g1,h1,i1,j1,k1,x1,y1,z1,101,111,121,131,141,151,161,171,181,191,1a1,1b1,1c1,1p1,210,220,25.,2h1,2j0,2k0,2t0,2u0,2y1,2z1,301,391,3b0,3d1,3m1,3n1,3q1,3r1,3s1,411,441,451,4e1,4f1,4i1,4j1,4k1,4p1,4q1,4r1,4s1,4t1,5a1,5b1,5c1,5h1,5i1,5j1,5k1,5l1,61.,691,6t.,6u.,6v.,6w.,6x.,711,7l.,7m.,7n.,7o.,7p.,7u.,7v.,7w.,8d.,8e.,8f.,8g.,8h.,8m.,8n.,8o.,8p.,96.,97.,98.,99.,9u.,9v.,a9.,ac.,ad.,ag.,ah.,ai.,aj.,am.,an.,b1.,b31,b5.,b8.,b9.,ba.,bb.,be.,bt.,bx.,c6.,c8.,d0.,d1.","","c1,k.,w1,1c.,1o1,200,221,251,261,271,2g1,2i0,2k1,2s0,2u1,30.,381,3a0,3c1,3s.,401,4k.,4p.,4q.,4r.,58.,59.,5a.,5b.,5c.,5g1,60.,681,6s.,701,7s1,7t1,7u1,7v1,7w1,8d1,8p1,9h1,9t.,9y1,a91,ab.,ad1,af.,aj1,al.,ao.,b11,b51,bb1,c9.,ca.","","","c.,k1,w.,1c1,1o.,201,220,25.,26.,27.,2g.,2i1,2k0,2s1,2u0,301,38.,3a1,3c0,3s1,40.,4k1,4p1,4q1,4r1,581,591,5a1,5b1,5c1,5g.,601,68.,6s1,70.,7s.,7t.,7u.,7v.,7w.,8d.,8p.,9h.,9t1,9y.,a9.,ab1,ad.,af1,aj.,al1,ao1,b1.,b5.,bb.,c91,ca1","","d.,e.,f.,g.,h.,i.,j.,k.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,1a.,1b.,1c.,1p.,211,221,251,2h.,2j1,2k1,2t1,2u1,2y.,2z.,30.,39.,3b1,3d0,3m0,3n0,3q.,3r.,3s.,41.,440,450,4e0,4f0,4i.,4j.,4k.,4p.,4q.,4r.,4s.,4t.,5a.,5b.,5c.,5h.,5i.,5j.,5k.,5l.,611,69.,6t1,6u1,6v1,6w1,6x1,71.,7l1,7m1,7n1,7o1,7p1,7u1,7v1,7w1,8d1,8e1,8f1,8g1,8h1,8m1,8n1,8o1,8p1,961,971,981,991,9u1,9v1,a91,ac1,ad1,ag1,ah1,ai1,aj1,am1,an1,b11,b3.,b51,b81,b91,ba1,bb1,be1,bt1,bx1,c61,c81,d01,d11","","71,81,91,a1,b1,c1,d1,e1,z1,101,111,121,131,141,151,161,171,181,191,1a1,1b1,1c1,1d1,1e1,1q.,1t0,1u0,261,2f1,2g1,2h1,2l0,2m0,2v0,2w0,2y1,371,381,391,3c1,3d1,3m1,3o0,3q1,3z1,401,411,441,451,4e1,4f1,4i1,4r1,4s1,4t1,5a1,5b1,5c1,5d1,5e1,5m.,621,631,641,651,661,6a.,6b.,6c.,6d.,6e.,6y1,72.,73.,74.,75.,76.,7q1,7u.,7v.,7w.,7x.,7y.,8f.,8g.,8h.,8m.,8n.,8o.,8p.,96.,97.,98.,99.,9k.,9l.,ac.,ad.,ag.,ah.,ai.,aj.,am.,an.,aq.,b5.,b8.,b9.,ba.,bb.,be.,bg1,bi.,bv.,bx.,c6.,ca.,cm.,cn.","","7.,f1,z.,1f1,1o1,1p1,1q1,1t1,1v0,271,2f.,2l1,2n0,2v1,2x0,2z1,37.,3n1,3p0,3r1,3z.,4j1,4r.,4s.,4t.,4u.,4v.,5c.,5d.,5e.,5n.,671,6f.,6z1,7r1,7y1,8f1,8g1,8h1,8i1,8j1,961,9h1,9m.,9y1,ab.,ae.,ag1,ak.,am1,ao.,aq1,b81,be1,bi1,bt.,bu.","","","71,f.,z1,1f.,1o.,1p.,1q.,1t0,1v1,27.,2f1,2l0,2n1,2v0,2x1,2z.,371,3n0,3p1,3r.,3z1,4j.,4r1,4s1,4t1,4u1,4v1,5c1,5d1,5e1,5n1,67.,6f1,6z.,7r.,7y.,8f.,8g.,8h.,8i.,8j.,96.,9h.,9m1,9y.,ab1,ae1,ag.,ak1,am.,ao1,aq.,b8.,be.,bi.,bt1,bu1","","7.,8.,9.,a.,b.,c.,d.,e.,z.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,1a.,1b.,1c.,1d.,1e.,1q1,1t1,1u1,26.,2f.,2g.,2h.,2l1,2m1,2v1,2w1,2y.,37.,38.,39.,3c0,3d0,3m0,3o1,3q.,3z.,40.,41.,440,450,4e0,4f0,4i.,4r.,4s.,4t.,5a.,5b.,5c.,5d.,5e.,5m1,62.,63.,64.,65.,66.,6a1,6b1,6c1,6d1,6e1,6y.,721,731,741,751,761,7q.,7u1,7v1,7w1,7x1,7y1,8f1,8g1,8h1,8m1,8n1,8o1,8p1,961,971,981,991,9k1,9l1,ac1,ad1,ag1,ah1,ai1,aj1,am1,an1,aq1,b51,b81,b91,ba1,bb1,be1,bg.,bi1,bv1,bx1,c61,ca1,cm1,cn1","","y1,z1,101,111,121,131,141,151,161,171,181,191,1a1,1b1,1c1,1d1,2k0,2l0,2u0,2v0,3y1,3z1,401,411,441,451,4e1,4f1,4i1,4j1,4k1,4l1,4q1,4r1,4s1,4t1,5a1,5b1,5c1,5d1,5i1,5j1,5k1,5l1,621,631,641,651,72.,73.,74.,75.,7m.,7n.,7o.,7p.,7u.,7v.,7w.,7x.,8e.,8f.,8g.,8h.,8m.,8n.,8o.,8p.,96.,97.,98.,99.,a9.,ac.,ad.,ag.,ah.,ai.,aj.,am.,an.,aq.,b1.,b31,b5.,b8.,b9.,ba.,bb.,be.,bg1,bi.,bt.,bx.,c6.,ca.","","","",""],"a0":[2,1,24,16]},"Turning":{"w":24,"h":17,"palette":["#141413","#be684d","#d97757"],"base":"............................2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,262,272,2g2,2h2,2u2,2v2,342,352,3c.,3d.,3e.,3f.,3i0,3j0,3k0,3r0,3s0,3t0,3w.,3x.,3y.,3z.,602,612,622,632,6k2,6l2,6m2,6n2,8u2,8v2,8y2,8z2,902,912,942,952","41,51,61,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,s1,t1,u1,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,1g1,1h1,1i1,1l0,1m0,1t0,1u0,241,251,261,290,2a0,2h0,2i0,2o1,2p1,2q1,2r2,382,392,3a2,3c1,3d1,3e1,3f2,3i2,3j2,3k2,3r2,3s2,3t2,3w2,3x2,3y2,401,411,421,4n.,4o1,4p1,4q1,5b.,5c.,5d.,5e.,5f.,5g1,5h1,5i1,5w.,5x.,5y.,5z.,60.,61.,62.,63.,641,651,661,6k.,6l.,6m.,6n.,6s1,6t1,6u1,7g1,7h1,7i1,841,851,861,8s1,8t1,8u.,8v.,8w.,8z.,90.,93.,94.,95.,9g1,9h1,9i1,9k.,9m2,9p2,9r.,9t2,a4.,a51,a61,a8.,aa2,ad2,af.,ah2,aj.,as.,at.,aw.,ay2,b12,b3.,b6.,b7.","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,1l2,1m2,1t2,1u2,2o.,2p.,2q.,2r.,2s1,2t1,2u1,2x0,2y0,350,360,38.,39.,3a.,5c1,5d1,5e1,5f2,5g2,5h2,5i2,5w2,5x2,5y2,8s.,8u1,952,97.,9g.,9v.,at1,au1,b52,b62","","","","","","","","","","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1g2,1h2,1i2,242,252,262,292,2a2,2h2,2i2,2s2,2t2,2u2,2x2,2y2,352,362,3c.,3d.,3e.,3f.,3i0,3j0,3k0,3r0,3s0,3t0,3w.,3x.,3y.,402,412,422,4n2,4o2,4p2,4q2,5b2,5c2,5d2,5e2,5z2,602,612,622,632,642,652,662,6k2,6l2,6m2,6n2,6s2,6t2,6u2,7g2,7h2,7i2,842,852,862,8s2,8t2,8u2,8v2,8w2,8z2,902,932,942,972,9g2,9h2,9i.,9k2,9m.,9p.,9r2,9t.,9v2,a42,a52,a6.,a82,aa.,ad.,af2,ah.,aj2,as2,at2,au.,aw2,ay.,b1.,b32,b5.,b72","32,42,52,62,72,82,92,a2,b2,c2,d2,e2,f2,g1,h1,i1,r2,s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,141,151,161,1f2,1g0,1h0,1o0,1p0,1s1,1t1,1u1,1v.,232,240,250,2c0,2d0,2g1,2h1,2i1,2j.,2o2,2p2,2q2,2r2,381,391,3a1,3c2,3d2,3e2,3f2,3i2,3j2,3k2,3r2,3s2,3t2,3w1,3x1,3y1,4k1,4l1,4m1,4n.,581,591,5a1,5b.,5c.,5d.,5e.,5s1,5t1,5u1,5v.,5w.,5x.,5y.,5z.,60.,61.,62.,6g1,6h1,6i1,6j.,6k.,6l.,6m.,6n.,6r2,741,751,761,77.,7f2,7s1,7t1,7u1,7v.,832,8g1,8h1,8i1,8j.,8r2,8t.,8u.,8v.,8y.,8z.,92.,93.,94.,951,961,97.,9f2,9o2,9p2,9q.,9r.,9s1,9t1,9u1,9v.,ac2,ad2,ae.,af.,ag1,ah1,ai.,aj.,as.,at.,b02,b12,b2.,b3.,b6.,b7.","3.,4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,1g2,1h2,1o2,1p2,2o.,2p.,2q.,2s0,2t0,300,310,341,351,361,37.,38.,39.,3a.,5c2,5d2,5e2,5s2,5t2,5u2,5v2,5w1,5x1,5y1,8r.,8t2,941,96.,9f.,9u.,as2,at2,b41,b51","","","","","","","","","","r.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,1f.,1s2,1t2,1u2,1v2,23.,242,252,2c2,2d2,2g2,2h2,2i2,2j2,2r.,2s2,2t2,302,312,342,352,362,372,3c.,3d.,3e.,3f.,3i0,3j0,3k0,3r0,3s0,3t0,3w.,3x.,3y.,4k2,4l2,4m2,4n2,582,592,5a2,5b2,5w2,5x2,5y2,5z2,602,612,622,6g2,6h2,6i2,6j2,6k2,6l2,6m2,6n2,6r.,742,752,762,772,7f.,7s2,7t2,7u2,7v2,83.,8g2,8h2,8i2,8j2,8u2,8v2,8y2,8z2,922,932,942,952,962,972,9o.,9p.,9q2,9r2,9s.,9t.,9u2,9v2,ac.,ad.,ae2,af2,ag.,ah.,ai2,aj2,b0.,b1.,b22,b32,b4.,b5.,b62,b72"],"a0":[0,1,24,16]},"DancingHappy":{"w":24,"h":17,"palette":["#141413","#be684d","#d97757"],"base":"............................2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","","","","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,262,272,2g2,2h2,2u2,2v2,342,352,3c.,3d.,3e.,3f.,3i0,3j0,3k0,3r0,3s0,3t0,3w.,3x.,3y.,3z.,602,612,622,632,6k2,6l2,6m2,6n2,8u2,8v2,8y2,8z2,902,912,942,952","41,51,61,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,s1,t1,u1,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,1g1,1h1,1i1,1l0,1m0,1t0,1u0,241,251,261,290,2a0,2h0,2i0,2o1,2p1,2q1,2r2,382,392,3a2,3c1,3d1,3e1,3f2,3i2,3j2,3k2,3r2,3s2,3t2,3w2,3x2,3y2,401,411,421,4n.,4o1,4p1,4q1,5b.,5c.,5d.,5e.,5f.,5g1,5h1,5i1,5w.,5x.,5y.,5z.,60.,61.,62.,63.,641,651,661,6k.,6l.,6m.,6n.,6s1,6t1,6u1,7g1,7h1,7i1,841,851,861,8s1,8t1,8u.,8v.,8w.,8z.,90.,93.,94.,95.,9g1,9h1,9i1,9k.,9m2,9p2,9r.,9t2,a4.,a51,a61,a8.,aa2,ad2,af.,ah2,aj.,as.,at.,aw.,ay2,b12,b3.,b6.,b7.","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,1l2,1m2,1t2,1u2,2o.,2p.,2q.,2r.,2s1,2t1,2u1,2x0,2y0,350,360,38.,39.,3a.,5c1,5d1,5e1,5f2,5g2,5h2,5i2,5w2,5x2,5y2,8s.,8u1,952,97.,9g.,9v.,at1,au1,b52,b62","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,292,2a2,2h2,2i2,3c.,3d.,3e.,3f.,3g1,3h1,3i1,3l0,3m0,3t0,3u0,3w.,3x.,3y.,601,611,621,632,642,652,662,6k2,6l2,6m2,8s1,8v2,8w2,8z2,902,932,942,972,9g1,9i.,9k2,9m.,9p.,9r2,9t.,9v2,a41,a82,af2,aj2","","c2,d2,e2,f2,g2,h2,i2,j2,s1,t1,u1,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,1t0,1u0,290,2a0,2h0,2i0,2k2,2l2,2m2,352,362,382,392,3a2,3l2,3m2,3t2,3u2,3w2,3x2,3y2,40.,41.,42.,43.,441,451,461,58.,59.,5a.,5w.,5x.,5y.,6k.,6l.,6m.,6o1,6p1,6q1,6r2,6s2,6t2,6u2,8s.,8v.,8w.,8z.,90.,93.,94.,95.,982,9g.,9i1,9k.,9m2,9p2,9r.,9u.,9w2,a4.,a8.,af.,ah.,ai.,ak2,b5.,b6.","","c.,d.,e.,f.,g.,h.,i.,j.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1t2,1u2,292,2a2,2h2,2i2,2k.,2l.,2m.,350,360,38.,39.,3a.,3l0,3m0,3t0,3u0,3w.,3x.,3y.,401,411,421,432,442,452,462,582,592,5a2,5w2,5x2,5y2,6k2,6l2,6m2,6o.,6p.,6q.,6r.,6s1,6t1,6u1,8s1,8v2,8w2,8z2,902,932,942,952,98.,9g1,9i.,9k2,9m.,9p.,9r2,9u2,9w.,a41,a82,af2,ah2,ai2,ak.,b52,b62","","41,51,61,72,82,92,a2,b2,c2,d2,e2,s1,t1,u1,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,1l0,1m0,201,211,221,232,242,252,262,290,2a0,2h0,2i0,2o1,2p1,2q1,2r2,2s2,2t2,2u2,2x2,2y2,3c1,3d1,3e1,3f2,3g2,3h2,3i2,3l2,3m2,3t2,3u2,4k.,4l.,4m.,4o.,4p.,4q.,4r.,4s1,4t1,5c.,5d.,5e.,5f.,5g1,5h1,60.,61.,62.,63.,641,651,6u2,782,792,7a2,7f1,7h2,7i2,831,852,862,8q1,8r1,8t.,8u.,8v.,8w.,8z.,90.,93.,94.,97.,9e1,9f1,9g.,9h.,9k.,9m2,9p2,9r.,9t2,9v.,a21,a31,a4.,a5.,a6.,a8.,af.,aj.,at.,au.","","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1l2,1m2,20.,21.,22.,23.,241,251,261,292,2a2,2h2,2i2,2o.,2p.,2q.,2r.,2s1,2t1,2u1,2x0,2y0,3c.,3d.,3e.,3f.,3g1,3h1,3i1,3l0,3m0,3t0,3u0,4k2,4l2,4m2,4o1,4p1,4q1,4r2,4s2,4t2,5c1,5d1,5e1,5f2,5g2,5h2,601,611,621,632,642,652,6u1,78.,79.,7a.,7f.,7h1,7i1,83.,851,861,8q.,8r.,8t1,8u1,8v2,8w2,8z2,902,932,942,972,9e.,9f.,9g1,9h1,9k2,9m.,9p.,9r2,9t.,9v2,a2.,a3.,a41,a51,a61,a82,af2,aj2,at1,au1","","41,51,61,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,s1,t1,u1,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,1l0,1m0,1t0,1u0,290,2a0,2h0,2i0,2o1,2p1,2q1,2r2,2s2,2t2,2u2,2x2,2y2,352,362,382,392,3a2,3c1,3d1,3e1,3f2,3g2,3h2,3i2,3l2,3m2,3t2,3u2,3w2,3x2,3y2,5c.,5d.,5e.,5f.,5g1,5h1,5i1,5w.,5x.,5y.,60.,61.,62.,63.,641,651,661,6k.,6l.,6m.,8u.,8v.,8w.,8z.,90.,93.,94.,95.,9i1,9k.,9m2,9p2,9r.,9t2,a4.,a8.,af.,aj.,at.,au.,b5.,b6.","","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1g2,1h2,1i2,1l2,1m2,1t2,1u2,242,252,262,292,2a2,2h2,2i2,2o.,2p.,2q.,2r.,2u0,2v0,340,350,38.,39.,3a.,3c.,3d.,3e.,3f.,3i0,3j0,3s0,3t0,3w.,3x.,3y.,402,412,422,4n2,4o2,4p2,4q2,5b2,5c2,5d2,5e2,5f2,5g2,5h2,5i2,5w2,5x2,5y2,5z2,602,612,622,632,642,652,662,6k2,6l2,6m2,6n2,6s2,6t2,6u2,7g2,7h2,7i2,842,852,862,8r2,8s2,8t2,8u2,8v2,8w2,8z2,902,932,942,952,982,9f2,9g2,9h.,9i.,9j2,9k2,9l.,9m.,9p.,9q.,9r2,9s2,9t.,9u.,9w2,a32,a42,a5.,a6.,a72,a82,aa.,ad.,af2,ag2,ah.,ai.,aj2,ak2,ar2,as2,aw2,ay.,b1.,b32,b72,b82","","42,52,62,72,82,92,a2,b2,c2,d2,e2,f2,g2,h1,i1,j1,s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,151,161,171,1h0,1i0,1p0,1q0,1t1,1u1,1v1,250,260,2d0,2e0,2h1,2i1,2j1,2p2,2q2,2r2,2u2,2v2,342,352,382,391,3a1,3b1,3d2,3e2,3f2,3i2,3j2,3s2,3t2,3w2,3x1,3y1,3z1,40.,4l1,4m1,4n1,4o.,591,5a1,5b1,5c.,5d.,5e.,5f.,5t1,5u1,5v1,5w.,5x.,5y.,5z.,60.,61.,62.,63.,6h1,6i1,6j1,6k.,6l.,6m.,6n.,751,761,771,7t1,7u1,7v1,8h1,8i1,8j1,8r.,8u.,8v.,8w.,8z.,90.,93.,94.,95.,961,971,98.,9f.,9h2,9i2,9j.,9k.,9l2,9m2,9p2,9q2,9r.,9s.,9t1,9u1,9v1,9w.,a3.,a4.,a52,a62,a7.,a8.,aa2,ad2,af.,ag.,ah1,ai1,aj.,ak.,ar.,as.,aw.,ay2,b12,b3.,b7.,b8.","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,1h2,1i2,1p2,1q2,2p.,2q.,2r.,2t0,2u0,310,320,351,361,371,38.,39.,3a.,3b.,5d2,5e2,5f2,5t2,5u2,5v2,5w2,5x1,5y1,5z1,8s.,8u2,951,97.,9g.,9v.,at2,au2,b51,b61","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,252,262,2d2,2e2,3d.,3e.,3f.,3h0,3i0,3p0,3q0,3t1,3u1,3v1,3w.,3x.,3y.,3z.,612,622,632,6h2,6i2,6j2,6k2,6l1,6m1,6n1,8s2,8v2,8w2,8z2,902,932,942,971,9g2,9i.,9k2,9m.,9p.,9r2,9t.,9v1,a42,a82,af2,aj1","","42,52,62,72,82,92,a2,b2,s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,151,161,171,1h0,1i0,212,222,232,250,260,2d0,2e0,2p2,2q2,2r2,2t2,2u2,3d2,3e2,3f2,3h2,3i2,3p2,3q2,4h1,4i1,4j1,4k.,4l.,4m.,4n.,4p.,4q.,4r.,5d.,5e.,5f.,61.,62.,63.,752,762,772,782,791,7a1,7b1,8r2,8u.,8v.,8w.,8z.,90.,93.,94.,97.,9f2,9h.,9k.,9m2,9p2,9r.,9t1,9v.,a32,a5.,a6.,a8.,af.,aj.,at.,au.","","4.,5.,6.,7.,8.,9.,a.,b.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1h2,1i2,21.,22.,23.,252,262,2d2,2e2,2p.,2q.,2r.,2t0,2u0,3d.,3e.,3f.,3h0,3i0,3p0,3q0,4h2,4i2,4j2,4k2,4l1,4m1,4n1,4p2,4q2,4r2,5d2,5e2,5f2,612,622,632,751,761,771,78.,79.,7a.,7b.,8r.,8u2,8v2,8w2,8z2,902,932,942,971,9f.,9h2,9k2,9m.,9p.,9r2,9t.,9v1,a3.,a52,a62,a82,af2,aj1,at2,au2","","92,a2,b2,c2,d2,e2,f2,g2,h1,i1,j1,s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,151,161,171,1p0,1q0,250,260,2d0,2e0,2h2,2i2,2j2,2k2,2l1,2m1,2n1,312,322,352,362,372,382,391,3a1,3b1,3h2,3i2,3p2,3q2,3t2,3u2,3v2,3w2,3x1,3y1,3z1,41.,42.,43.,561,571,58.,59.,5a.,5b.,5u1,5v1,5w.,5x.,5y.,5z.,6i1,6j1,6k.,6l.,6m.,6n.,6p2,6q2,6r2,752,7t2,7u2,7w1,8h2,8i2,8k1,8s.,8v.,8w.,8z.,90.,93.,94.,95.,96.,981,991,9g.,9i2,9k.,9m2,9p2,9r.,9u.,9v.,9w1,9x1,a4.,a8.,af.,ah.,ai.,aj.,ak1,al1,b5.,b6.","","9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1p2,1q2,252,262,2d2,2e2,2h1,2i1,2j1,2k.,2l.,2m.,2n.,310,320,351,361,371,38.,39.,3a.,3b.,3h0,3i0,3p0,3q0,3t1,3u1,3v1,3w.,3x.,3y.,3z.,412,422,432,562,572,582,591,5a1,5b1,5u2,5v2,5w2,5x1,5y1,5z1,6i2,6j2,6k2,6l1,6m1,6n1,6p.,6q.,6r.,751,7t1,7u1,7w.,8h1,8i1,8k.,8s2,8v2,8w2,8z2,902,932,942,951,961,98.,99.,9g2,9i.,9k2,9m.,9p.,9r2,9u1,9v1,9w.,9x.,a42,a82,af2,ah1,ai1,aj1,ak.,al.,b51,b61","","42,52,62,72,82,92,a2,b2,c2,d2,e2,f2,g2,h1,i1,j1,s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,151,161,171,1h0,1i0,1p0,1q0,250,260,2d0,2e0,2p2,2q2,2r2,2t2,2u2,312,322,352,362,372,382,391,3a1,3b1,3d2,3e2,3f2,3h2,3i2,3p2,3q2,3t2,3u2,3v2,3w2,3x1,3y1,3z1,5d.,5e.,5f.,5t1,5u1,5v1,5w.,5x.,5y.,5z.,61.,62.,63.,6h1,6i1,6j1,6k.,6l.,6m.,6n.,8u.,8v.,8w.,8z.,90.,93.,94.,95.,9i2,9k.,9m2,9p2,9r.,9t1,a4.,a8.,af.,aj.,at.,au.,b5.,b6.","","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1h2,1i2,1p2,1q2,1t2,1u2,1v2,252,262,2d2,2e2,2h2,2i2,2j2,2p.,2q.,2r.,2u0,2v0,340,350,38.,39.,3a.,3b.,3d.,3e.,3f.,3i0,3j0,3s0,3t0,3w.,3x.,3y.,3z.,402,4l2,4m2,4n2,4o2,592,5a2,5b2,5c2,5d2,5e2,5f2,5t2,5u2,5v2,5w2,5x2,5y2,5z2,602,612,622,632,6h2,6i2,6j2,6k2,6l2,6m2,6n2,752,762,772,7t2,7u2,7v2,8h2,8i2,8j2,8r2,8u2,8v2,8w2,8z2,902,932,942,952,962,972,982,9f2,9h.,9i.,9j2,9k2,9l.,9m.,9p.,9q.,9r2,9s2,9t.,9u.,9v2,9w2,a32,a42,a5.,a6.,a72,a82,aa.,ad.,af2,ag2,ah.,ai.,aj2,ak2,ar2,as2,aw2,ay.,b1.,b32,b72,b82",""],"a0":[0,1,24,16]},"BreakDancing":{"w":34,"h":32,"palette":["#d97757","#bf694d","#000000"],"base":"........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................0000000000000000..................0000000000000000..................0022000000002200..................0022000000002200..................1111000000001111.................000010000000010000................000010000000010000................000010000000010000................000010000000010000.................1111000000001111..................0000000000000000..................0000000000000000..................00..00....00..00..................00..00....00..00..................00..00....00..00..................00..00....00..00..........","deltas":["","fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,h30,h40,h50,h60,h70,ha0,hc2,hk0,hl0,i10,i20,i30,i40,i50,i80,ia2,ii0,ik2,im1,in0,io0,iz0,j00,j10,j20,j30,j40,j50,j60,j70,jg0,jh2,ji2,jj0,jk1,jl0,jm0,jn0,jx0,jy0,jz0,k00,k50,ke0,ki1,kj0,kk0,kl0,kz.,l30,lc0,lg1,lh0,li0,lj0,lx.,m10,ma0,me.,mf0,mg0,mh0,mv.,mz0,n80,nc.,nu0,nv0,nw0,nx0,o60,o70,o80,o90,qn0,qw0,qx0,r00,r10,r40,rk0,rl0,rn.,rp0,ry0,s20,sh0,si0,sj0,sk.,sl.,sn0,sp.,su.,sw0,sy.,t00,tf0,tg0,ti.,tj.,tl0,tn.,ts.,tu0,tw.,ty0","","fc.,fk0,ga.,gq0,h3.,hb0,hd2,ho0,hp1,hq0,hr0,i1.,i90,ib2,ij0,il2,im0,in1,ip0,iq0,iz.,jh0,jj2,jk0,jl1,jo0,jx.,ki0,kj1,km0,l0.,lg0,lh.,lk0,ly.,me0,mf.,mg.,mh.,mw.,nc0,nu.,oa0,os.,p80,pq.,q60,qn.,qq0,qs.,qu0,qw.,r2.,r50,rk.,rn0,rp.,rs0,rw.,rz0,s0.,s30,sk0,sp0","fc0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,ga0,gq.,h4.,h5.,h6.,h7.,ha2,hb2,hc0,hd0,hk2,hl2,ho.,hp.,hq.,hr.,i2.,i3.,i4.,i5.,i82,i92,ia0,ib0,ii2,ij2,ik0,il0,im.,in.,io.,ip.,iq.,j0.,j1.,j2.,j3.,ji0,jj0,jk.,jl.,jm.,jn.,jo.,jy.,jz.,k0.,k1.,k21,k31,k41,kf1,kg1,kh1,ki.,kj.,kk.,kl.,km.,kx0,ky0,kz0,l00,l21,ld1,lh0,lj.,lk.,lv0,lw0,lx0,ly0,m01,mb1,mf0,mg0,mt0,mu0,mv0,mw0,my1,n91,nd0,ne0,nr0,ns0,nt0,nu0,nw1,o71,ob0,oc0,os1,ot1,ou1,p51,p61,p71,p8.,pq0,q6.,qn0,qq.,qs0,qu.,qx.,r0.,r1.,r20,r4.,r5.,rk0,rp0,rs.,rw0,rz.,s00,s3.,sh.,sk.,su0,tf.,th0","ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,gc2,gd2,gm2,gn2,i61,i71,i81,i91,ia1,ih1,ii1,ij1,ik1,il1,j30,j81,jf1,jk0,k10,k20,k30,k40,k61,kd1,kf0,kg0,kh0,ki0,kx.,ky.,l20,l41,lb1,ld0,lh.,li.,lv.,lw.,m00,m21,m91,mb0,mf.,mg.,mt.,mu.,mv.,mw1,mx1,mz1,n01,n71,n81,na1,nb1,nc.,nd.,ne.,nr.,ns.,nt.,nw0,o70,oa.,ob.,oc.,os0,ot0,ou0,p50,p60,p70,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,qn.,qq0,r10,rk.,rl.,rm.,ro0,rp.,rs0,rv0,ry.,rz0,s1.,s2.,si.,sj.,sl0,sm0,sn.,so.,sq0,st0,sv.,sw.,sx0,sy0,sz.,t0.,tg.,th.,tj0,tk0,tl.,tm.,tn0,to0,tr0,ts0,tt.,tu.,tv0,tw0,tx.,ty.","","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fr.,g90,gc0,gd0,gm0,gn0,gp.,h70,ha0,hb0,hi2,hj2,hk0,hl0,ho0,hp0,hq0,hr0,i20,i30,i41,i50,i62,i72,i80,i90,ia0,ig2,ih2,ii0,ij0,ik0,il0,im0,in0,io0,ip0,iz0,j00,j10,j21,j42,j52,j80,jf0,jl0,jm0,jn0,jx0,jy0,jz0,k01,k60,kd0,kj0,kk0,kl0,kv0,kw0,kx0,ky1,l40,lb0,lf.,lg.,lt0,lu0,lv0,m20,m90,md.,me.,mv0,mw0,mx0,my0,mz0,n00,n70,n80,n90,na0,nb.,nt0,o9.,or0,p7.,pp0,ps0,pt0,pw0,px0,py0,pz0,q20,q30,q5.,qm0,qn0,qr0,qu0,qx0,qz.,rk0,rl0,rm0,rn.,rp0,rr.,rs.,rz.,s10,s20,si0,sj0,sl.,sn0,sp.,sq.,st.,sv0,sx.,sy.,sz0,t00,t10,tg0,th0,tj.,tl0,tn.,to.,tr.,tt0,tv.,tw.,ty0,tz0","","fi0,fq.,g80,go.,h30,h40,h51,h60,hh2,hj0,hr.,i00,i10,i31,i40,i52,i70,if2,ih0,ip.,iy0,j11,j20,j32,j50,jn.,jw0,jz1,k00,kl.,ku0,kx.,ky0,le.,lt.,lu.,lv.,lw0,mc.,mu0,na.,ns0,o8.,oq0,p6.,po0,q4.,ql0,qo.,qu.,qw0,qy.,r00,r3.,rj0,rm.,rn0,rq.,ru0,rx.,rz0,s2.,st0,sy0","fb0,fc0,fd0,fe0,ff0,fg0,fh0,fq0,g8.,go0,h3.,h4.,h5.,h6.,h92,ha2,hh0,hi0,hj2,hk2,hn.,ho.,hp.,hq.,i0.,i1.,i2.,i3.,i4.,i50,i60,i72,i82,if0,ig0,ih2,ii2,il.,im.,in.,io.,iy.,iz.,j0.,j1.,j2.,j30,j40,jj.,jk.,jl.,jm.,jw.,jx.,jy.,jz.,k0.,k11,k21,k31,ke1,kf1,kg1,kh.,ki.,kj.,kk.,ku.,kv.,kx0,l11,lc1,le0,lf0,lg0,lh0,lu0,lv0,lz1,ma1,mc0,md0,me0,mf0,ms0,mt0,mx1,n81,na0,nb0,nc0,nd0,nq0,nr0,nv1,o61,o80,o90,oa0,ob0,oq.,or1,os1,ot1,p41,p51,p61,po.,q40,ql.,qm.,qo0,qp.,qq.,qt.,qw.,qy0,r0.,r30,rj.,rm0,rn.,rq0,ru.,rx0,s20,so0,sy.,t1.,tx0,tz.","ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,fb.,fr0,g9.,gc2,gd2,gm2,gn2,gp0,h7.,h90,hb2,hj0,hl2,hn0,i5.,i61,i71,i81,i91,ia1,ih1,ii1,ij1,ik1,il1,j81,jf1,jj0,jk0,k10,k20,k30,k61,kd1,ke0,kf0,kg0,kh0,ki0,kw.,kx.,ky.,l10,l41,lb1,lc0,lh.,lu.,lv.,lw.,lz0,m21,m91,ma0,mf.,ms.,mt.,mu.,mv.,mw1,my1,mz1,n01,n71,n91,na1,nb1,nc.,nd.,nq.,nr.,ns.,nt.,nv0,o60,oa.,ob.,or.,os0,ot0,p40,p50,p60,p70,pp.,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,q50,qn.,qp0,qq0,qr.,qt0,qx.,qz0,rk.,rl.,rm.,rn0,rp.,rr0,rs0,s1.,s2.,si.,sj.,sl0,sn.,so.,sp0,sq0,sv.,sx0,sy0,sz.,t0.,tg.,th.,tj0,tl.,tn0,to0,tr0,tt.,tv0,tw0,tx.,ty.","","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,gc0,gd0,gm0,gn0,h30,h40,h50,h60,h70,ha0,hc2,hk0,hl0,i10,i20,i30,i40,i50,i60,i70,i80,i92,ia2,ih0,ii0,ij2,ik2,il0,im1,in0,io0,iz0,j00,j10,j20,j80,jf0,jh2,ji2,jk1,jl0,jm0,jn0,jx0,jy0,jz0,k00,k60,kd0,ki1,kj0,kk0,kl0,kz.,l40,lb0,lg1,lh0,li0,lj0,lx.,m20,m90,me.,mf0,mg0,mh0,mw0,mx0,my0,mz0,n00,n70,n80,n90,na0,nb0,ps0,pt0,pw0,px0,py0,pz0,q20,q30,qn0,qq.,qw0,qx0,r00,r40,rk0,rl0,rm0,rn.,ro.,rp0,rs.,rv.,ry0,rz.,s10,s20,sh0,si0,sj0,sl.,sm.,sn0,so0,sp.,sq.,st.,su.,sv0,sw0,sx.,sy.,sz0,t00,tf0,tg0,tj.,tk.,tl0,tm0,tn.,to.,tr.,ts.,tt0,tu0,tv.,tw.,tx0,ty0","","fc.,fk0,ga.,gq0,h3.,hb0,hd2,ho0,hp1,hq0,hr0,i1.,i90,ib2,ij0,il2,im0,in1,ip0,iq0,iz.,jh0,jj2,jk0,jl1,jo0,jx.,ki0,kj1,km0,l0.,lg0,lh.,lk0,ly.,me0,mf.,mg.,mh.,mw.,nc0,nu.,oa0,os.,p80,pq.,q60,qn.,qq0,qs.,qu0,qw.,r2.,r50,rk.,rn0,rp.,rs0,rw.,rz0,s0.,s30,sk0,sp0","fc0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,ga0,gq.,h4.,h5.,h6.,h7.,ha2,hb2,hc0,hd0,hk2,hl2,ho.,hp.,hq.,hr.,i2.,i3.,i4.,i5.,i82,i92,ia0,ib0,ii2,ij2,ik0,il0,im.,in.,io.,ip.,iq.,j0.,j1.,j2.,j3.,ji0,jj0,jk.,jl.,jm.,jn.,jo.,jy.,jz.,k0.,k1.,k21,k31,k41,kf1,kg1,kh1,ki.,kj.,kk.,kl.,km.,kx0,ky0,kz0,l00,l21,ld1,lh0,lj.,lk.,lv0,lw0,lx0,ly0,m01,mb1,mf0,mg0,mt0,mu0,mv0,mw0,my1,n91,nd0,ne0,nr0,ns0,nt0,nu0,nw1,o71,ob0,oc0,os1,ot1,ou1,p51,p61,p71,p8.,pq0,q6.,qn0,qq.,qs0,qu.,qx.,r0.,r1.,r20,r4.,r5.,rk0,rp0,rs.,rw0,rz.,s00,s3.,sh.,sk.,su0,tf.,th0","ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,gc2,gd2,gm2,gn2,i61,i71,i81,i91,ia1,ih1,ii1,ij1,ik1,il1,j30,j81,jf1,jk0,k10,k20,k30,k40,k61,kd1,kf0,kg0,kh0,ki0,kx.,ky.,l20,l41,lb1,ld0,lh.,li.,lv.,lw.,m00,m21,m91,mb0,mf.,mg.,mt.,mu.,mv.,mw1,mx1,mz1,n01,n71,n81,na1,nb1,nc.,nd.,ne.,nr.,ns.,nt.,nw0,o70,oa.,ob.,oc.,os0,ot0,ou0,p50,p60,p70,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,qn.,qq0,r10,rk.,rl.,rm.,ro0,rp.,rs0,rv0,ry.,rz0,s1.,s2.,si.,sj.,sl0,sm0,sn.,so.,sq0,st0,sv.,sw.,sx0,sy0,sz.,t0.,tg.,th.,tj0,tk0,tl.,tm.,tn0,to0,tr0,ts0,tt.,tu.,tv0,tw0,tx.,ty.","","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fr.,g90,gc0,gd0,gm0,gn0,gp.,h70,ha0,hb0,hi2,hj2,hk0,hl0,ho0,hp0,hq0,hr0,i20,i30,i41,i50,i62,i72,i80,i90,ia0,ig2,ih2,ii0,ij0,ik0,il0,im0,in0,io0,ip0,iz0,j00,j10,j21,j42,j52,j80,jf0,jl0,jm0,jn0,jx0,jy0,jz0,k01,k60,kd0,kj0,kk0,kl0,kv0,kw0,kx0,ky1,l40,lb0,lf.,lg.,lt0,lu0,lv0,m20,m90,md.,me.,mv0,mw0,mx0,my0,mz0,n00,n70,n80,n90,na0,nb.,nt0,o9.,or0,p7.,pp0,ps0,pt0,pw0,px0,py0,pz0,q20,q30,q5.,qm0,qn0,qr0,qu0,qx0,qz.,rk0,rl0,rm0,rn.,rp0,rr.,rs.,rz.,s10,s20,si0,sj0,sl.,sn0,sp.,sq.,st.,sv0,sx.,sy.,sz0,t00,t10,tg0,th0,tj.,tl0,tn.,to.,tr.,tt0,tv.,tw.,ty0,tz0","","fi0,fq.,g80,go.,h30,h40,h51,h60,hh2,hj0,hr.,i00,i10,i31,i40,i52,i70,if2,ih0,ip.,iy0,j11,j20,j32,j50,jn.,jw0,jz1,k00,kl.,ku0,kx.,ky0,le.,lt.,lu.,lv.,lw0,mc.,mu0,na.,ns0,o8.,oq0,p6.,po0,q4.,ql0,qo.,qu.,qw0,qy.,r00,r3.,rj0,rm.,rn0,rq.,ru0,rx.,rz0,s2.,st0,sy0","fb0,fc0,fd0,fe0,ff0,fg0,fh0,fq0,g8.,go0,h3.,h4.,h5.,h6.,h92,ha2,hh0,hi0,hj2,hk2,hn.,ho.,hp.,hq.,i0.,i1.,i2.,i3.,i4.,i50,i60,i72,i82,if0,ig0,ih2,ii2,il.,im.,in.,io.,iy.,iz.,j0.,j1.,j2.,j30,j40,jj.,jk.,jl.,jm.,jw.,jx.,jy.,jz.,k0.,k11,k21,k31,ke1,kf1,kg1,kh.,ki.,kj.,kk.,ku.,kv.,kx0,l11,lc1,le0,lf0,lg0,lh0,lu0,lv0,lz1,ma1,mc0,md0,me0,mf0,ms0,mt0,mx1,n81,na0,nb0,nc0,nd0,nq0,nr0,nv1,o61,o80,o90,oa0,ob0,oq.,or1,os1,ot1,p41,p51,p61,po.,q40,ql.,qm.,qo0,qp.,qq.,qt.,qw.,qy0,r0.,r30,rj.,rm0,rn.,rq0,ru.,rx0,s20,so0,sy.,t1.,tx0,tz.","ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,fb.,fr0,g9.,gc2,gd2,gm2,gn2,gp0,h7.,h90,hb2,hj0,hl2,hn0,i5.,i61,i71,i81,i91,ia1,ih1,ii1,ij1,ik1,il1,j81,jf1,jj0,jk0,k10,k20,k30,k61,kd1,ke0,kf0,kg0,kh0,ki0,kw.,kx.,ky.,l10,l41,lb1,lc0,lh.,lu.,lv.,lw.,lz0,m21,m91,ma0,mf.,ms.,mt.,mu.,mv.,mw1,my1,mz1,n01,n71,n91,na1,nb1,nc.,nd.,nq.,nr.,ns.,nt.,nv0,o60,oa.,ob.,or.,os0,ot0,p40,p50,p60,p70,pp.,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,q50,qn.,qp0,qq0,qr.,qt0,qx.,qz0,rk.,rl.,rm.,rn0,rp.,rr0,rs0,s1.,s2.,si.,sj.,sl0,sn.,so.,sp0,sq0,sv.,sx0,sy0,sz.,t0.,tg.,th.,tj0,tl.,tn0,to0,tr0,tt.,tv0,tw0,tx.,ty.","","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,gc0,gd0,gm0,gn0,i60,i70,i82,i92,ia0,ih0,ii2,ij2,ik0,il0,j00,j10,j20,j80,jf0,jl0,jm0,jn0,jy0,jz0,k00,k60,kd0,kj0,kk0,kl0,kw0,kx0,ky0,l40,lb0,lh0,li0,lj0,lu0,lv0,lw0,m20,m90,mf0,mg0,mh0,mw0,mx0,my0,mz0,n00,n70,n80,n90,na0,nb0,ps0,pt0,pw0,px0,py0,pz0,q20,q30,qq.,r1.,rm0,ro.,rs.,rv.,rz.,s10,sk0,sm.,so0,sq.,st.,sv0,sx.,sz0,ti0,tk.,tm0,to.,tr.,tt0,tv.,tx0","fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,ga.,gb.,gc.,gd.,ge.,gf.,gg.,gh.,gi.,gj.,gk.,gl.,gm.,gn.,go.,gp.,ha0,hb0,hk0,hl0,i80,i90,ii0,ij0,j0.,j1.,j2.,j3.,jk.,jl.,jm.,jn.,jy.,jz.,k0.,k1.,ki.,kj.,kk.,kl.,kw.,kx.,ky.,kz.,lg.,lh.,li.,lj.,lu.,lv.,lw.,lx.,m02,m12,ma2,mb2,me.,mf.,mg.,mh.,ms0,mt0,mu0,mv0,my2,mz2,n82,n92,nc0,nd0,ne0,nf0,nq0,nr0,ns0,nt0,oa0,ob0,oc0,od0,oo0,op0,oq0,or0,p80,p90,pa0,pb0,pm0,pn0,po0,pp0,q60,q70,q80,q90,qq0,qr0,qu0,qv0,qw0,qx0,r00,r10,ro0,rp0,rs0,rt0,ru0,rv0,ry0,rz0,sk1,sl1,so1,sp1,su1,sv1,sy1,sz1","b10,b20,b30,by0,bz0,c00,c10,c20,cw1,cx1,cy1,cz0,d00,do0,dp0,dq0,dr0,ds0,dt0,du0,dv0,dw1,dx0,dy0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,eu1,ev0,ew0,ex0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo2,fp2,fq0,fr0,fs1,ft0,fu0,fv0,ga0,gb0,gc2,gd2,ge0,gf0,gg0,gh0,gi0,gj0,gk0,gl0,gm2,gn2,go0,gp0,gq1,gr0,gs0,gt0,ha2,hb2,ho1,hp0,hq0,hr0,jy0,jz0,k00,k10,kw0,kx0,ky0,kz0,lu0,lv0,lw0,lx0,m00,m10,ma0,mb0,my0,mz0,n80,n90,nc.,nd.,ne.,nf.,nq.,nr.,ns.,nt.,oa1,ob.,oc.,od.,oo.,op.,oq.,or.,p4.,p5.,p9.,pa.,pb.,pm.,pn.,po.,pp.,ps.,pt.,py.,pz.,q3.,q4.,q7.,q8.,q9.,qq.,qr.,qu.,qv.,qw.,qx.,qy.,r1.,r2.,r40,ro.,rp.,rs.,rt.,ru.,rv.,rw.,rz.,s0.,s20,sk0,sl0,so0,sp0,su.,sv0,sw0,sy.,sz.,ts.,tt.,tw.,tx.","840,850,860,870,920,930,940,950,a00,a10,a20,a30,ay1,az1,b01,b11,b2.,b3.,bt0,bu0,bv0,bw0,bx0,bz1,c0.,c1.,c2.,cn0,co0,cp0,cq0,cr0,cs0,ct0,cu0,cv0,cw0,cx.,cy.,cz.,d0.,di0,dj0,dk0,dl0,dm0,dn0,dr2,ds2,dv.,dw.,dx.,dy.,ed0,ee0,ef0,ep2,eq2,et.,eu.,ev.,ew.,ex.,fb0,fo0,fp0,fr.,fs.,ft.,fu.,fv.,g90,gb2,gd0,gm0,gn0,gp.,gq.,gr.,gs.,gt.,h70,h92,hb0,hn.,ho.,hp.,hq.,hr.,i50,il.,j30,jj.,jy.,jz.,k0.,kh.,kv0,lf.,lt0,mr0,n7.,n8.,n9.,nc0,np0,nq0,nr0,ns0,nt0,o1.,o2.,o6.,o7.,o8.,oa0,ob0,or0,ot.,ou.,ov.,oy.,oz.,p0.,p1.,p40,p6.,p7.,p90,pp0,pw.,px.,q0.,q5.,q6.,qn0,r3.,r4.,rx.,ry.,s1.,s2.,sv.,sw.,tm.,tn.","","84.,85.,86.,87.,92.,93.,94.,95.,a0.,a1.,a2.,a3.,ay.,az.,b0.,b10,b20,b30,bt.,bu.,bv.,bw.,bx.,bz0,c00,c10,c20,cn.,co.,cp.,cq.,cr.,cs.,ct.,cu.,cv.,cw1,cx1,cy1,cz0,d00,di.,dj.,dk.,dl.,dm.,dn.,dr0,ds0,dv0,dw1,dx0,dy0,ed.,ee.,ef.,ep0,eq0,et0,eu1,ev0,ew0,ex0,fb.,fo2,fp2,fr0,fs1,ft0,fu0,fv0,g9.,gb0,gd2,gm2,gn2,gp0,gq1,gr0,gs0,gt0,h7.,h90,hb2,hn0,ho1,hp0,hq0,hr0,i5.,il0,j3.,jj0,jy0,jz0,k00,kh0,kv.,lf0,lt.,mr.,n70,n80,n90,nc.,np.,nq.,nr.,ns.,nt.,o10,o20,o60,o70,o80,oa1,ob.,or.,ot0,ou0,ov0,oy0,oz0,p00,p10,p4.,p60,p70,p9.,pp.,pw0,px0,q00,q50,q60,qn.,r30,r40,rx0,ry0,s10,s20,sv0,sw0,tm0,tn0","b1.,b2.,b3.,by.,bz.,c0.,c1.,c2.,cw.,cx.,cy.,cz.,d0.,do.,dp.,dq.,dr.,ds.,dt.,du.,dv.,dw.,dx.,dy.,ee0,ef0,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,eu.,ev.,ew.,ex.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,fs.,ft.,fu.,fv.,gc0,gd0,gm0,gn.,go.,gp.,gq.,gr.,gs.,gt.,h40,h50,h60,h70,ha0,hb0,ho.,hp.,hq.,hr.,i20,i30,i40,i50,j00,j10,j20,j30,k42,k52,kw.,kx.,ky.,kz.,l22,l32,lu.,lv.,lw.,lx.,ma2,mb2,ms.,mt.,mu.,mv.,n82,n92,oa.,p40,p50,p8.,ps0,pt0,py0,pz0,q30,q40,q6.,qu0,qv0,qw0,qx0,qy0,r10,r20,r50,r60,r70,rq1,rr1,ru0,rv0,rw0,rz0,s00,s30,s40,s50,su1,sv1,sw.,sy1,sz1,t00,t10,t20,t30,ts0,tt0,tw0,tx0,ty0,tz0,u00,u10","910,920,930,940,950,960,9z0,a00,a10,a20,a30,a40,aw0,ax0,ay0,az0,b00,b10,b20,bu0,bv0,bw0,bx0,by0,bz0,c00,cn0,co0,cp0,cq0,cr0,cs0,ct0,cu0,cv0,cw0,cx0,cy0,cz0,d00,d10,d20,d30,dj0,dk0,dl0,dm0,dn0,do0,dp0,dq0,dr0,ds0,dt0,du0,dv0,dw0,dx0,dy0,dz0,e00,e10,ee.,ef.,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es2,et2,eu0,ev0,ew0,ex0,ey0,ez0,fc.,fd.,fh.,fi.,fj.,fk0,fl0,fm0,fn0,fo0,fp0,fq2,fr2,fs0,ft0,fu0,fv0,fw0,fx0,ga.,gb.,ge.,gf.,gg.,gh.,gn0,go0,gp0,gq0,gr0,gs0,gt0,gu0,h4.,h5.,h6.,h7.,h8.,h9.,hc.,ho0,hp0,hq0,hr0,hs0,i2.,i3.,i4.,i5.,i6.,i7.,i8.,i9.,im0,in0,io0,ip0,iq0,j0.,j1.,j2.,j3.,j4.,j5.,j6.,jk0,jl0,jm0,jn0,jo0,jy.,jz.,k0.,k1.,k2.,k3.,k4.,k50,ki0,kj0,kk0,kl0,l0.,l1.,l2.,l30,l6.,l7.,lg0,lh0,li0,lj0,ly.,lz.,m0.,m3.,m4.,m5.,ma0,mb0,me0,mf0,mg0,mh0,mw.,mx.,my.,mz.,n0.,n1.,n2.,n3.,n80,n90,nc0,nd0,ne0,nf0,nu.,nv.,nw.,nx.,ny.,nz.,o0.,o62,o72,oa0,ob0,oc0,od0,os.,ot.,ou.,ov.,ow.,ox.,p42,p52,p80,p90,pa0,pq.,pr.,ps.,pt.,pu.,q60,q70,q80,qo.,qp.,qv.,qw.,r7.,rm.,rn.,rq0,rr0,ru.,rv.,rw.,rx.,s0.,s1.,sk.,sl.,so.,sp.,su.,sv.,sw0,sx0,sy0,sz.,ti.,tj.,tm.,tn.,ts.,tt.,tv0,tx.","870,880,890,8a0,8b0,91.,92.,93.,94.,970,980,990,9q0,9r0,9z.,a0.,a1.,a2.,a50,a60,a70,ao0,ap0,aq0,aw.,ax.,ay.,az.,b0.,b30,b40,b50,bn0,bo0,bp0,bq0,br0,bs0,bt0,c10,c20,c30,c40,cm0,d40,d50,dj.,dk.,dl.,dm.,dx2,dy2,e20,e30,ej.,ek.,es0,et0,ev2,ew2,f00,f10,fh0,fi0,fj0,fq0,fr0,fy0,gc.,gd.,gf0,gg0,gh0,gv0,gw0,ha.,hb.,hd.,he.,ht0,hu0,ia.,ib.,ic.,ir0,is0,j7.,j8.,j9.,ja.,jp0,k40,km0,kn0,l20,l60,l70,lk0,ll0,m1.,m2.,m50,mi0,mj0,n30,na2,nb2,ng0,nh0,nz0,o00,o60,o70,o82,o92,oe0,ov0,ow0,ox0,p40,p50,pb0,pc0,ps0,pt0,pu0,pw.,px.,py.,pz.,q0.,q90,qa0,qq0,qr0,qs.,qt.,qu.,qx.,qy.,qz.,r0.,r1.,r2.,r3.,r70,rq.,rr.,ry.,rz.,sw.,sx.,sy.,tv.,tw.","620,630,700,710,720,7z0,800,87.,88.,8c0,8x0,8y0,8z0,95.,96.,9a0,9q.,9s0,9w0,9x0,a3.,a4.,a80,ao.,ar0,as0,au0,av0,aw0,b1.,b2.,b60,bn.,c50,cm.,cn.,dx0,dz2,eg.,eh.,ei.,el.,ev0,ex2,fe.,ff.,fg.,fh.,fi.,fj.,fz0,gf.,gg.,gh.,ha0,hb0,hf.,i80,i90,ia0,ib0,id.,j70,j80,j90,ja0,jq0,k4.,k5.,l2.,l3.,l6.,l7.,m20,m30,m5.,n00,n10,n20,na0,nc2,ny0,o80,oa2,of0,ov.,ow.,ox.,oy.,oz.,p0.,p1.,p2.,ps.,pt.,pu.,pv.,q1.,q2.,qq.,qr.","","62.,63.,640,650,70.,71.,730,740,7z.,80.,810,820,89.,8a.,8d0,8e0,8v0,8x.,8y.,900,910,97.,98.,9b0,9c0,9r.,9s.,9t0,9u0,9w.,9x.,9y0,9z0,a5.,a6.,a90,aa0,ap.,aq.,at0,au.,av.,ax0,ay0,b3.,b4.,b70,b80,bo.,bp.,c60,co.,d60,dn.,dy0,e02,e40,em.,ew0,ey2,f20,fk.,g00,gd0,ge0,gi.,gx0,ha.,hc0,hd0,hg.,hv0,i8.,i9.,ic0,id0,ie.,it0,j7.,j8.,jr0,k6.,k9.,ko0,l4.,l60,l8.,lm0,m2.,m40,m50,m6.,mk0,n0.,n1.,nb0,nd2,ni0,ny.,nz.,o0.,o90,ob2,og0,p3.,pd0,q3.,qb0","","","","","620,630,64.,65.,700,710,73.,74.,7z0,800,81.,82.,890,8a0,8d.,8e.,8v.,8x0,8y0,90.,91.,970,980,9b.,9c.,9r0,9s0,9t.,9u.,9w0,9x0,9y.,9z.,a50,a60,a9.,aa.,ap0,aq0,at.,au0,av0,ax.,ay.,b30,b40,b7.,b8.,bo0,bp0,c6.,co0,d6.,dn0,dy2,e00,e4.,em0,ew2,ey0,f2.,fk0,g0.,gd.,ge.,gi0,gx.,ha0,hc.,hd.,hg0,hv.,i80,i90,ic.,id.,ie0,it.,j70,j80,jr.,k60,k90,ko.,l40,l6.,l80,lm.,m20,m4.,m5.,m60,mk.,n00,n10,nb2,nd0,ni.,ny0,nz0,o00,o92,ob0,og.,p30,pd.,q30,qb.","","62.,63.,70.,71.,72.,7z.,80.,89.,8a.,8b.,8c.,8x.,8y.,8z.,910,920,930,940,950,960,97.,98.,99.,9a.,9r.,9s.,9w.,9x.,9z0,a00,a10,a20,a30,a40,a5.,a6.,a7.,a8.,an0,ao0,ap.,aq.,ar.,as.,au.,av.,ax0,ay0,az0,b00,b10,b20,b3.,b4.,b5.,b6.,bl0,bm0,bn0,bs.,bt.,c1.,c2.,c3.,c4.,c5.,cj0,ck0,cl0,cm0,cn0,d4.,d5.,dj0,dk0,dl0,dm0,dy0,dz0,e2.,e3.,el0,es2,et2,ew0,ex0,f0.,f1.,fq2,fr2,fy.,fz.,gv.,gw.,h90,hc0,hd0,he0,hf0,ht.,hu.,i70,ic0,id0,ir.,is.,j50,j60,jp.,jq.,k6.,k7.,k8.,km.,kn.,l4.,l5.,lk.,ll.,m2.,m3.,mi.,mj.,n0.,n1.,n2.,n3.,nb0,nc0,ng.,nh.,ny.,nz.,o0.,o62,o72,o90,oa0,oe.,of.,oy0,oz0,p00,p10,p20,p42,p52,pb.,pc.,pv0,pw0,px0,py0,pz0,q00,q10,q20,q9.,qa.,qs0,qt0,qu0,qx0,qy0,qz0,r00,r10,r20,r30,r7.,rq0,rr0,ry0,rz0,sw0,sx0,sy0,tv0,tw0","","91.,92.,93.,94.,95.,96.,9z.,a0.,a1.,a2.,a3.,a4.,an.,ao.,aw.,ax.,ay.,az.,b0.,b1.,b2.,bl.,bm.,bn.,bo.,bp.,bq.,br.,bu.,bv.,bw.,bx.,by.,bz.,c0.,cj.,ck.,cl.,cm.,cn.,co.,cp.,cq.,cr.,cs.,ct.,cu.,cv.,cw.,cx.,cy.,cz.,d0.,d1.,d2.,d3.,dj.,dk.,dl.,dm.,dn.,do.,dp.,dq.,dr.,ds.,dt.,du.,dv.,dw.,dx.,dy.,dz.,e0.,e1.,ee0,ef0,eg0,eh0,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,eu.,ev.,ew.,ex.,ey.,ez.,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,fs.,ft.,fu.,fv.,fw.,fx.,g40,ga0,gb0,gc0,gd0,ge0,gf0,gg0,gh0,gn.,go.,gp.,gq.,gr.,gs.,gt.,gu.,h40,h50,h60,h71,h80,ho.,hp.,hq.,hr.,hs.,hy0,i00,i20,i30,i40,i51,i60,im.,in.,io.,ip.,iq.,iw0,iy0,j00,j10,j20,j31,j40,jk.,jl.,jm.,jn.,jo.,ju0,jy0,jz0,k00,k11,k20,k30,k42,k52,k60,k70,k80,ki.,kj.,kk.,kl.,ks0,l00,l10,l22,l32,l40,l50,l60,l70,lg.,lh.,li.,lj.,lq0,ly0,lz0,m00,m10,m20,m30,m40,m50,ma2,mb2,me.,mf.,mg.,mh.,mp0,mw0,mx0,my0,mz0,n00,n10,n20,n30,n82,n92,nc.,nd.,ne.,nf.,nn0,nu0,nv0,nw0,nx0,ny0,nz0,o00,o60,o70,oa1,oe0,om0,on0,os0,ot0,ou0,ov0,ow0,ox0,p11,p40,p50,p81,pb0,pc0,pd0,pp0,pq0,pr0,ps0,pt0,pu0,pz1,q51,q61,q90,qa0,qb0,qc0,ql0,qm0,qn0,qo0,qp0,qr0,qv0,qw0,qx1,r31,r5.,r6.,rh0,ri0,rj0,rk0,rl0,ro0,rp0,ru0,rv1,rw0,rx0,s00,s11,s3.,s4.,s5.,sf0,sg0,sh0,si0,sm0,sn0,so0,sp0,su0,sv0,sz1,t1.,t2.,t3.,td0,te0,tf0,tl0,tm0,ts0,tt0,tu0,ty.,tz.,u0.,u1.","","ee.,ef.,eg.,eh.,el0,em0,fa1,fb1,fc1,fd.,fe.,ff.,fg.,fh.,fk0,fl0,g4.,g61,g71,g81,g91,ga1,gb1,gc.,gd.,ge.,gf.,gh1,gi1,gj1,gk1,gl.,gm.,h41,h51,h61,h81,h91,ha.,hb.,hc.,hd.,he.,hf1,hg1,hh1,hi1,hr0,hy.,i0.,i2.,i31,i41,i61,i71,i81,i9.,ia1,ib1,ic1,id1,ie1,if1,ig1,in0,io0,ip0,iq0,iw.,iy.,j0.,j11,j21,j41,j51,j61,j71,j81,j91,ja1,jb1,jc1,jd1,je1,jk1,jl0,jm0,jn0,jo0,ju.,jy.,jz.,k01,k21,k31,k41,k51,k61,k71,k81,k91,ka1,kb1,kc1,kf2,kg2,ki1,kj0,kk0,kl0,ko0,ks.,ky1,kz1,l01,l11,l21,l31,l41,l51,l61,l71,l81,l91,la1,ld2,le2,lg1,lh1,li0,ln0,lq.,lx1,ly1,lz1,m01,m11,m21,m31,m41,m51,m61,m71,m81,ma0,mb0,me1,mf1,ml0,mp.,mw1,mx1,my1,mz1,n01,n11,n21,n31,n41,n51,n61,n71,n80,n90,nj0,nl0,nn.,nu1,nv1,nw1,nx1,ny1,nz1,o01,o11,o21,o31,o41,o51,oa.,ob.,oc.,od.,oe.,oh0,oj0,om.,on.,oo0,os1,ot1,ou1,ov1,ow1,ox1,oy1,oz1,p01,p21,p31,p8.,p9.,pa.,pb.,pc.,pd.,ph0,pm0,pp.,pq1,pr1,ps1,pt1,pu1,pv1,pw1,px1,py1,q01,q11,q21,q50,q71,q81,qc.,qf0,qm.,qn.,qo.,qp1,qq1,qr1,qs1,qt1,qu1,qv1,qw1,qy1,qz1,r01,r30,r41,r51,r60,r70,r80,r90,rc0,rh.,ri.,rj.,rl.,ro1,rp1,rq1,rr1,rs1,rt1,ru1,rw1,rx1,ry1,s10,s90,sf.,sg.,sh.,si.,sm.,sn.,so.,sp.,st1,su1,sv1,sw1,sx1,sy.,sz.,t0.,td.,te.,tf.,tl.,tm.,tr0,tw.","","di0,dj0,dk0,dl0,ee0,ef0,el.,em.,en0,eo0,fa.,fb.,fc.,fi.,fj.,fm0,fn0,ft1,fu1,fv1,g6.,g7.,g8.,g9.,ga.,gb.,gg.,gh.,gl1,gq1,gr1,gs1,gt1,gu1,gv1,h4.,h5.,h60,h7.,h8.,h9.,ha0,hb0,hc0,hd0,he0,hj.,hk.,hl.,hm.,hn.,ho1,hp1,hq1,hr1,hs1,ht1,i30,i40,i50,i60,i7.,i80,i90,ia0,ib0,ic0,id0,ih1,ii1,ij1,ik.,il1,im1,in1,io1,ip1,iq1,j10,j20,j30,j60,j70,j80,j90,ja0,jb0,jf1,jg1,jh1,ji1,jj1,jl1,jm1,jn1,jo1,jq0,k00,k10,k42,k52,k60,k70,k80,k90,ka0,kd1,ke1,kf1,kg1,kh1,kj1,kk1,kl1,ko.,kp0,ky.,kz0,l22,l32,l40,l50,l60,l70,l80,lb1,lc1,ld1,le1,lf1,li1,lj1,lx.,m00,m10,m20,m30,m40,m50,m60,m91,ma1,mb1,mc1,md1,mg1,ml.,mw.,mx.,my0,mz0,n00,n10,n20,n30,n40,n81,n91,na1,nb1,nc1,nd1,nj.,nl.,nu.,nv.,nw0,nx0,ny0,nz0,o00,o10,o20,o61,o71,o81,o91,oa1,ob1,oh.,oj.,oo.,os.,ot.,ou0,ov0,ow0,ox0,oy0,oz0,p00,p41,p51,p61,p71,p81,p91,ph.,pn0,po0,pp0,ps0,pu0,pv0,pw0,px0,py0,q31,q41,q51,q8.,q9.,qa.,qb.,qf.,qk0,qm0,qn0,qo1,qq0,qs0,qt0,qu0,qv0,qw0,r11,r21,r31,r5.,r6.,r7.,r8.,r9.,rc.,rk.,rn1,ro0,rq0,rr0,rs0,rt0,ru0,rz1,s01,s11,s2.,s9.,so0,sp0,sq0,sr0,ss0,st.,su.,sv.,sw.,sx.,tm0,tn0,to0,tp0,tq0,tr.,ts.,tt.,tu.,tv.","","di.,dj.,dk.,dl.,ee.,ef.,en.,eo.,fe0,ff0,fh0,fi0,fk1,fl1,fm.,fn1,fo1,ft.,fu.,fv.,gc0,gd0,gf0,gg0,gk.,gm1,gq.,gr.,gs.,gt.,gu.,gv.,h6.,hc.,hf.,hi.,hj1,hk1,hn0,ho0,hp0,hq.,hr.,hs.,ht.,i3.,i70,id1,ij.,il.,im.,in.,io0,ip0,iq.,j1.,j40,j50,jb1,jg.,jh.,ji.,jj.,jk.,jl.,jm.,jn.,jo0,jq.,k20,k30,k40,k50,kb0,kc0,kd2,ke2,kf0,kg0,kh.,ki.,kj.,kk.,kl.,km0,kp.,ky0,l00,l10,l20,l30,l90,la0,lb2,lc2,ld0,le0,lf.,lg.,lh.,li.,lj.,lk0,ln.,lw0,lx0,ly0,lz0,m70,m80,m90,ma0,mb0,mc0,md.,me.,mf.,mg0,mh0,mu0,mv0,mw0,mx0,n50,n60,n70,n80,n90,na0,nb.,nc.,nd.,nu1,nv1,nw1,nx1,ny1,nz1,o01,o11,o30,o40,o50,o60,o70,o80,o9.,oa.,ob.,os0,ot0,p10,p20,p30,p40,p50,p60,p7.,p8.,p9.,pm.,pn.,po.,pp.,pq0,pr0,pt0,pz0,q00,q10,q20,q30,q40,q5.,q6.,q7.,qk.,ql.,qm.,qn.,qo0,qp0,qr0,qx0,qy0,qz0,r00,r10,r20,r3.,r4.,rm0,rn0,rp0,rv0,rw0,rx0,ry0,rz0,s00,s1.,sk0,sl0,sm0,sn0,st0,su0,sv0,sw0,sx0,sy0,tj0,tk0,tl0,tr0,ts1,tt0,tu0,tv1","","fd1,fe1,ff.,fg1,fh1,fi.,fj1,fl.,fm1,fo.,g91,ga1,gb1,gc1,gd.,ge1,gf1,gg.,gh1,gj.,gk1,gn1,go1,gp1,h71,h81,h91,ha1,hb.,hc1,hd1,he.,hf1,hh.,hi1,hl1,hm1,hn1,ho.,hp.,i10,i20,i51,i61,i71,i82,i92,id0,ie0,if0,ig0,ih2,ii2,ij0,ik0,il1,im0,io.,ip.,ix0,iy0,j31,jb0,jc0,jd0,je0,jf0,jg0,jh0,ji0,jj1,jk0,jo.,ju0,k11,kd0,ke0,kh1,ki0,km.,ks0,kz1,lb0,lc0,lf1,lg0,lk.,lr0,lw.,lx.,mg.,mh.,mu.,mv.,nu0,nv0,nw0,nx0,ny0,nz0,o00,o10","","fc1,fe.,ff1,fh.,fi0,fj0,fk.,fl0,fm0,fn.,g9.,gc.,gd1,gf.,gg0,gh0,gi.,gj0,gk0,gl.,gm.,gn.,go.,gp.,h7.,ha.,hb1,hd.,he0,hf0,hg.,hh0,hi0,hj.,hk.,hl.,hm.,hn.,i1.,i2.,i4.,i5.,i81,i91,ia1,ib1,ih0,ii0,il.,im.,ix.,iy.,j2.,j3.,j4.,j51,j61,j71,j81,j91,jj.,jk.,ju.,k10,k22,k32,kh.,ki.,kk0,ks.,kz0,l02,l12,lf.,lg.,lj0,lr.,lw0,lx0,mh0,mu0,mv0,nf0,ns0,nt0,nz1,o01,o11,o21,o31,o41,o51,o61,o7.,o8.,od0,oq0,or0,p5.,p6.,p90,pa0,po0,pp0,q3.,q4.,q50,q60,qm0,qn0,r1.,r2.,rk0,rl0,rz.,s0.,si0,sj0,sx.,sy.,th1,ti0,tk1,ts0,tu.,tv.","","dg0,dh0,di0,dj0,dk0,dl0,dm0,dn0,do0,dp0,ec0,ed0,fc.,fd.,fi1,fj1,fl1,fm1,fo1,fp1,g91,gc1,gg1,gh1,gj1,gk1,gm1,gn1,go1,gp1,gr0,gs0,h20,h30,h71,ha1,he1,hf1,hh1,hi1,hk1,hl1,hm1,hn1,i00,i40,i51,i60,i70,i82,i92,ia0,ib0,ih2,ii2,ij1,ik1,il1,im0,j20,j31,j40,j50,j60,j70,j80,j90,jj1,jk0,k11,k20,k30,kh1,ki0,kk.,kz1,l00,l10,lf1,lg0,lj.,lw.,lx.,mh.,mu.,mv.,nf.,ns.,nt.,nz0,o00,o10,o20,o30,o40,o50,o60,o70,o80,od.,oq.,or.,p50,p60,p9.,pa.,po.,pp.,q30,q40,q5.,q6.,qm.,qn.,r10,r20,rk.,rl.,rz0,s00,si.,sj.,sx0,sy0,th.,ti.,tj1,tk0,tm1,tu0,tv0","","dg.,dh.,di.,dj.,dk.,dl.,dm.,dn.,do.,dp.,ec.,ed.,fe0,ff0,fg.,fh0,fi0,fj.,fk1,fm.,fn1,fp.,g9.,ga.,gb.,gc0,gd0,ge.,gf0,gg0,gh.,gi1,gk.,gl1,gn.,go.,gp.,gr.,gs.,h2.,h3.,h7.,h8.,h9.,ha0,hb0,hc.,hd0,he0,hf.,hg1,hi.,hj1,hl.,hm.,hn0,ho0,hp0,i0.,i50,i80,i90,id1,ie1,if1,ig1,ih1,ii1,ij.,ik.,il.,im.,io0,ip0,j30,jb1,jc1,jd1,je1,jf1,jg.,jh.,ji.,jj.,jk.,jo0,k10,kd2,ke2,kh.,ki.,km0,kz0,lb2,lc2,lf.,lg.,lk0,lw0,lx0,mg0,mh0,mu0,mv0,nu1,nv1,nw1,nx1,ny1,nz1,o01,o11,tj0,tm0,ts1,tv1","","fd1,fe1,ff.,fg1,fh1,fi.,fj1,fl.,fm1,fo.,g91,ga1,gb1,gc1,gd.,ge1,gf1,gg.,gh1,gj.,gk1,gn1,go1,gp1,h71,h81,h91,ha1,hb.,hc1,hd1,he.,hf1,hh.,hi1,hl1,hm1,hn1,ho.,hp.,i10,i20,i51,i61,i71,i82,i92,id0,ie0,if0,ig0,ih2,ii2,ij0,ik0,il1,im0,io.,ip.,ix0,iy0,j31,jb0,jc0,jd0,je0,jf0,jg0,jh0,ji0,jj1,jk0,jo.,ju0,k11,kd0,ke0,kh1,ki0,km.,ks0,kz1,lb0,lc0,lf1,lg0,lk.,lr0,lw.,lx.,mg.,mh.,mu.,mv.,nu0,nv0,nw0,nx0,ny0,nz0,o00,o10","","fc1,fe.,ff1,fh.,fi0,fj0,fk.,fl0,fm0,fn.,g9.,gc.,gd1,gf.,gg0,gh0,gi.,gj0,gk0,gl.,gm.,gn.,go.,gp.,h7.,ha.,hb1,hd.,he0,hf0,hg.,hh0,hi0,hj.,hk.,hl.,hm.,hn.,i1.,i2.,i4.,i5.,i81,i91,ia1,ib1,ih0,ii0,il.,im.,ix.,iy.,j2.,j3.,j4.,j51,j61,j71,j81,j91,jj.,jk.,ju.,k10,k22,k32,kh.,ki.,kk0,ks.,kz0,l02,l12,lf.,lg.,lj0,lr.,lw0,lx0,mh0,mu0,mv0,nf0,ns0,nt0,nz1,o01,o11,o21,o31,o41,o51,o61,o7.,o8.,od0,oq0,or0,p5.,p6.,p90,pa0,po0,pp0,q3.,q4.,q50,q60,qm0,qn0,r1.,r2.,rk0,rl0,rz.,s0.,si0,sj0,sx.,sy.,th1,ti0,tk1,ts0,tu.,tv.","","dg0,dh0,di0,dj0,dk0,dl0,dm0,dn0,do0,dp0,ec0,ed0,fc.,fd.,fi1,fj1,fl1,fm1,fo1,fp1,g91,gc1,gg1,gh1,gj1,gk1,gm1,gn1,go1,gp1,gr0,gs0,h20,h30,h71,ha1,he1,hf1,hh1,hi1,hk1,hl1,hm1,hn1,i00,i40,i51,i60,i70,i82,i92,ia0,ib0,ih2,ii2,ij1,ik1,il1,im0,j20,j31,j40,j50,j60,j70,j80,j90,jj1,jk0,k11,k20,k30,kh1,ki0,kk.,kz1,l00,l10,lf1,lg0,lj.,lw.,lx.,mh.,mu.,mv.,nf.,ns.,nt.,nz0,o00,o10,o20,o30,o40,o50,o60,o70,o80,od.,oq.,or.,p50,p60,p9.,pa.,po.,pp.,q30,q40,q5.,q6.,qm.,qn.,r10,r20,rk.,rl.,rz0,s00,si.,sj.,sx0,sy0,th.,ti.,tj1,tk0,tm1,tu0,tv0","","dg.,dh.,di.,dj.,dk.,dl.,dm.,dn.,do.,dp.,ec.,ed.,ff.,fg.,fi.,fj.,fl.,fm.,fo.,fp.,g9.,ga.,gb.,gc.,gd.,ge.,gg.,gh.,gj.,gk.,gm.,gn.,go.,gp.,gr.,gs.,h2.,h3.,h7.,h8.,h9.,ha0,hb0,hc0,hd0,he0,hf0,hg0,hh0,hi0,hk.,hl.,hm.,hn.,i0.,i4.,i5.,i6.,i7.,i80,i90,ih0,ii0,ij0,ik.,il.,im.,j2.,j3.,j4.,j5.,jk1,jl1,jm1,jn1,jo1,k0.,k1.,k2.,k3.,ki1,kj1,kk1,kl1,km1,kn1,ky.,kz.,l0.,l1.,lf0,lg1,lh1,li1,lj1,lk1,ll1,ly.,lz.,md0,me1,mf1,mg1,mh1,mi1,mj1,mw.,mx.,my2,mz2,n62,n72,nb0,nc1,nu.,nv.,nw2,nx2,o42,o52,o90,oa1,os.,ot1,p71,p81,p91,pa1,pb1,pc1,pr1,pw1,q11,q51,q61,q71,q81,q91,qa1,qn0,qp1,qu1,qz1,r31,r41,r51,r61,r71,r81,rk0,rl0,rn1,rs1,rx1,s10,si0,sj0,sl.,sq.,sr.,ss.,st.,su.,sv.,sz0,tj.,tm0,to.,tp.,tq.,tr.,ts.,tt.,tw0","","h80,h90,hj0,hk0,hl0,hm0,hn0,i61,i70,ik0,il0,j40,j50,jj0,jk.,jl.,jm.,jn.,jo.,k20,k30,kh0,ki.,kj.,kk.,kl.,km.,kn.,l00,l10,lg.,lh.,li.,lj.,lk.,ll.,ly0,lz0,m02,m12,ma2,mb2,me.,mf.,mg.,mh.,mi.,mj.,ms0,mt0,mu0,mv0,mw0,mx0,n60,n70,n82,n92,nc0,nd0,ne0,nf0,nq0,nr0,ns0,nt0,nu0,nv0,nw0,nx0,o40,o50,oa0,ob0,oc0,od0,oo0,op0,oq0,or0,os0,ot0,p70,p80,p90,pa0,pb0,pc.,pm0,pn0,po0,pp0,pr0,pw0,q10,q50,q60,q70,q80,q90,qa.,qn.,qp0,qu0,qz0,r30,r4.,r5.,r6.,r7.,r8.,rk.,rl.,rn0,rs0,rx0,si.,sj.,sk1,sl1,sm.,sn.,so1,sp1,su1,sv1,sw.,sx.,sy1,sz1,ti0,tj0,tk.,tl.,ts0,tt0,tu.,tv.,tx0","7q0,7r0,7s0,7t0,860,870,880,890,8o0,8p0,8q0,8r0,940,950,960,970,9m0,9n0,9o0,9p0,9q0,9r0,9s0,9t0,9u0,9v0,9w0,9x0,9y0,9z0,a00,a10,a20,a30,a40,a50,ak0,al0,am0,an0,ao0,ap0,aq0,ar0,as0,at0,au0,av0,aw0,ax0,ay0,az0,b00,b10,b20,b30,bk0,bl0,bm2,bn2,bo0,bp0,bq0,br0,bs0,bt0,bu0,bv0,bw2,bx2,by0,bz0,ci0,cj0,ck2,cl2,cm0,cn0,co0,cp0,cq0,cr0,cs0,ct0,cu2,cv2,cw0,cx0,dg0,dh0,di2,dj2,dk0,dl0,dm0,dn0,do0,dp0,dq0,dr0,ds2,dt2,du0,dv0,ee0,ef0,eg2,eh2,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq2,er2,es0,et0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,ga0,gb0,gc0,gd0,ge0,gf0,gg0,gh0,gi0,gj0,gk0,gl0,gm0,gn0,go0,gp0,i60,m00,m10,ma0,mb0,ms.,mt.,mu.,mv.,my.,mz.,n2.,n3.,n4.,n5.,n8.,n9.,nc.,nd.,ne.,nf.,nq.,nr.,ns.,nt.,nw.,nx.,o0.,o1.,o2.,o3.,o6.,o7.,oa.,ob.,oc.,od.,oo.,op.,oq.,or.,ou.,ov.,oy.,oz.,p0.,p1.,p4.,p5.,p8.,p9.,pa.,pb.,pm.,pn.,po.,pp.,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,q6.,q7.,q8.,q9.,qq.,qr.,qu.,qv.,qw.,qx.,r0.,r1.,rm.,rn.,ro.,rp.,rq.,rr.,rs.,rt.,ru.,rv.,rw.,rx.,ry.,rz.,s0.,s1.,sk.,sl.,so.,sp.,su.,sv.,sy.,sz.,ti.,tj.,tm.,tn.,ts.,tt.,tw.,tx.","5x0,5y0,5z0,600,670,680,690,6a0,6v0,6w0,6x0,6y0,750,760,770,780,7q.,7r.,7s.,7u0,7v0,7w0,830,840,850,87.,88.,89.,8o.,8p.,8q.,8s0,8t0,8u0,910,920,930,95.,96.,97.,9m.,9n.,a4.,a5.,ak.,al.,b2.,b3.,di0,dj0,ds0,dt0,eg0,eh0,eq0,er0,l2.,l3.,l6.,l7.,l8.,l9.,lc.,ld.,m0.,m1.,m4.,m5.,m6.,m7.,ma.,mb.,os.,ot.,ow.,ox.,p2.,p3.,p6.,p7.,pq.,pr.,pu.,pv.,q0.,q1.,q4.,q5.,qo.,qp.,qs.,qt.,qy.,qz.,r2.,r3.","290,2c0,2f0,380,3a0,3c0,520,530,540,550,560,570,580,590,5x.,5y.,5z.,610,620,630,640,650,660,68.,69.,6a.,6v.,6w.,6x.,6z0,700,710,720,730,740,76.,77.,78.,7t.,7u.,7v.,7x0,7y0,7z0,800,810,820,84.,85.,86.,8q0,8v0,8w0,8x0,8y0,8z0,900,950,ao2,ap2,ay2,az2,ck0,cl0,cu0,cv0,k4.,k5.,k8.,k9.,ka.,kb.,ke.,kf.,nu.,nv.,ny.,nz.,o4.,o5.,o8.,o9.","b0,g0,k0,1a0,1h0,29.,2c.,2f.,38.,3a.,3c.,4z0,500,510,53.,54.,55.,56.,57.,58.,5a0,5b0,5c0,5x0,5y0,5z0,61.,62.,63.,64.,65.,66.,680,690,6a0,6v0,6w0,6x0,6z.,70.,71.,72.,73.,74.,760,770,780,7t0,7u0,7v0,7x.,7y.,7z.,80.,81.,82.,840,850,860","b.,g.,k.,1a.,1h.,4z.,50.,51.,52.,59.,5a.,5b.,5c.,5x.,5y.,5z.,60.,67.,68.,69.,6a.,6t0,6u0,6x.,6y.,75.,76.,790,7a0,7r0,7s0,7v.,7w.,83.,84.,870,880,8p0,8t.,8u.,8v.,8w.,8x.,8y.,8z.,90.,91.,92.,960,9n0,a40,ao0,ap0,ay0,az0,ck2,cl2,cu2,cv2,k40,k50,k80,k90,ka0,kb0,ke0,kf0,nu0,nv0,ny0,nz0,o40,o50,o80,o90","6t.,6u.,6v.,6w.,77.,78.,79.,7a.,7r.,7s.,7t.,7u.,85.,86.,87.,88.,8p.,8q.,8r.,8s.,93.,94.,95.,96.,9n.,9o.,9p.,9q.,9r.,9s.,9t.,9u.,9v.,9w.,9x.,9y.,9z.,a0.,a1.,a2.,a3.,a4.,am.,an.,ao.,ap.,aq.,ar.,as.,at.,au.,av.,aw.,ax.,ay.,az.,b0.,b1.,bk.,bl.,bm.,bn.,bo.,bp.,bq.,br.,bs.,bt.,bu.,bv.,bw.,bx.,by.,bz.,ck0,cl0,cu0,cv0,cx.,eg2,eh2,eq2,er2,fe2,ff2,fo2,fp2,gc2,gd2,gm2,gn2,h40,h50,h60,h70,ha2,hb2,hk2,hl2,ho0,hp0,hq0,hr0,i20,i30,i40,i50,i82,i92,ii2,ij2,im0,in0,io0,ip0,j00,j10,j20,j30,jk0,jl0,jm0,jn0,jy0,jz0,k00,k10,ki0,kj0,kk0,kl0,kw0,kx0,ky0,kz0,l20,l30,l60,l70,l80,l90,lc0,ld0,lg0,lh0,li0,lj0,lv0,lw0,lx0,m00,m10,m40,m50,m60,m70,ma0,mb0,me0,mf0,mg0,mu0,mv0,my0,mz0,n20,n30,n40,n50,n80,n90,nc0,nd0,nw0,nx0,o00,o10,o20,o30,o60,o70,os0,ot0,ou0,ov0,ow0,ox0,oy0,oz0,p00,p10,p20,p30,p40,p50,p60,p70,pq0,pr0,ps0,pt0,pu0,pv0,pw0,px0,py0,pz0,q00,q10,q20,q30,q40,q50,qn0,qo0,qp0,qr0,qs0,qt0,qu0,qy0,qz0,r00,r20,r30,r40,rl0,rm0,rp0,rq0,rx0,ry0,s10,s20,sj0,sk0,sl0,sn0,so0,sp0,su0,sv0,sw0,sy0,sz0,t00,ti0,tj0,tm0,tn0,ts0,tt0,tw0,tx0","ci.,cj.,ck.,cl.,cm.,cn.,co.,cp.,cq.,cr.,cs.,ct.,cu.,cv.,cw.,dg.,dh.,di.,dj.,dk.,dl.,dm.,dn.,do.,dp.,dq.,dr.,ds.,dt.,du.,dv.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,gc0,gd0,gm0,gn0,h4.,h5.,h6.,h7.,ha0,hb0,hk0,hl0,ho.,hp.,hq.,hr.,i2.,i3.,i4.,i5.,im.,in.,io.,ip.,j0.,j1.,j2.,j3.,j62,j72,jg2,jh2,jk.,jl.,jm.,jn.,jy.,jz.,k0.,k1.,k42,k52,ke2,kf2,ki.,kj.,kk.,kl.,kw.,kx.,ky.,kz.,lg.,lh.,li.,lj.,lu0,mh0,ms0,mt0,ne0,nf0,nq0,nr0,ns0,nt0,oa0,ob0,oc0,od0,oo0,op0,oq0,or0,p80,p90,pa0,pb0,qq0,qv0,qw0,qx0,r10,rr0,rs0,rt0,ru0,rv0,rw0","i80,i90,ii0,ij0,j82,jf2,jy0,jz0,k00,k10,k40,k50,ke0,kf0,ki0,kj0,kk0,kl0,kw0,kx0,ky0,kz0,lg0,lh0,li0,lj0,nq.,nr.,ns.,nt.,oa.,ob.,oc.,od.,oo.,op.,oq.,or.,p8.,p9.,pa.,pb.,qn.,r4.,rl.,rn0,rp.,rs.,rt.,ru.,rv.,ry.,s00,s2.,sj.,sn.,sw.,t0.","ee1,ef1,eg1,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,fc1,fd1,fe1,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,ga1,gb1,gc1,gf2,gg2,gn2,go2,h81,h91,ha1,hd2,he2,hl2,hm2,i21,i31,i41,i50,im0,in0,io0,j01,j11,j21,j30,j60,j70,j80,jf0,jg0,jh0,jk0,jl0,jm0,jy1,jz1,k01,kl.,kw1,kx1,ky1,lj.,lu.,lv.,lw.,lx.,ly1,lz1,m01,me.,mf.,mg.,mh.,ms.,mt.,mu.,mv.,mw1,mx1,my1,nc.,nd.,ne.,nf.,nu1,nv1,nw1,os1,ot1,ou1,pq1,pr1,ps1,qo1,qp1,qq.,qr.,qs.,qv.,qw.,qz.,r0.,r1.,rm1,rn1,ro1,rq.,rs0,rv0,rx.,rz0,sk.,sl1,sm1,so.,sq0,st0,sv.,sx0,sz.,ti.,tj.,tm.,to0,tr0,tt.,tw.,tx.","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,gf0,gg0,gn0,go0,i2.,i3.,i4.,i5.,i61,i71,i81,ib2,ic2,ij2,ik2,im.,in.,io.,lu1,lv1,lw1,lx0,ly0,lz0,m00,me0,mf0,mg0,qo.,qq1,r10,r3.,rm.,s1.,tj1,tk1,tv0,tw0","fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,hd0,he0,hl0,hm0,j0.,j1.,j2.,j3.,j41,j51,j61,j92,ja2,jh2,ji2,jk.,jl.,jm.,ms1,mt1,mu1,mv0,mw0,mx0,my0,nc0,nd0,ne0,qo1,qr0,qs0,qv0,qw0,qz0,r00,r30,rm1,ro.,rq0,rs.,rv.,rx0,rz.,s10,sk1,so0,sv0,sz0","","em0,en0,eo0,ep0,eq0,er0,es0,et0,fc1,fd1,fe1,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,gn2,go2,hd2,he2,hl2,hm2,ho0,hp0,hq0,ij0,ik0,im0,in0,io0,j90,ja0,jh0,ji0,jk0,jl0,jm0,jy.,jz.,k0.,k1.,k21,k31,k41,lg.,lh.,li.,me.,mf.,mg.,nc.,nd.,ne.,nq1,nr1,ns1,nt0,nu0,nv0,nw0,qo.,qr.,qs.,qv.,qw.,qz.,r0.,r1.,r40,rm.,ro1,rq.,rs0,rv0,rx.,s0.,s20,sk.,so.,sv.,sx.,sy.,t00,tv.,tw.","","em.,en.,eo.,ep.,eq.,er.,es.,et.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,gn0,go0,hd0,he0,hl0,hm0,ho.,hp.,hq.,ij2,ik2,im.,in.,io.,j92,ja2,jh2,ji2,jk.,jl.,jm.,jy1,jz1,k01,k10,k20,k30,k40,lg0,lh0,li0,me0,mf0,mg0,nc0,nd0,ne0,nq.,nr.,ns.,nt.,nu1,nv1,nw1,qo1,qr0,qs0,qv0,qw0,qz0,r00,r10,r4.,rm1,ro.,rq0,rs.,rv.,rx0,s00,s2.,sk1,so0,sv0,sx0,sy0,t0.,tv0,tw0","","ee1,ef1,eg1,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,fc1,fd1,fe1,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,gf2,gg2,h41,h51,h61,h70,h80,h90,ha0,hd2,he2,hl2,hm2,i21,i31,i41,i50,i60,i70,i80,ib0,ic0,j01,j11,j21,j30,j40,j50,j60,j90,ja0,jh0,ji0,ki.,kj.,kk.,kw.,kx.,ky.,kz.,l01,l11,lu.,lv.,lw.,lx.,ly1,lz1,ms.,mt.,mu.,mv.,mw1,mx1,nw0,oa0,ob0,oc0,or1,ot0,ou0,pp1,pr0,ps0,qm1,qn1,qp.,qq.,qr.,qs.,qv.,qw.,qz.,r0.,r3.,rk1,rl1,rm.,rn.,rq.,rs0,rv0,rx.,rz0,s1.,si1,sj1,sk.,sl.,sm.,so.,sv.,sz.,tj.,tk.","","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,gf0,gg0,h4.,h5.,h6.,h7.,h81,h91,ha1,hd0,he0,hl0,hm0,i2.,i3.,i4.,i5.,i61,i71,i81,ib2,ic2,j0.,j1.,j2.,j3.,j41,j51,j61,j92,ja2,jh2,ji2,ki0,kj0,kk0,kw1,kx1,ky1,kz0,l00,l10,lu1,lv1,lw1,lx0,ly0,lz0,ms1,mt1,mu1,mv0,mw0,mx0,nw1,oa.,ob.,oc.,or.,ot1,ou1,pp.,pr1,ps1,qm.,qn.,qp1,qq1,qr0,qs0,qv0,qw0,qz0,r00,r30,rk.,rl.,rm1,rn1,rq0,rs.,rv.,rx0,rz.,s10,si.,sj.,sk1,sl1,sm1,so0,sv0,sz0,tj1,tk1","","ee1,ef1,eg1,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,fc1,fd1,fe1,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo0,fp0,fq0,fr0,gf2,gg2,gn2,go2,hd2,he2,hl2,hm2,i21,i31,i41,i50,i60,i70,i80,ib0,ic0,ij0,ik0,im0,in0,io0,j01,j11,j21,j30,j40,j50,j60,j90,ja0,jh0,ji0,jk0,jl0,jm0,lu.,lv.,lw.,lx.,ly1,lz1,m01,me.,mf.,mg.,ms.,mt.,mu.,mv.,mw1,mx1,my1,nc.,nd.,ne.,qq.,qr.,qs.,qv.,qw.,qz.,r0.,r1.,ro1,rq.,rs0,rv0,rx.,rz0,sk.,so.,sv.,sz.,tj.,tk.,tv.,tw.","","ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,fr.,ga0,gb0,gc0,gf0,gg0,gn0,go0,h80,h90,ha0,hd0,he0,hl0,hm0,i2.,i3.,i4.,i5.,i82,i92,ii2,ij2,im.,in.,io.,j0.,j1.,j2.,j3.,j62,j72,jg2,jh2,jk.,jl.,jm.,jy0,jz0,k00,kl0,kw0,kx0,ky0,lj0,lu0,lv0,lw0,lx0,ly0,lz0,m00,me0,mf0,mg0,mh0,ms0,mt0,mu0,mv0,mw0,mx0,my0,nc0,nd0,ne0,nf0,nu0,nv0,nw0,os0,ot0,ou0,pq0,pr0,ps0,qn0,qo0,qp0,qq0,qr0,qs0,qv0,qw0,qz0,r00,r10,r40,rl0,rm0,rn.,ro.,rp0,rq0,rr.,rs.,rv.,rw.,rx0,ry0,rz.,s0.,s20,sj0,sk0,sl.,sm.,sn0,so0,sq.,st.,sv0,sw0,sx.,sy.,sz0,t00,th0,ti0,tm0,to.,tr.,tt0,tx0,ty0","","ed0,ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq1,er1,es1,fb0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo1,fp1,fq1,g90,ga2,gb2,gi2,gj2,gm1,gn1,go1,gp.,h70,h82,h92,hg2,hh2,hk1,hl1,hm1,hn.,i20,i30,i40,i50,i80,i90,ii0,ij0,im1,in1,io1,j00,j10,j20,j30,j60,j70,jg0,jh0,jk1,jl1,jm1,ki1,kj1,kk1,kl.,lg1,lh1,li1,lj.,lu.,lv.,lw.,ma1,mb1,mc1,md.,me.,mf.,mg.,mh.,ms.,mt.,mu.,n81,n91,na1,nb.,nc.,nd.,ne.,nf.,nt0,o61,o71,o81,o9.,or0,p41,p51,p61,p7.,pp0,q21,q31,q41,q5.,qp.,qq.,qr.,qu.,qv.,qy.,qz.,r0.,r11,r21,r3.,r4.,rn0,rp.,rr0,ru0,rv0,rx.,ry1,rz1,s01,s1.,s2.,sj.,sl0,sn.,ss0,st0,su.,sv.,sw1,sx1,sz.,t0.,th.,ti.,tq0,tr0,ts.,tt.,tx.,ty.","ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,ga0,gb0,gi0,gj0,i2.,i3.,i4.,i62,i72,ie2,if2,ii1,ij1,ik1,il.,im.,in.,io.,lu0,lv0,lw0,ma0,mb0,mc0,md0,me1,mf1,mg1,qn.,qp0,r01,r2.,rl.,s0.,ti0,tj0,tu1,tv1","fb.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,h80,h90,hg0,hh0,j0.,j1.,j2.,j42,j52,jc2,jd2,jg1,jh1,ji1,jj.,jk.,jl.,jm.,ms0,mt0,mu0,n80,n90,na0,nb0,nc1,nd1,ne1,qn0,qq0,qr0,qu0,qv0,qy0,qz0,r21,rl0,rn.,rp0,rr.,ru.,rw0,ry.,s01,sj0,sn0,su0,sy1","","ed0,ee0,ef0,eg0,eh0,ei0,ej0,ek0,fb0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo1,fp1,fq1,ga2,gb2,h40,h50,h60,h82,h92,hg2,hh2,i20,i30,i40,i60,i70,j00,j10,j20,j40,j50,jc0,jd0,ke1,kf1,kg1,kh.,ki.,kj.,kk.,kw.,kx.,ky.,lu.,lv.,lw.,ms.,mt.,mu.,o60,o70,o80,o90,oa1,ob1,oc1,qm0,qp.,qq.,qr.,qu.,qv.,qy.,qz.,r2.,rk0,rm.,rp.,rr0,ru0,rw.,ry1,s0.,si0,sk.,sl.,sn.,su.,sy.,ti.,tj.","","ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,fb.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,ga0,gb0,h4.,h5.,h6.,h80,h90,hg0,hh0,i2.,i3.,i4.,i62,i72,j0.,j1.,j2.,j42,j52,jc2,jd2,ke0,kf0,kg0,kh0,ki1,kj1,kk1,kw0,kx0,ky0,lu0,lv0,lw0,ms0,mt0,mu0,o61,o71,o81,o9.,oa.,ob.,oc.,qm.,qp0,qq0,qr0,qu0,qv0,qy0,qz0,r21,rk.,rm0,rp0,rr.,ru.,rw0,ry.,s01,si.,sk0,sl0,sn0,su0,sy1,ti0,tj0","","ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq1,er1,es1,fb0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo1,fp1,fq1,gi2,gj2,h82,h92,hg2,hh2,hk0,hl0,hm0,hn0,ho1,hp1,hq1,ie0,if0,ii0,ij0,ik0,il0,im1,in1,io1,j40,j50,jc0,jd0,jg0,jh0,ji0,jj0,jk1,jl1,jm1,jy.,jz.,k0.,ld1,le1,lf.,lg.,lh.,li.,mb1,mc1,md.,me.,mf.,mg.,n91,na1,nb.,nc.,nd.,ne.,nq0,nr0,ns0,o60,p40,p50,p71,q20,q30,q51,qn.,qq.,qr.,qu.,qv.,qy.,qz.,r0.,r1.,r31,r41,rl.,rn0,rp.,rr0,ru0,rw.,rz.,s0.,s11,s21,sj.,sn.,su.,sw.,sx.,sy.,sz1,t01,tu.,tv.","","ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,fb.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,gi0,gj0,h80,h90,hg0,hh0,hk1,hl1,hm1,hn.,ho.,hp.,hq.,ie2,if2,ii1,ij1,ik1,il.,im.,in.,io.,j42,j52,jc2,jd2,jg1,jh1,ji1,jj.,jk.,jl.,jm.,jy0,jz0,k00,ld0,le0,lf0,lg1,lh1,li1,mb0,mc0,md0,me1,mf1,mg1,n90,na0,nb0,nc1,nd1,ne1,nq.,nr.,ns.,o61,p41,p51,p7.,q21,q31,q5.,qn0,qq0,qr0,qu0,qv0,qy0,qz0,r01,r11,r3.,r4.,rl0,rn.,rp0,rr.,ru.,rw0,rz1,s01,s1.,s2.,sj0,sn0,su0,sw1,sx1,sy1,sz.,t0.,tu1,tv1","","ed0,ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq1,er1,es1,fb0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm0,fn0,fo1,fp1,fq1,ga2,gb2,gi2,gj2,h82,h92,hg2,hh2,i20,i30,i40,i60,i70,ie0,if0,ii0,ij0,ik0,il0,im1,in1,io1,j00,j10,j20,j40,j50,jc0,jd0,jg0,jh0,ji0,jj0,jk1,jl1,jm1,lu.,lv.,lw.,ma1,mb1,mc1,md.,me.,mf.,mg.,ms.,mt.,mu.,n81,n91,na1,nb.,nc.,nd.,ne.,qp.,qq.,qr.,qu.,qv.,qy.,qz.,r0.,rn0,rp.,rr0,ru0,rw.,ry1,sj.,sn.,su.,sy.,ti.,tj.,tu.,tv.","","ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,fb.,fc.,fd.,fe.,ff.,fg.,fh.,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fp.,fq.,ga0,gb0,gi0,gj0,gm0,gn0,go0,h80,h90,hg0,hh0,hk0,hl0,hm0,i2.,i3.,i4.,i72,i82,ih2,ii2,il.,im.,in.,io.,j0.,j1.,j2.,j52,j62,jf2,jg2,jj.,jk.,jl.,jm.,jx0,ki0,kj0,kk0,kv0,lg0,lh0,li0,lt0,lu0,lv0,lw0,ma0,mb0,mc0,md0,me0,mf0,mg0,mr0,ms0,mt0,mu0,n80,n90,na0,nb0,nc0,nd0,ne0,o60,o70,o80,p40,p50,p60,q20,q30,q40,qm0,qp0,qq0,qr0,qu0,qv0,qy0,qz0,r00,r10,r20,r30,rk0,rm.,rn.,ro0,rp0,rq.,rr.,ru.,rv.,rw0,rx0,ry.,rz.,s00,s10,si0,sj0,sk.,sl.,sm0,sn0,sp.,ss.,su0,sv0,sw.,sx.,sy0,sz0,tg0,th0,tl0,tn.,tq.,ts0,tw0,tx0","","dm0,dn0,do0,dp0,dq0,dr0,ds0,dt0,du0,ed0,ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,fb0,fc0,fd0,fe0,ff0,fg0,fh0,fi0,fj0,fk0,fl0,fm2,fn0,fo0,fp2,fq0,ga2,gd2,gl2,gm2,h92,ha2,i70,i80,ih0,ii0,il0,im0,in0,io0,ip0,j50,j60,jf0,jg0,jj0,jk0,jl0,jm0,jn0,jx.,jy.,jz.,k0.,kl0,kv.,lj0,lt.,md.,me.,mf.,mg.,mr.,nb.,nc.,nd.,ne.,nq0,nr0,ns0,o90,or.,p70,p80,pp.,q2.,q3.,q4.,q50,q60,qm.,qn.,qq.,qr.,qu.,qv.,qw.,qx.,r0.,r1.,r2.,r40,rk.,rl.,rm0,rn0,ro.,rp.,rq0,rr0,s0.,s20,si.,sj.,sk0,sl0,sm.,sn.,sp0,st.,sy.,t00,tg.,th.,ti0,tj0,tl.,tn0,tr.,tt0,tw.,tx.","dl0,du.,ec0,es.,fa0,fl2,fm0,fo2,fp0,fq.,g80,g92,ga0,gc2,gd0,gk2,gm0,go.,h60,h82,ha0,hm.,i40,ip.,j20,jn.,k00,kl.,kw.,kx.,lj.,oa0,oo0,op0,oq0,or0,q20,qy.,r00,rw.,ry0,su.,sw0,sz.,t0.,ts.,tt.","","dl.,du0,ec.,es0,fa.,fl0,fm2,fo0,fp2,fq0,g8.,g90,ga2,gc0,gd2,gk0,gm2,go0,h6.,h80,ha2,hm0,i4.,ip0,j2.,jn0,k0.,kl0,kw0,kx0,lj0,oa.,oo.,op.,oq.,or.,q2.,qy0,r0.,rw0,ry.,su0,sw.,sz0,t00,ts0,tt0","dm.,dn.,do.,dp.,dq.,dr.,ds.,dt.,du.,ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,fb.,fm0,fp0,fr0,g9.,ga0,gd0,gl0,gm0,gp0,h7.,ha0,hc2,hj2,hm2,hn0,i5.,i82,i92,ii2,ij2,im.,in.,io.,ip.,j3.,jk.,jl.,jm.,jn.,jy0,jz0,k00,md0,me0,mf0,mg0,mh0,nb0,nc0,nd0,ne0,nf0,nq.,nr.,ns.,nt.,p8.,q20,q30,q40,q6.,r20,r4.,s00,s2.,sy0,t0.,tw0,tx0","ed0,ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,fb0,fr.,g90,ga2,gd2,gp.,h70,ha2,hc0,hi2,hj0,hl2,hm0,hn.,i20,i30,i40,i50,i80,i90,ih2,ij0,il.,j00,j10,j20,j30,jj.,kh.,ki.,kj.,kk.,kl.,lu.,lv.,lw.,ms.,mt.,mu.,nt0,oa0,ob0,oc0,od0,or0,p7.,pp0,q5.,qn0,qp.,qr0,qt.,qx0,qz.,r10,r3.,rl0,rp0,rv0,rx.,rz0","","ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,ga0,gd0,h82,h90,ha0,hb2,i2.,i3.,i4.,i72,i82,j0.,j1.,j2.,kh0,ki0,kj0,kk0,kl0,lu0,lv0,lw0,ms0,mt0,mu0,o9.,oa.,ob.,oc.,od.,p70,pp.,q50,qn.,qp0,qr.,qt0,qx.,qz0,r1.,r30,rl.,rp.,rv.,rx0,rz.","","fb.,fr0,g9.,gp0,h7.,h80,h92,hb0,hc2,hi0,hj2,hl0,hm2,hn0,i5.,i70,i92,ih0,ij2,il0,im0,in0,io0,ip0,j3.,jj0,jk0,jl0,jm0,jn0,jy.,jz.,k0.,k1.,me.,mf.,mg.,mh.,nc.,nd.,ne.,nf.,nq0,nr0,ns0,o90,or.,os.,p80,pq.,q60,qo.,qq0,qs.,qu0,qy.,r00,r2.,r40,ro0,rq.,rs0,ry0,s20","","fc.,fs0,ga.,gq0,h8.,h90,ha2,hc0,hd2,hj0,hk2,hm0,hn2,ho0,i6.,i80,ia2,ii0,ik2,in.,io.,ip.,j4.,jl.,jm.,jn.,jy0,jz0,k00,k10,me0,mf0,mg0,mh0,nc0,nd0,ne0,nf0,nq.,nr.,ns.,nt.,nu.,oa0,os0,pq0,q6.,qo0,qq.,qs0,qu.,qy0,r0.,r20,r4.,ro.,rq0,rs.,ry.,s2.","","fc0,fs.,ga0,gq.,h80,h92,ha0,hc2,hd0,hj2,hk0,hm2,hn0,ho.,i60,i82,ia0,ii2,ik0,im.,j00,j10,j20,j30,j40,jk.,ki.,kj.,kk.,kl.,ms.,mt.,mu.,mv.,nu0,ob0,oc0,od0,p8.","","dh0,di0,dj0,dk0,dl0,dm0,dn0,do0,dp0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,eu0,fc.,fe2,fh2,fs0,ga.,gd2,ge2,gm2,gp2,gq0,h8.,h90,hc0,hj0,hl2,ho0,i20,i30,i40,i50,i80,i90,ii0,ij0,im0,jk0,ki0,lu.,lv.,lw.,lx.,ly.,mw.,or0,pp0,pr.,ps.,pt.,qn0,qp.,rl0,rn.,sj0,sl.,ti.,tj.","dh.,dq0,ef.,ev0,fd.,fe0,ff2,fh0,fi2,ft0,gb.,gd0,gf2,gm0,gn2,gp0,gq2,gr0,h9.,hl0,hn2,hp0,i2.,in0,j0.,jl0,jy.,kj0,kw.,li.,lj.,nt0,p80,p90,pa0,pb0,pt0,qr0,qt.,rp0,rr.,sj.,sk.,sn0,sp.,tm.,tn.","","dh0,dq.,ef0,ev.,fd0,fe2,ff0,fh2,fi0,ft.,gb0,gd2,gf0,gm2,gn0,gp2,gq0,gr.,h90,hl2,hn0,hp.,i20,in.,j00,jl.,jy0,kj.,kw0,li0,lj0,nt.,p8.,p9.,pa.,pb.,pt.,qr.,qt0,rp.,rr0,sj0,sk0,sn.,sp0,tm0,tn0","dh.,di.,dj.,dk.,dl.,dm.,dn.,do.,dp.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,eu.,fc0,fe0,fh0,fs.,ga0,gd0,ge0,gm0,gp0,gq.,h80,h92,hc2,hj2,hl0,ho.,i2.,i3.,i4.,i5.,i82,i92,ii2,ij2,im.,j0.,j1.,j2.,j3.,jk.,kj0,kk0,kl0,lu0,lv0,lw0,lx0,ly0,ms0,mt0,mu0,mv0,mw0,oa.,ob.,oc.,od.,or.,pp.,pr0,ps0,pt0,qn.,qp0,rl.,rn0,sj.,sl0,ti0,tj0","el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,eu0,fc.,fs0,ga.,gm2,gp2,gq0,h8.,h90,ha2,hc0,hd2,hj0,hl2,ho0,i6.,i80,ia2,ii0,ij0,im0,in0,io0,ip0,j4.,jk0,jl0,jm0,jn0,jy.,jz.,k0.,k1.,k2.,mf.,mg.,mh.,nd.,ne.,nf.,nq0,nr0,ns0,nt0,oa0,os.,ot.,p80,pq.,q60,qo.,qq0,qs.,qu0,qy.,r00,r2.,r40,ro0,rq.,rs0,ry0,s20","","el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,eu.,gm0,gp0,ha0,hb2,hc2,hd0,ij2,ik2,in.,io.,ip.,jl.,jm.,jn.,jy0,jz0,k00,k10,k20,mf0,mg0,mh0,nd0,ne0,nf0,nq.,nr.,ns.,nt.,nu.,ot0,pq0,q6.,qo0,qq.,qs0,qu.,qy0,r0.,r20,r4.,ro.,rq0,rs.,ry.,s2.","","fc0,fs.,ga0,gq.,h80,ha2,hc0,hk2,hm0,ho.,i20,i30,i40,i50,i60,i82,ia0,ii2,ik0,im.,j00,j10,j20,j30,j40,jk.,ki.,kj.,kk.,kl.,lu.,lv.,lw.,lx.,ms.,mt.,mu.,mv.,nu0,ob0,oc0,od0,or0,os0,p7.,p8.,pp0,q5.,qn0,qp.,qr0,qt.,qx0,qz.,r10,r3.,rl0,rp0,rv0,rx.,rz0","","fb0,fr.,g90,gp.,h70,h92,hb0,hj2,hl0,hn.,i2.,i3.,i4.,i72,i90,ih2,ij0,il.,j0.,j1.,j2.,jj.,ki0,kj0,kk0,kl0,lu0,lv0,lw0,lx0,ms0,mt0,mu0,mv0,nt0,o9.,oa.,ob.,oc.,od.,p70,pp.,q50,qn.,qp0,qr.,qt0,qx.,qz0,r1.,r30,rl.,rp.,rv.,rx0,rz.","f90,fa0,fr0,fs0,ft0,fu0,g70,g80,gp0,gq0,gr0,gs0,h50,h60,h90,ha0,hj0,hk0,hn0,ho0,hp0,hq0,i30,i40,i70,i92,ih0,ij2,il0,im0,in0,io0,j3.,j62,j72,jg2,jh2,jj0,jy.,jz.,k0.,k1.,ki.,kj.,kk.,kl.,kw.,kx.,ky.,kz.,lg.,lh.,li.,lj.,lu.,lv.,lw.,lx.,me.,mf.,mg.,mh.,ms.,mt.,mu.,mv.,nc.,nd.,ne.,nf.,nt.,o90,or.,q60,qq0,qu0,r00,r40,rm.,ro0,rq.,rs0,rw.,ry0,s0.,s20,sk.,sm0,so.,sq0,su.,sw0,sy.,t00,ti.,tk0,tm.,to0,ts.,tu0,tw.,ty0","dv0,dw0,dx0,dy0,eb0,ec0,ed0,ee0,ef0,et0,eu0,ev0,ew0,fe.,ff.,fg.,fh.,fi.,fj.,ho.,hp.,hq.,i3.,i4.,i5.,i80,i90,im.,in.,io.,k42,k52,qr0,qv0,rm0,ro.,rq0,rs.,s30,sk0,so0,sv.,sx0,sz.,t10,t20,tt.,tv0,tx.,ty.,tz0","","cf0,cg0,ch0,ci0,cj0,cx0,cy0,cz0,d00,dd0,de0,df0,dg0,dh0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,fe0,ff0,fg0,fh0,fi0,fj0,g7.,g8.,g9.,gq.,gr.,gs.,h5.,h6.,h7.,ha2,hb2,hk2,hl2,i82,i92,j60,j70,jg0,jh0,k40,k50,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,qq.,qr.,qu.,qv.,r2.,rz0,sm.,sq.,t2.,ti0,tk.,tm0,to.,tu.,tv.,tz.","cf.,cg.,ch.,ci.,cj.,cx.,cy.,cz.,d0.,dd.,de.,df.,dg.,dh.,dv.,dw.,dx.,dy.,eb.,ec.,ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,eu.,ev.,ew.,fv0,g70,g80,g90,gq0,gr0,gs0,gt0,h50,h60,h70,ha0,hc2,hk0,hm2,ho0,hp0,hq0,hr0,i30,i40,i50,i80,ia2,ii0,ik2,im0,in0,io0,ip0,j4.,jk0,k2.,ki0,l0.,lg0,ly.,me0,mw.,nc0,nu.,oa0,p80,ps0,pt0,pw0,px0,py0,pz0,q20,q30,q6.,r0.,r20,r4.,rw0,ry.,rz.,s00,s2.,s3.,su0,sv0,sw.,sx.,sy0,sz0,t0.,t1.,ts0,tt0,tw0,tx0","f80,fv.,g60,gt.,h40,hb0,hc0,hl0,hm0,hr.,i20,i82,ia0,ii2,ik0,ip.,j40,j62,j72,jg2,jh2,jk.,k20,ki.,l00,lg.,ly0,me.,mw0,nc.,nu0,oa.,p8.,pp0,qn0,qr0,rl0,rn.,rp0,rr.,sj0,sl.,sn0,sp.,st0,sx0,th0,tj.,tl0,tn.,tr0,tt.,tv0,tx.","dc0,dd0,de0,df0,ea0,eb0,ec0,ed0,fi.,fj.,fk.,fl.,fm.,fn.,fo.,fu.,gs.,h4.,h5.,h6.,hq.,i2.,i3.,i4.,i72,i90,ii0,ij0,io.,j30,j52,j70,jf2,jh0,jj.,k10,kd2,ke2,kh.,kz0,lf.,lx0,md.,mv0,nb.,nt0,o9.,or0,p7.,po0,q5.,qm0,qp.,qq0,qt.,qu0,qv0,qw0,qx0,r00,r10,r3.,rj0,rk0,rm.,ro0,rq.,rv0,rx.,rz0,s1.,sg0,sh0,si0,sj.,sk.,sl0,sm0,sn.,so.,ss0,sv.,sw0,sz.,tf0,th.,ti.,tj0,tk0,tl.,tm.,tq0,ts.,tu0,tw.","","cf0,cg0,ch0,ci0,cw0,cx0,cy0,cz0,d00,dc.,dg0,du0,dv0,dw0,dx0,dy0,ea.,ee0,ef0,eg0,eh0,ei0,ej0,ek0,el0,em0,en0,eo0,ep0,eq0,er0,es0,et0,eu0,ev0,ew0,f8.,fi0,fj0,fk0,fl0,fm0,fn0,fo0,fu0,g6.,g7.,g8.,g9.,gq.,gr.,h7.,ha2,hb2,hk2,hl2,ho.,hp.,i5.,i70,i92,ii2,ij2,im.,in.,j3.,j50,j60,jf0,jg0,jj0,k1.,kd0,ke0,kh0,kz.,lf0,lx.,md0,mv.,nb0,nt.,o90,or.,p70,po.,ps.,pt.,pw.,px.,py.,pz.,q2.,q3.,q50,qm.,qq.,qt0,qu.,qv.,qw.,qx.,r0.,r1.,r30,rj.,rm0,rq0,rv.,rx0,rz.,s10,sg.,sh.,sj0,sl.,sn0,ss.,st.,sv0,sw.,sx.,sz0,tf.,tj.,tk.,tq.,tr.,ts0,tt0,tu.,tv.,tw0,tx0","","cf.,cg.,ch.,ci.,cw.,cx.,cy.,cz.,d0.,dd.,de.,df.,dg.,du.,dv.,dw.,dx.,dy.,eb.,ec.,ed.,ee.,ef.,eg.,eh.,ei.,ej.,ek.,el.,em.,en.,eo.,ep.,eq.,er.,es.,et.,eu.,ev.,ew.,f9.,fa.,fb.,fs.,ft.,fu.,i30,i40,i50,im0,in0,io0,j10,j20,j30,jk0,jl0,jm0,jz0,k00,k10,ki0,kj0,kk0,kx0,ky0,kz0,lg0,lh0,li0,pp.,ps0,pt0,pw0,px0,py0,pz0,q20,q30,qn.,qp0,qr.,rk.,rl.,rn0,ro.,rp.,rr0,si.,sj.,sk0,sl0,sm.,sn.,so0,sp0,ti0,tj0,tm0,tn0"],"a0":[7,16,18,16]},"Meditating":{"w":24,"h":16,"palette":["#141413","#be684d","#d97757"],"base":"....2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","","","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,1i2,1j2,1s2,1t2,2o.,2p.,2q.,2r.,2u0,2v0,340,350,38.,39.,3a.,3b.,5c2,5d2,5e2,5f2,5w2,5x2,5y2,5z2,832,861,872,8a2,8b2,8c2,8d2,8g2,8h1,8k2,8r2,8t1,8u1,8v2,8x1,8y1,8z1,901,911,921,942,951,961,982,9f2,9j2,9s2,9w2","","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,262,272,2g2,2h2,2t0,2u2,2v2,2w0,330,342,352,360,3c.,3d.,3e.,3f.,3i0,3j0,3s0,3t0,3w.,3x.,3y.,3z.,40.,4n.,4o.,5b.,5c.,5z.,612,622,632,6k2,6l2,6m2,8a1,8b1,8c1,8d1,8q2,992,9e2,9i1,9m2,9n1,9o1,9p2,9t1,9x2,a32,aa2,ad2,ak2","","3d2,3e2,3f2,3w2,3x2,3y2,41.,4m.,4o2,5b2,5c2,5z2,61.,62.,63.,6k.,6l.,6m.","","2p2,2q2,2r2,382,392,3a2,3c2,3d.,3y.,3z2,402,412,4m2,4n2,5c.,5d.,5e.,5f.,5w.,5x.,5y.,5z.","","2p.,2q.,2r.,38.,39.,3a.,3c.,3d2,3y2,3z.,41.,4m.,5c2,5d2,5e2,5f2,5w2,5x2,5y2,5z2","","","","","","","","","","s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,250,280,2f0,2i0,2p2,2q2,2r2,2t2,2u0,2v0,2w2,332,340,350,362,382,392,3a2,3c2,3d.,3i2,3j2,3s2,3t2,3y.,3z2,412,4m2,5c.,5d.,5e.,5f.,5w.,5x.,5y.,5z.","","","1h0,1k0,1r0,1u0,212,222,232,252,260,270,282,2f2,2g0,2h0,2i2,2k2,2l2,2m2,2o2,2p.,2u2,2v2,342,352,3a.,3b2,3d2,3y2,4o.,4p.,4q.,4r.,58.,59.,5a.,5b.","","","","","","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1h2,1k2,1r2,1u2,21.,22.,23.,250,262,272,280,2f0,2g2,2h2,2i0,2k.,2l.,2m.,2o.,2p2,2u0,2v0,340,350,3a2,3b.,3d.,3y.,4o2,4p2,4q2,4r2,582,592,5a2,5b2","","252,282,2f2,2i2,2p.,2q.,2r.,2t0,2u2,2v2,2w0,330,342,352,360,38.,39.,3a.,3c.,3d2,3i0,3j0,3s0,3t0,3y2,3z.,41.,4m.,5c2,5d2,5e2,5f2,5w2,5x2,5y2,5z2","","","","","","","","","","2t2,2w2,332,362,3h0,3k0,3r0,3u0","2u0,2v0,340,350,3h2,3k2,3r2,3u2","","","","","","s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,260,270,2g0,2h0,3c2,3i2,3j2,3s2,3t2,3z2,412,4m2,8a2,8b2,8c2,8d2,8q.,99.,9e.,9i.,9m.,9n.,9o.,9p.,9t.,9x.,a3.,aa.,ad.,ak.","","42,52,62,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,1i0,1j0,1s0,1t0,2o2,2p2,2q2,2r2,2u2,2v2,342,352,382,392,3a2,3b2,5c.,5d.,5e.,5f.,5w.,5x.,5y.,5z.,83.,86.,87.,8a.,8b.,8c.,8d.,8g.,8h.,8k.,8r.,8t2,8u.,8v.,8x2,8y.,8z.,90.,91.,922,94.,95.,962,98.,9f.,9j.,9s.,9w.","","","","",""],"a0":[0,0,24,16]},"Waving":{"w":24,"h":21,"palette":["#141413","#be684d","#d97757"],"base":"............................................................................................................................2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","3g.,3h.,3i.,3j.,3k.,3l.,3m.,3n.,3o.,3p.,3q.,3r.,3s.,3t.,3u.,3v.,44.,45.,46.,47.,48.,49.,4a.,4b.,4c.,4d.,4e.,4f.,4g.,4h.,4i.,4j.,4u2,4v2,542,552,5i2,5j2,5s2,5t2,60.,61.,62.,63.,6k.,6l.,6m.,6n.,6o.,6p.,6q.,6r.,78.,79.,7a.,7b.,7c.,7d.,7e.,7f.,7w.,7x.,7y.,7z.,80.,81.,82.,83.,860,870,8g0,8h0,8k.,8l.,8m.,8n.,8o2,8p2,8q2,8r2,8u0,8v0,940,950,982,992,9a2,9b2,9c2,9d2,9e2,9f2,9w2,9x2,9y2,9z2,a02,a12,a22,a32,ak2,al2,am2,an2,ao2,ap2,aq2,ar2,b82,b92,ba2,bb2,bi2,bj2,bm2,bn2,bo2,bp2,bs2,bt2,c62,c72,ca2,cb2,cc2,cd2,cg2,ch2,cs1,ct1,cw1,cx1,d21,d31,d61,d71","i2,j2,k2,l2,162,172,182,192,1a2,1u1,1v1,1w1,1x2,1y2,2c2,2d2,2e2,2f2,2g2,2h2,2i2,2j2,2k1,2l2,2m2,2u2,2v2,2w2,2x2,2y2,2z2,302,312,322,332,342,352,362,372,381,392,3a2,3b2,3g2,3h2,3i2,3j2,3k2,3l2,3m2,3n2,3o2,3p2,3q2,3r2,3s0,3t0,3u2,3v2,3w1,3x2,3y2,3z2,442,452,460,470,482,492,4a2,4b2,4c2,4d2,4e2,4f2,4g0,4h0,4i2,4j2,4k1,4l2,4m2,4n2,4u0,4v0,581,592,5a2,5b2,6o2,6p2,6q2,6r2,7c2,7d2,7e2,7f2,802,812,822,832,862,872,8g2,8h2,8u2,8v2,942,952,98.,99.,9a.,9b.,9c.,9d.,9e.,9f.,9w.,9x.,9y.,9z.,a0.,a1.,a2.,a3.,ag.,ah.,ak.,al.,am.,an.,ao.,ap.,aq.,ar.,au.,av.,b0.,b1.,b4.,b5.,b8.,b9.,ba.,bb.,bi.,bj.,bm.,bn.,bo.,bp.,bs.,bt.,c6.,c7.,ca.,cb.,cc.,cd.,cg.,ch.,cs2,ct2,cw2,cx2,d22,d32,d62,d72","i.,j.,k.,l.,142,152,18.,19.,1a.,1s2,1t2,1u2,1v2,1w.,1x.,1y.,2c.,2d.,2e.,2f.,2g1,2h1,2i1,2j1,2k.,2l.,2m.,2u.,2v.,2w.,2x.,2y.,2z.,38.,39.,3a.,3b.,3s2,3t2,3w.,3x.,3y.,3z.,462,472,4k.,4l.,4m.,4n.,540,550,58.,59.,5a.,5b.,5i0,5j0,602,612,622,632,8o.,8p.,8q.,8r.,ag2,ah2,au2,av2,b02,b12,b42,b52","132,17.,1r2,1v.,2f1,2j.,60.,61.,62.,63.,8o2,8p2,8q2,8r2","13.,172,1r.,1v2,2f.,2j1","132,17.,1r2,1v.,2f1,2j.","13.,172,1r.,1v2,2f.,2j1","132,17.,1r2,1v.,2f1,2j.","13.,172,1r.,1v2,2f.,2j1","132,17.,1r2,1v.,2f1,2j.","13.,172,1r.,1v2,2f.,2j1","132,17.,1r2,1v.,2f1,2j.","13.,14.,15.,172,182,192,1r.,1s.,1t.,1v2,1w2,1x2,1y2,2f.,2g.,2h.,2j1,2k1,2l2,2m2,381,392,3a2,3w1,3x2,3y2,3z2,4k1,4l2,4m2,4n2,581,592,5a2,5b2,5w1,5x2,5y2,5z2,6o.,6p.,6q.,6r.,9c2,9d2,9e2,9f2"],"a0":[0,5,24,16]},"Thinking":{"w":24,"h":29,"palette":["#141413","#be684d","#d97757","#699acb"],"base":"............................................................................................................................................................................................................................................................................................................................2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","313,323,333,343,353,3o3,3p3,3q3,3r3,3s3,3t3,3u3,4c3,4d3,4e3,4f3,4g3,4h3,4i3,503,513,523,533,543,553,563,5q3,5r3,5s3,6e3,7s2,7t2,7u2,7v2,882,892,8a2,8b2,8c2,8d2,8e2,8f2,8g2,8h2,8i2,8j2,9r0,9s0,9t0,9w2,9x2,a80,ag2,ah2,al2,am2,au2,av2,b42,b52,b92,ba2,bc.,bd.,be.,bf.,bz.,cn.,da.,db.,dw.,dx.,dy.,dz.,e02,e12,e22,e32,gc.,gd.,gg.,gh.","d3,e3,f3,g3,h3,i3,j3,103,113,123,133,143,153,163,173,183,1o3,1p3,1q3,1r3,1s3,1t3,1u3,1v3,1w3,2c3,2d3,2e3,2f3,2g3,2h3,2i3,2j3,2k3,303,363,373,383,3v3,3w3,4c.,4j3,50.,51.,52.,56.,5q.,6e.,6f3","2e0,9w.,9x.,ak2","","9w2,9x2,ak.","","9w.,9x.,ak2","2g0","9w2,9x2,ak.","","9w.,9x.,ak2","","2i0,9w2,9x2,ak.","","9w.,9x.,ak2","","d.,e.,f.,g.,h.,i.,j.,10.,11.,12.,13.,14.,15.,16.,17.,18.,1o.,1p.,1q.,1r.,1s.,1t.,1u.,1v.,1w.,2c.,2d.,2e.,2f.,2g.,2h.,2i.,2j.,2k.,30.,31.,32.,33.,34.,35.,36.,37.,38.,3o.,3p.,3q.,3r.,3s.,3t.,3u.,3v.,3w.,4d.,4e.,4f.,4g.,4h.,4i.,4j.,53.,54.,55.,5r.,5s.,6f.,7s.,7t.,7u.,7v.,871,881,891,8a1,8b1,8c1,8d1,8e1,8f1,8g1,8h1,8i1,8j1,8s1,8t1,8u1,8v1,8w1,8x1,8y1,8z1,901,911,921,931,941,951,961,971,9r2,9s2,9t2,a62,a72,a82,ak.,al.,am.,aq2,ar2,b9.,ba.,be2,bf2,c0.,c50,c60,c70,cf0,cg0,ch0,co.,cr.,ct0,cu0,cv0,d30,d40,d50,da2,dc.,df.,dw2,dx2,dy2,e0.,ek2,el2,em2,ep2,eq2,er2,gc2,gd2,gg2,gh2,gu2,gv2,gy2,gz2,h02,h12,h42,h52,hg1,hh1,hk1,hl1,hq1,hr1,hu1,hv1","433,443,453,463,473,4q3,4r3,4s3,4t3,4u3,4v3,4w3,5e3,5f3,5g3,5h3,5i3,5j3,5k3,623,633,643,653,663,673,683,6s3,6t3,6u3,7i3,87.,88.,89.,8a.,8b.,8c.,8d.,8e.,8f.,8g.,8h.,8i.,8j.,8s.,8t.,8u.,8v.,8w.,8x.,8y.,8z.,90.,91.,92.,93.,94.,95.,96.,97.,9g1,9h1,9i1,9j1,9k1,9l1,9m1,9n1,9o1,9p1,9q1,9r1,9s1,9t1,9u1,9v1,a41,a51,a61,a71,a81,a91,aa1,ab1,ac1,ad1,ae1,af1,ag1,ah1,ai1,aj1,aq.,ar.,be.,bf.,bw.,bx.,by.,c1.,c2.,c3.,c52,c62,c72,cf2,cg2,ch2,ck.,cl.,cm.,cp.,cq.,ct2,cu2,cv2,d32,d42,d52,d8.,d9.,da.,dd.,df2,dw.,dx.,dy.,e3.,e50,e60,e70,ef0,eg0,eh0,er.,f82,f92,fa2,fd2,fe2,ff2,fw2,fx2,fy2,g12,g22,g32,gk2,gl2,gm2","1d3,1e3,1f3,1g3,1h3,1i3,1j3,203,213,223,233,243,253,263,273,283,2o3,2p3,2q3,2r3,2s3,2t3,2u3,2v3,2w3,3c3,3d3,3e3,3f3,3g3,3h3,3i3,3j3,3k3,403,413,423,483,4o3,4p3,5d3,5k.,62.,66.,67.,68.,6u.,7h3,7i.","3i0,de.,df.,e32","","de2,df2,e3.","","de.,df.,e32","3g0","de2,df2,e3.","","de.,df.,e32","","3e0,de2,df2,e3.","","de.,df.,e32","","1d.,1e.,1f.,1g.,1h.,1i.,1j.,20.,21.,22.,23.,24.,25.,26.,27.,28.,2o.,2p.,2q.,2r.,2s.,2t.,2u.,2v.,2w.,3c.,3d.,3e.,3f.,3g.,3h.,3i.,3j.,3k.,40.,41.,42.,43.,44.,45.,46.,47.,48.,4o.,4p.,4q.,4r.,4s.,4t.,4u.,4v.,4w.,5d.,5e.,5f.,5g.,5h.,5i.,5j.,63.,64.,65.,6s.,6t.,7h.,8s2,8t2,8u2,8v2,8w2,8x2,8y2,8z2,902,912,922,932,942,952,962,972,9g2,9h2,9i2,9j2,9k2,9l2,9m2,9n2,9o2,9p2,9q2,9r2,9s2,9t2,9u2,9v2,a42,a52,a60,a70,a82,a92,aa2,ab2,ac2,ad2,ae2,af2,ag0,ah0,ai2,aj2,au0,av0,b40,b50,bc2,bd2,be2,bf2,bw2,bx2,by2,bz2,c02,c12,c22,c32,ck2,cl2,cm2,cn2,co2,cp2,cq2,cr2,d82,d92,da2,db2,dc2,dd2,de2,df2,dw2,dx2,dy2,dz2,e1.,e2.,e3.,e52,e62,e72,ef2,eg2,eh2,ek.,el.,em.,ep.,eq.,f8.,f9.,fa.,fd.,fe.,ff.,fw.,fx.,fy.,g1.,g2.,g3.,gk.,gl.,gm.,gu.,gv.,gy.,gz.,h0.,h1.,h4.,h5.,hg2,hh2,hk2,hl2,hq2,hr2,hu2,hv2"],"a0":[0,13,24,16]},"Excited":{"w":24,"h":17,"palette":["#141413","#d97757","#be684d"],"base":"............................1111111111111111........1111111111111111........1100111111110011........1100111111110011....111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111....1111111111111111........1111111111111111........1111111111111111........1111111111111111........11..11....11..11........11..11....11..11........11..11....11..11........11..11....11..11....","deltas":["","","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,261,271,2g1,2h1,3c.,3d.,3e.,3f.,3g2,3i0,3j0,3s0,3t0,3v2,3w.,3x.,3y.,3z.,40.,452,4i2,4n.,4o.,4t2,562,5b.,5c.,5h2,5u2,5z.,611,621,631,652,6i2,6k1,6l1,6m1,6s2,6t2,762,772,831,8k1,8r1,8t.,8v1,8x.,92.,941,96.,981,9f1,9j1,9s1,9w1","","41,51,61,71,81,91,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,s1,t1,u1,v1,w1,x1,y1,z1,101,111,121,131,141,151,161,171,1j0,1k0,1r0,1s0,260,290,2e0,2h0,2r1,2u1,2v2,342,351,381,3f1,3g1,3i1,3j2,3s2,3t1,3v1,3w1,41.,42.,451,472,4g2,4i1,4l.,4m.,4p.,4q.,4t1,4v2,542,561,59.,5a.,5d.,5e.,5f.,5g2,5i2,5j2,5s2,5t2,5v2,5w.,5x.,5y.,61.,62.,63.,651,6i1,6k.,6l.,6m.,6s1,6t1,761,771,7f1,86.,8k.,921,94.,961,98.,9h.,9l.,9s.,9w.,a31,a5.,a71,a9.,as.,at.,aw.,ax.","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,j1,r.,171,1f.,1i1,1k0,1q1,1s0,1v1,23.,251,260,281,290,2d1,2e0,2g1,2h0,2j1,2q.,2u1,2v2,331,342,381,3e.,3i1,3j2,3r1,3s2,3w1,42.,461,472,4f1,4g2,4k1,4q.,4u1,4v2,531,542,581,5f.,5j2,5r1,5v2,63.,6j1,6r.,771,86.,8g1,ar.,as.,av.,aw.,b21,b31,b61,b71","31,j.,r1,17.,1f1,1i0,1k1,1q0,1s1,1v.,231,250,261,280,291,2d0,2e1,2g0,2h1,2j.,2q1,2u2,2v1,332,341,38.,3e1,3i2,3j1,3r2,3s1,3w.,421,462,471,4f2,4g1,4k.,4q1,4u2,4v1,532,541,58.,5f2,5j1,5r2,5v.,631,6j.,6r1,77.,861,8g.,ar1,as1,av1,aw1,b2.,b3.,b6.,b7.","3.,4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,r.,s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,1f.,1i1,1j1,1q1,1r1,1v1,23.,251,281,2d1,2g1,2j1,2q.,2r.,2u0,2v0,331,340,350,3e.,3f.,3g2,3i0,3j0,3r1,3s0,3t0,3v2,411,452,461,4f1,4i2,4k1,4l1,4m1,4p1,4t2,4u1,531,562,581,591,5a1,5d1,5e1,5f1,5g1,5i1,5r1,5s1,5t1,5v1,5w1,5x1,5y1,611,621,652,6i2,6j1,6k1,6l1,6m1,6r.,6s2,6t2,762,772,7f.,8g1,8k1,92.,941,96.,981,9h1,9l1,9s1,9w1,a3.,a51,a7.,a91,ar.,at1,av.,ax1,b21,b31,b61,b71",""],"a0":[0,1,24,16]},"Disappointed":{"w":24,"h":18,"palette":["#141413","#be684d","#d97757"],"base":"....................................................2222222222222222........2222222222222222........2200222222220022........2200222222220022....222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222....2222222222222222........2222222222222222........2222222222222222........2222222222222222........22..22....22..22........22..22....22..22........22..22....22..22........22..22....22..22....","deltas":["","","","","","2u2,2v2,342,352,3h0,3k0,3r0,3u0","2t0,2u0,2v0,340,350,360,3h2,3j2,3k2,3r2,3s2,3u2","","","s2,t2,u2,v2,w2,x2,y2,z2,102,112,122,132,142,152,162,172,250,260,270,2g0,2h0,2i0,2t2,2v2,342,362,3c2,3d2,3e2,3f2,3i2,3t2,3w2,3x2,3y2,3z2,60.,61.,62.,63.,6k.,6l.,6m.,6n.,8u.,8v.,8y.,8z.,90.,91.,94.,95.","42,52,62,72,82,92,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,1h0,1i0,1j0,1s0,1t0,1u0,202,212,222,232,252,272,2g2,2i2,2k2,2l2,2m2,2n2,2o2,2p2,2q2,2r2,2u2,352,382,392,3a2,3b2,4o.,4p.,4q.,4r.,58.,59.,5a.,5b.,5c.,5d.,5e.,5f.,5w.,5x.,5y.,5z.","","4.,5.,6.,7.,8.,9.,a.,b.,c.,d.,e.,f.,g.,h.,i.,j.,1h2,1i2,1j2,1s2,1t2,1u2,20.,21.,22.,23.,262,2h2,2k.,2l.,2m.,2n.,2o.,2p.,2q.,2r.,38.,39.,3a.,3b.,3h0,3i0,3j0,3s0,3t0,3u0,4o2,4p2,4q2,4r2,582,592,5a2,5b2,5c2,5d2,5e2,5f2,5w2,5x2,5y2,5z2,602,612,622,632,6k2,6l2,6m2,6n2,6o2,6p2,6q2,6r2,782,792,7a2,7b2","s.,t.,u.,v.,w.,x.,y.,z.,10.,11.,12.,13.,14.,15.,16.,17.,1g.,1h.,1i.,1j.,1k.,1l.,1m.,1n.,1o.,1p.,1q.,1r.,1s.,1t.,1u.,1v.,24.,25.,26.,27.,28.,29.,2a.,2b.,2c.,2d.,2e.,2f.,2g.,2h.,2i.,2j.,2s.,2t.,2u.,2v.,2w.,2x.,2y.,2z.,30.,31.,32.,33.,34.,35.,36.,37.,3c.,3d.,3e.,3f.,3h2,3i2,3j2,3s2,3t2,3u2,3w.,3x.,3y.,3z.,40.,41.,42.,43.,4k.,4l.,4m.,4n.,4o.,4p.,4q.,4r.,58.,59.,5a.,5b.,5c.,5d.,5e.,5f.,5w.,5x.,5y.,5z.,60.,61.,62.,63.,660,670,680,6f0,6g0,6h0,6k.,6l.,6m.,6n.,6o.,6p.,6q.,6r.,78.,79.,7a.,7b.,7d2,7e2,7f2,7w2,7x2,7y2,812,822,832,8k2,8l2,8m2,8p2,8q2,8r2,8u2,8v2,8y2,8z2,902,912,942,952,982,992,9a2,9d2,9e2,9f2,9i2,9j2,9m2,9n2,9o2,9p2,9s2,9t2,9w2,9x2,9y2,a62,a72,aa2,ab2,ac2,ad2,ag2,ah2,as1,at1,aw1,ax1,b21,b31,b61,b71","2s2,2t2,2u2,2v2,2w2,2x2,2y2,2z2,302,312,322,332,342,352,362,372,5i0,5j0,5k0,5r0,5s0,5t0,662,672,682,6f2,6g2,6h2,6p2,6q2,6r2,782,792,7a2,9d.,9e.,9f.,9w.,9x.,9y.,a41,a51,a6.,a7.,a81,a91,aa.,ab.,ac.,ad.,ae1,af1,ag.,ah.,ai1,aj1,as2,at2,aw2,ax2,b22,b32,b62,b72","","","2s1,3g1,441,4s1,5g1,5i2,5l0,5r2,5u0,641,6p1,781,7a.,7d1,7w1,7y.,811,8k1,8m.,8p1,981,9a.,9g1","2t1,3h1,451,4t1,5h1,5j2,5m0,5s2,5v0,651,6q1,79.,7e1,7x.,821,8l.,8q1,99.,9h1","2t2,3h2,452,4t2,5h2,5j0,5m2,5s0,5v2,652,6q2,792,7e2,7x2,822,8l2,8q2,992,9h2","2s2,3g2,442,4s2,5g2,5i0,5l2,5r0,5u2,642,6p2,782,7a2,7d2,7w2,7y2,812,8k2,8m2,8p2,982,9a2,9g2","371,3v1,4j1,571,5h0,5k2,5q0,5t2,5v1,6j1,6p.,6r1,7a1,7d.,7f1,7y1,81.,831,8m1,8p.,8r1,9a1,9v1","361,3u1,4i1,561,5g0,5j2,5p0,5s2,5u1,6i1,6q.,791,7e.,7x1,82.,8l1,8q.,991","362,3u2,4i2,562,5g2,5j0,5p2,5s0,5u2,6i2,6q2,792,7e2,7x2,822,8l2,8q2,992","372,3v2,4j2,572,5h2,5k0,5q2,5t0,5v2,6j2,6p2,6r2,7a2,7d2,7f2,7y2,812,832,8m2,8p2,8r2,9a2,9v2","2s1,3g1,441,4s1,5g1,5i2,5l0,5r2,5u0,641,6p1,781,7a.,7d1,7w1,7y.,811,8k1,8m.,8p1,981,9a.,9g1","2t1,3h1,451,4t1,5h1,5j2,5m0,5s2,5v0,651,6q1,79.,7e1,7x.,821,8l.,8q1,99.","2t2,3h2,452,4t2,5h2,5j0,5m2,5s0,5v2,652,6q2,792,7e2,7x2,822,8l2,8q2,992","2s2,3g2,442,4s2,5g2,5i0,5l2,5r0,5u2,642,6p2,782,7a2,7d2,7w2,7y2,812,8k2,8m2,8p2,982,9a2,9g2","371,3v1,4j1,571,5h0,5k2,5q0,5t2,5v1,6j1,6p.,6r1,7a1,7d.,7f1,7y1,81.,831,8m1,8p.,8r1,9a1,9v1","5g0,5j2,5p0,5s2,6q.,791,7e.,7x1,82.,8l1,8q.,991","5g2,5j0,5p2,5s0,6q2,792,7e2,7x2,822,8l2,8q2,992","372,3v2,4j2,572,5h2,5k0,5q2,5t0,5v2,6j2,6p2,6r2,7a2,7d2,7f2,7y2,812,832,8m2,8p2,8r2,9a2,9v2","","","2s.,2t.,2u.,2v.,2w.,2x.,2y.,2z.,30.,31.,32.,33.,34.,35.,36.,37.,5i2,5j2,5k2,5r2,5s2,5t2,660,670,680,6f0,6g0,6h0,6p.,6q.,6r.,78.,79.,7a.,9d2,9e2,9f2,9w2,9x2,9y2,a42,a52,a62,a72,a82,a92,aa2,ab2,ac2,ad2,ae2,af2,ag2,ah2,ai2,aj2,as1,at1,aw1,ax1,b21,b31,b61,b71","","242,252,262,272,282,292,2a2,2b2,2c2,2d2,2e2,2f2,2g2,2h2,2i2,2j2,2s2,2t2,2u2,2v2,2w2,2x2,2y2,2z2,302,312,322,332,342,352,362,372,450,460,470,480,4f0,4g0,4h0,4i0,4o2,4p2,4q2,4r2,582,592,5a2,5b2,5c2,5d2,5e2,5f2,5w2,5x2,5y2,5z2,602,612,622,632,662,672,682,6f2,6g2,6h2,6k2,6l2,6m2,6n2,6o2,6p2,6q2,6r2,782,792,7a2,7b2,7d.,7e.,7f.,7w.,7x.,7y.,81.,82.,83.,8k.,8l.,8m.,8p.,8q.,8r.,98.,99.,9a.,9d.,9e.,9f.,9i.,9j.,9m.,9n.,9o.,9p.,9s.,9t.,9w.,9x.,9y.,a6.,a7.,aa.,ab.,ac.,ad.,ag.,ah.,as2,at2,aw2,ax2,b22,b32,b62,b72","1g2,1h2,1i2,1j2,1k2,1l2,1m2,1n2,1o2,1p2,1q2,1r2,1s2,1t2,1u2,1v2,2u0,2v0,340,350,3i0,3j0,3s0,3t0,402,412,422,432,452,462,472,482,4f2,4g2,4h2,4i2,4k2,4l2,4m2,4n2,6o.,6p.,6q.,6r.,78.,79.,7a.,7b.","","","",""],"a0":[0,2,24,16]},"Dizzy":{"w":28,"h":17,"palette":["#141413","#d97757","#be684d"],"base":"..................................1111111111111111............1111111111111111............1100111111110011............1100111111110011........111111111111111111111111....111111111111111111111111....111111111111111111111111....111111111111111111111111........1111111111111111............1111111111111111............1111111111111111............1111111111111111............11..11....11..11............11..11....11..11............11..11....11..11............11..11....11..11......","deltas":["","","","","","d1,e1,f1,g1,h1,i1,j1,k1,x1,170,180,190,1a0,1d.,1p1,1r0,1y0,230,25.,2h1,2i0,2k1,2m0,2q0,2s0,2t0,2u1,2y1,2z1,301,391,3a0,3d1,3f0,3i0,3l0,3m1,3q1,3r1,3s1,3y.,3z.,40.,420,440,450,470,4b0,4c0,4f0,4l.,4p1,4u0,4z0,560,5d.,5h1,5n0,5o0,5p0,5q0,61.,62.,63.,64.,65.,691,6t.,6u.,6v.,6w.,6x.,711,721,731,741,751,7l.,7x1,8d.,9u.,9v.,aq1,bg.,bi1,c8.,ca1,d0.,d1.","","c1,k.,w1,160,1a1,1c.,1o1,1s0,1t0,1x0,1y1,220,231,251,261,271,2g1,2l1,2p0,2q1,2r0,2t1,2v1,30.,381,3e0,3f1,3h0,3i1,3j0,3n1,3s.,401,421,430,451,460,471,490,4b1,4c1,4d0,4f1,4k.,4p.,4q.,4r.,4t0,4u1,4y0,4z1,520,530,540,561,58.,59.,5a.,5b.,5c.,5g1,5m0,5q1,60.,681,6s.,701,7s1,7t1,7u1,7v1,7w1,8d1,8p1,9h1,9t.,9y1,a91,ab.,ad1,af.,aj1,al.,ao.,b11,b51,bb1,c9.,ca.","","c.,k1,w.,161,181,191,1c1,1o.,1u0,1x1,1y0,210,25.,26.,27.,2g.,2m1,2n0,2p1,2q0,2r1,2v0,301,38.,3d0,3e1,3f0,3h1,3i0,3j1,3k0,3n0,3s1,40.,420,431,441,450,461,470,491,4a0,4d1,4f0,4k1,4p1,4q1,4r1,4t1,4v0,4w0,4y1,4z0,521,550,560,581,591,5a1,5b1,5c1,5g.,5m1,5n1,5o1,5p1,5q0,601,68.,6s1,70.,7s.,7t.,7u.,7v.,7w.,8d.,8p.,9h.,9t1,9y.,a9.,ab1,ad.,af1,aj.,al1,ao1,b1.,b5.,bb.,c91,ca1","","71,81,91,a1,b1,c1,f.,g.,h.,i.,j.,k.,x.,y.,110,120,130,140,171,1d1,1e1,1p.,1q.,1r1,1t1,1u1,1x0,1y1,211,230,240,251,261,2f1,2g1,2i1,2k0,2m0,2q1,2s1,2t0,2v1,2x0,2z.,30.,371,381,3a1,3d1,3e0,3f1,3g0,3i1,3k1,3p0,3r.,3s.,3z1,401,421,440,451,471,480,4a1,4e0,4h0,4j.,4k.,4p.,4q.,4v1,4w1,4x0,4y0,531,551,561,590,5d1,5e1,5h.,5i.,5j.,5k.,5l.,5m.,5q1,5x0,5y0,5z0,600,611,621,631,641,651,661,69.,6a.,6b.,6c.,6d.,6e.,6t1,6u1,6v1,6w1,6x1,6y1,71.,72.,73.,74.,75.,76.,7l1,7m1,7n1,7o1,7p1,7q1,7x.,7y.,8d1,8e1,9k.,9l.,9u1,9v1,a91,aq.,b11,b3.,bg1,bi.,bt1,bv.,c81,ca.,cm.,cn.,d01,d11","","7.,f1,z.,111,131,141,1f1,1o1,1p1,1q1,1s1,1t0,1w0,250,271,2f.,2k1,2l0,2m1,2q0,2x1,2y0,2z1,37.,3c1,3d0,3e1,3f0,3i0,3o0,3p1,3q0,3r1,3z.,441,450,481,4a0,4d0,4e1,4f1,4g0,4h1,4i0,4j1,4r.,4s.,4t.,4u.,4v.,4x1,500,510,541,560,570,591,5a0,5c.,5d.,5e.,5n.,5x1,5y1,5z1,601,610,671,6f.,6z1,7r1,7y1,8f1,8g1,8h1,8i1,8j1,961,9h1,9m.,9y1,ab.,ae.,ag1,ak.,am1,ao.,aq1,b81,be1,bi1,bt.,bu.","","71,f.,z1,130,140,1f.,1o.,1p.,1q.,1w1,210,251,27.,2f1,2p0,2q1,2s0,2t1,2x0,2y1,2z.,371,3d1,3e0,3g1,3h0,3i1,3k0,3l1,3m0,3o1,3q1,3r.,3z1,440,451,490,4a1,4c0,4d1,4e0,4i1,4j.,4r1,4s1,4t1,4u1,4v1,4x0,511,540,561,571,580,5a1,5c1,5d1,5e1,5n1,5x0,5y0,5z0,611,67.,6f1,6z.,7r.,7y.,8f.,8g.,8h.,8i.,8j.,96.,9h.,9m1,9y.,ab1,ae1,ag.,ak1,am.,ao1,aq.,b8.,be.,bi.,bt1,bu1","","7.,8.,9.,a.,b.,c.,f1,g1,h1,i1,j1,k1,x1,y1,121,131,141,170,1d.,1e.,1p1,1q1,1r0,1s0,1u0,1x1,1y0,231,241,25.,26.,2f.,2g.,2i0,2l1,2p1,2q0,2v0,2x1,2z1,301,37.,38.,3a0,3c0,3d0,3e1,3h1,3i0,3l0,3m1,3r1,3s1,3z.,40.,420,441,450,470,491,4a0,4c1,4e1,4f0,4g1,4j1,4k1,4p1,4q1,4v0,4w0,4x1,4y1,501,530,550,560,581,5d.,5e.,5h1,5i1,5j1,5k1,5l1,5m1,5q0,5x1,5y1,5z1,61.,62.,63.,64.,65.,66.,691,6a1,6b1,6c1,6d1,6e1,6t.,6u.,6v.,6w.,6x.,6y.,711,721,731,741,751,761,7l.,7m.,7n.,7o.,7p.,7q.,7x1,7y1,8d.,8e.,9k1,9l1,9u.,9v.,a9.,aq1,b1.,b31,bg.,bi1,bt.,bv1,c8.,ca1,cm1,cn1,d0.,d1.","","c1,k.,w1,180,190,1c.,1o1,1q0,1u1,211,251,261,271,2g1,2h0,2i1,2m0,2n1,2u0,2v1,30.,381,390,3a1,3b0,3d1,3f1,3i1,3j0,3l1,3m0,3n1,3s.,401,410,421,430,471,490,4a1,4e0,4f1,4k.,4p.,4q.,4r.,4t0,4v1,4w1,4x0,4z1,520,561,58.,59.,5a.,5b.,5c.,5g1,5m0,5n0,5o0,5q1,60.,681,6s.,701,7s1,7t1,7u1,7v1,7w1,8d1,8p1,9h1,9t.,9y1,a91,ab.,ad1,af.,aj1,al.,ao.,b11,b51,bb1,c9.,ca.","","c.,k1,w.,1a0,1c1,1o.,1q1,1s1,1t1,221,230,25.,26.,27.,2g.,2h1,2i0,2l0,2t0,2u1,2v0,301,38.,391,3a0,3b1,3f0,3i0,3j1,3k1,3l0,3m1,3n0,3s1,40.,411,420,431,440,470,491,4b0,4c0,4e1,4f0,4k1,4p1,4q1,4r1,4t1,4u0,4x1,4z0,521,531,541,551,560,581,591,5a1,5b1,5c1,5g.,5m1,5p0,5q0,601,68.,6s1,70.,7s.,7t.,7u.,7v.,7w.,8d.,8p.,9h.,9t1,9y.,a9.,ab1,ad.,af1,aj.,al1,ao1,b1.,b5.,bb.,c91,ca1","","71,81,91,a1,b1,c1,f.,g.,h.,i.,j.,k.,x.,y.,120,130,140,171,181,191,1a1,1d1,1e1,1p.,1q.,1r1,1t0,1x0,1y1,210,220,240,251,261,2f1,2g1,2i1,2m1,2n0,2p0,2q1,2t1,2v1,2x0,2z.,30.,371,381,3a1,3c1,3e0,3h0,3i1,3k0,3l1,3m0,3r.,3s.,3z1,401,421,451,471,490,4b1,4e0,4f1,4g0,4j.,4k.,4p.,4q.,4u1,4x0,4y0,500,540,561,580,5d1,5e1,5h.,5i.,5j.,5k.,5l.,5m.,5n1,5o1,5p1,5q1,5x0,5y0,5z0,611,621,631,641,651,661,69.,6a.,6b.,6c.,6d.,6e.,6t1,6u1,6v1,6w1,6x1,6y1,71.,72.,73.,74.,75.,76.,7l1,7m1,7n1,7o1,7p1,7q1,7x.,7y.,8d1,8e1,9k.,9l.,9u1,9v1,a91,aq.,b11,b3.,bg1,bi.,bt1,bv.,c81,ca.,cm.,cn.,d01,d11","","7.,f1,z.,131,141,1f1,1o1,1p1,1q1,1w0,211,250,271,2f.,2p1,2q0,2s1,2t0,2x1,2y0,2z1,37.,3d0,3e1,3g0,3h1,3i0,3k1,3l0,3m1,3o0,3q0,3r1,3z.,441,450,491,4a0,4c1,4d0,4e1,4i0,4j1,4r.,4s.,4t.,4u.,4v.,4x1,510,541,560,570,581,5a0,5c.,5d.,5e.,5n.,5x1,5y1,5z1,610,671,6f.,6z1,7r1,7y1,8f1,8g1,8h1,8i1,8j1,961,9h1,9m.,9y1,ab.,ae.,ag1,ak.,am1,ao.,aq1,b81,be1,bi1,bt.,bu.","","71,f.,z1,130,140,1f.,1o.,1p.,1q.,1w1,210,251,27.,2f1,2p0,2q1,2s0,2t1,2x0,2y1,2z.,371,3d1,3e0,3g1,3h0,3i1,3k0,3l1,3m0,3o1,3q1,3r.,3z1,440,451,490,4a1,4c0,4d1,4e0,4i1,4j.,4r1,4s1,4t1,4u1,4v1,4x0,511,540,561,571,580,5a1,5c1,5d1,5e1,5n1,5x0,5y0,5z0,611,67.,6f1,6z.,7r.,7y.,8f.,8g.,8h.,8i.,8j.,96.,9h.,9m1,9y.,ab1,ae1,ag.,ak1,am.,ao1,aq.,b8.,be.,bi.,bt1,bu1","","7.,8.,9.,a.,b.,c.,d.,e.,z.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,1a.,1b.,1c.,1d.,1e.,1q2,1r2,1t1,1x1,211,221,231,241,2f.,2g.,2h.,2i2,2j2,2l1,2n1,2p1,2s1,2x1,37.,38.,39.,3a2,3b2,3e1,3f1,3h1,3k1,3m1,3n1,3z.,40.,41.,422,432,441,450,460,470,480,491,4c1,4f0,4h0,4r2,4s2,4x1,4y1,4z1,501,541,581,5e.,5j2,5k2,5l1,5m1,5x1,5y1,5z1,66.,6b2,6c2,6d1,6e1,6y.,732,742,751,761,7q.,7y1,8e.,9k1,9l1,a9.,b1.,b31,bt.,bv1,cm1,cn1","1p1,1q1,1r1,242,252,26.,2h1,2i1,2j1,2w2,2x2,2y.,391,3a1,3b1,3o2,3p2,3q.,411,420,430,440,461,471,481,4b0,4c0,4d0,4f1,4g2,4h2,4i.,4q1,4r1,4s1,5b2,5c2,5d.,5i1,5j1,5k1,632,642,65.,6a1,6b1,6c1,6v2,6w2,6x.,721,731,741,7n2,7o2,7p.","1p.,1q2,1r2,241,251,261,2h.,2i2,2j2,2w1,2x1,2y1,39.,3a2,3b2,3o1,3p1,3q1,41.,422,432,441,460,470,480,4b1,4c1,4d1,4f0,4g0,4h0,4i1,4q.,4r2,4s2,5b1,5c1,5d1,5i.,5j2,5k2,631,641,651,6a.,6b2,6c2,6v1,6w1,6x1,72.,732,742,7n1,7o1,7p1","1p1,1q1,1r1,242,252,26.,2h1,2i1,2j1,2w2,2x2,2y.,391,3a1,3b1,3o2,3p2,3q.,411,420,430,440,461,471,481,4b0,4c0,4d0,4f1,4g2,4h2,4i.,4q1,4r1,4s1,5b2,5c2,5d.,5i1,5j1,5k1,632,642,65.,6a1,6b1,6c1,6v2,6w2,6x.,721,731,741,7n2,7o2,7p.","1p.,1q2,1r2,241,251,261,2h.,2i2,2j2,2w1,2x1,2y1,39.,3a2,3b2,3o1,3p1,3q1,41.,422,432,441,460,470,480,4b1,4c1,4d1,4f0,4g0,4h0,4i1,4q.,4r2,4s2,5b1,5c1,5d1,5i.,5j2,5k2,631,641,651,6a.,6b2,6c2,6v1,6w1,6x1,72.,732,742,7n1,7o1,7p1","1p1,1q1,1r1,242,252,26.,2h1,2i1,2j1,2w2,2x2,2y.,391,3a1,3b1,3o2,3p2,3q.,411,420,430,440,461,471,481,4b0,4c0,4d0,4f1,4g2,4h2,4i.,4q1,4r1,4s1,5b2,5c2,5d.,5i1,5j1,5k1,632,642,65.,6a1,6b1,6c1,6v2,6w2,6x.,721,731,741,7n2,7o2,7p.","1p.,241,251,2h.,2w1,2x1,39.,3c0,3d0,3m0,3n0,3o1,3p1,41.,421,431,4b1,4c1,4d1,4f0,4g1,4h1,5b1,5c1,5d1,631,641,651,6v1,6w1,6x1,7n1,7o1,7p1","y1,z1,101,111,121,131,141,151,161,171,181,191,1a1,1b1,1c1,1d1,2k0,2l0,2u0,2v0,3y1,3z1,401,411,441,451,4e1,4f1,4i1,4j1,4k1,4l1,72.,73.,74.,75.,7m.,7n.,7o.,7p.","","",""],"a0":[2,1,24,16]}}\ No newline at end of filediff --git a/token_tv/assets/codex-pixel.png b/token_tv/assets/codex-pixel.pngindex 645951e..f485463 100644Binary files a/token_tv/assets/codex-pixel.png and b/token_tv/assets/codex-pixel.png differdiff --git a/token_tv/assets/copilot-pixel.png b/token_tv/assets/copilot-pixel.pngnew file mode 100644index 0000000..5b71d06Binary files /dev/null and b/token_tv/assets/copilot-pixel.png differdiff --git a/token_tv/assets/eggs.bin b/token_tv/assets/eggs.binnew file mode 100644index 0000000..2f51bb7--- /dev/null+++ b/token_tv/assets/eggs.bin@@ -0,0 +1 @@+{"salt": "5b00a560128f99feed01196660da0d55", "boxes": [{"check": "626fe2e53593f3d16964d98cb4c9bfc7a79c0e57c4d0ef0282c88ae038d0dc0b", "nonce": "36d3f984625d7df8f50828adf7e6b66a", "chance": 1, "cooldown_days": 84, "data": "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"}, {"check": "a8a7343cdae77c196e872e2b92a776b70b55c6d488e359ed7e65090ab17f731f", "nonce": "a4626424fc0047e4cbaa2cf4f4d4f449", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "0a46b29e4872ef4366b56e379ff5e3de50b2df00b172a88d95db89322e130325", "nonce": "1c7cd31d4aaa5f78b1bf3cbb5f8bc101", "chance": 1, "cooldown_days": 28, "data": "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"}, {"check": "b12dd7b11f3ead747a85ea35b1ddcf2a366bf4267fd56fa64cd1f9852dcfd828", "nonce": "50e533b27e3abab7b85bc90158340182", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "2a316a696dc044c9a3d5dac114bb050b90fa91de33719d0599abcb33ba656d4c", "nonce": "052f6aff6feb160c28a2426aa2f1efd7", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "1467b5ca67edce5855fa3735f1873d14ca5af001598752e7186fe9fcaf399c58", "nonce": "2983a59b4bc11a841a12c5a35fc7a7ea", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "1d0e7fa17a59b60204256853acb1996137c4984587da6c077427f0a80eba08f5", "nonce": "96971f187a6b177d24983a4874e3656c", "chance": 0.5, "cooldown_days": 3, "data": "vNDcYOIz8wRxA4Beebr2ekwdKZnQhrJMjqVN/Whr5iZHLMqp6HeyJSHp5ge2IPAJFIEWjnxruOJcGvm/XMdEMIlvw58lcJa0ut6Ic9cgDMJnzi/sf0Z4igH4K+6xkXEw+TZhJbbJN9jKeMsK6enqLaSp8bO4Hz66ry3HOH3GhQMBK2eIr6PMh0ud6DMuMWkJLQFUfDSPpS7MiMwLj9NYG3Hrzo6fAiJBTEi6o2Jt8LEBMbv9rfYU2BbMqDFEBb+f2mRdvVgUZ4zaX4MLTxkkYusfW09uM/zD9QiQUc7wEwSCoMGHSrKbVGO2p5L9MEzj7hCnQnHhckD6I5MwofUP9Rzapop1iTCCWUKyN7n5HkhdRqb43hgO//APfl7AQeidO3OTsDl+BjZnqD7dCkuYLVMV5AwnhKW1TiEsE4JToz4JVhR4xXzkWbq6vzHIPK6YEIUbmtJwNwVNQCbRjCrYzg3+Hao7p1Xtp/hAV61F65zLvNtAC0dgfu99sdvWvlGaMh2Q2HQX0fq+y6vijdZLh7ZomemN9aIVrPF8pygY4rMmNY1uSu5+vcm54XgBoQyN/0H6lcbZ4LeQOr+0UkKe83DDYMOzypZIjseonSv31Dvuq1PgPOiCtxPbV8EdHBmAfGPIZNXVgMPIrWl5M3Hn7soyoZFLgKim2YTvpdyPleeY9eWV4qfWVXLpricK+6epuChAM2VeU5cYPBDg50O2aexgMg9a3Uibk8UWsCvipmt21+VEw5QlBEHjBidNJIlBKHq2KUnrQoX8fw2giKvNIurjgaCEgvqBWqlhKDCpF+ez6uJpiuOq+vnLQ9jHcO3+SOtEc2lyCpmNNweDAf5LJ2p3UxOCohiVffieY7YB7tg5TRB/2TyhNm1kq8W3787LWlX/7Iq2WAyss8VVFtEBlE3sac/A6cyFxK4EbR9x/SWYj1WUSH8uy5i7hNVrnjSG5/zb1t8SL7JkuP4FD7wHJ8cf7KSrflxgva0nQwfwYZaecoTWTi12kxvKho4XNYwd71x6N4FhBYygUqEM1O/uDOJqB2KB6i/W66q+BmaQDCtYq5iwIn69fQf6UzfkH5VVHLGD8yM/Y2+KCljKV3q+gEPbHnoMGRb3W/aQb/ltvKd/iYgAOeCyDjPDpLRN0ek4HEoAPCO27X/FWcdPIm4DptL5MwytMcVYd9dp6bEhZ39ZWOCwANWUnre9nll7gwGliieBwQjlvgjBRIIcM3PPJaSi7khNdN+iSDBQO43tmdzisBo+3jzctdahGxCCfw2DkhhOZ9uvO6VHknuEfMq67CvU5RIPBUDoBM5AdhRP7pvFKA+pPef243jTWysyfqhWHa/luHGPztZTZm+725BW/T/MiRkt3iyCFnYzYfH0pcQdnCQk5gKwuOGWSff6cBjeXtIIIWB+GmSQp4PkD39U3+v+xFpT158f7yPsvuYYDdj9ztg9MGAk/TL7ggfsr4ocUrslA2mCLlWlVa35bGfrbZASxMmKqvdc94ou/EuKN34KITvyRelgr79+srbqpM6JbMlj7d3nyecqsPHk+5XW0tQ6AuC2brw2NtdRZ1oxJLpYQpirCf1Jh7mJgJkU8jVe01ZXYfGmgwcYc5E5fPa5+wB6BS89wdBSQKfskpI9e8cSHa7M854T9k9bQPTShwePHjtVWHh79MGqqhaHPJMcDib9d//mBYBoiDmeVNqfRmNmlmGHoGKQP/lrLzEPOsJ5adLInhU/YK/FfTIPJcnzN56rhDGKvRnHi3fbNMY3H+t+gzs3LMeK8CgpM0pMd/NQTfX0RYJNf1tfKViO1JvmVOSghn7LdfWbAWfgIVn8uBJv8zyhvZB5NlP1O/z+gzRnxUr4CFQF1t1tIsDcM4w2M56hhgxJluaUI2zpBixxIsfwjaiv9cQJ5UqMJAWYee5v2Rn/2IIFTPNcxKzIfqbaan17e/Rr/LHChDt6B6RnNGFJj3+xupAG93WBXHMOPUR+yIy/Ex7fI0Ngz2Qs01hxHpBW3ekEIYwbZs0s92V/wIcjJ95fqb72OU+S4Byp3QUrywbbF3ygWLeulHR44H2wsbiWbcDgJWyjOmdnyvNu8D4R2hvo3qj/YGh1tlUKKwuAMf48RZE24pdy8zVf42/I6MQsOGDaDnogMa1NSxhxT2ugtwoIQZfrRZ2MXG95C5INEU7CtrUizFSjJQYeyZ+LusKz6XtAqYGTpjmZufJPz7VNl1Zuj5m1xwodNocox9SEmT7hSX3P1+kMN/H1ffN3F9kNySMkbcgmp+MhYUhRrEowIXY6FFqlYJjA9XSADaRcgJycBKa2BVaDLcdHFdi9I88aLdrgBdayAY4B+jcjFtlVtw00Yc5X/VPY3XfRZ8S+4J8dC8FzPyYpkdMPViD6RBT18UOP9QgSUb2wW7vEXi140WZ11VAZFKIQxO2f7krGEwQJJMHXNRpq6y2Ddv6v8JHuJMaofWLFJln/CvQjyBCVmy/Sjf7Y88GQ4WpOai3xFr28whoF+Y55FXfXGKK1ojGhbh/fVUPK5ifX61UygEMSqVj7Vvg/RNaOAMNZbI+8CSt4cb0X70cpyOGAguPZZ/raTtOKvmFs6BQdDI10HXDNk3YytOtgK3wZZS0xQoYH6Nc32K6pNAalagwaxD+kYWWQypz+5mQCEu3qGyCr4n/zwmPMMsYSKUU5664yR+0gaxoR9IZd03OwQyS9TkdQ+NW+Kan18J2gX5vZ+m1DeEtBMwKT8cTgePBQl7RQGItGPp1v8V0vQ5OLtZ7PxgqDjVUFPymAoQqvY0RU9htSs4kQkUrso8mH6YmQi/lZBKfiqHvOnWQW3RP0lDcW/IOZNflX/5aOFOQK9Kki5ubiyUIQF42h4Md+9Drpzp/SQ7zvx8R1jJh1USPjEiQQxHn4deEW5PKdy1rJJdUsAW+LMA3Tfmhdzt+o8PG9FqPVpVARdhfWAiRtpUcm+xdDmcrhVMLGa8cI6dhVCWRBoKhUAG2DXazEtTREfCBddm5khMtQuCzrhQ57E58x/lhFFjmftAPAHIAoxoojZUXV+HH3kqasuVwt5Q5BxQEN8h0z3p6ugM8xaHEiZ6Mv64p/5YEoNht6xAkxD9ExVJoksenuW9t0DpLrqOGGUNsUEwNReS5bUKSlOO3OeQWwnWXcN5O9TUxDOT/diwU9kf6fVO1s612e4RXggJo0t5DGu/P4EMpZMgpSYDz/9hcz7xmS70whRiwELYvjRrUGc8WNyl93nJYvCg5nmdq5Ol/S6RsFkkdwLb1qBWMz9Nlr1+VJXnVu8IeaDDqTcZxHJn0zhBWTk86mGKhGhiymjDOxmaXcPlOp+7cCymvIkeHdg/Z3+M//EJmhAJTVA9fP6+bfm/zBmpY1zqASj9aD5sULcPOTZ+Xg+k9qVwObl48PfdHDPVPIWfVC1NXL2ZJpFdGLGDsXSQUsqtca+w+AxQ+mspyC+4wbTfXTvXxjHLBv7uy5RpQLmrU7cxX7XRpDY1iZW1RT+OxpW1oawAJ6KvUkQm6aBw8PBuT+/2l11+8bgeyLgxA5HDnZBliSPPBtT+p/brUwIjHYGdSO1JaTTxLuROO7ImF0GjE6MOTy1OYE/5VkL6bg8oigGtW6EV5lchPHDKPgJ3XjeejBp8tw6Scs1Kyi18YzbBRh3UG6k2YsM8kU88UXLRDuA2QC213+OZC7aNoz54HHTA+4bRvKeySiP3Wrd2W01G0JgIQny1ufBqBv1kSbEPgRS4oCDna1ihT4Ab9hCCnBJ62nZ9RRPukXwNvJOIUSePL0Bxp+FOpT110DcRg8sQiP/TzWSoe9zCQtSdEi8uWlK0Lv4RZFCJt5zKq4pH4NXwxmg3Kyaqae2YBrosGRREQQx1W1vi2jb0Mcpx15O73GulvaBWalXA26/7OsRKVjNxkBkzaGYR3BdzKopKnLqQ8+ze28iCHvFHIqOxcutOoii+ZUS+PIniEfR8Zu3qSMTlfPnTvd2k/iDE7uABDD3giVV+cv584vM7Lyvh0hdKo3uG78YJnGbhboEHF/2NgmUq5JvYlixLGN31U5zFIZuRC0Js/iZXFGqkJ6a07yLU9kNkz+6SNtCfYAgE9GSH0j5q2UzYizhM6FUrOMA0NhSHDYLPFMBR/d1rlWNTrlg31UxmqliMMTgILmec+X22hJ7S7e/Z1OVoXDzKPuw7cZ1+emoP4TTmaO8fxWB0lWN5jhAWMbOewj9A+4vOwgH5FjbzN/pUArmj8C2ziZfp0/DDnYc9nkSdSesb5mjOL/iSOJwE6/psnQfqzRTixXDz9hJX+WZerJpYTv63+VhrDoPsoujcD0NljMjTojTYBQbkAHYBofwBlJhsyaQJcnf222k21/oyKP0ELw37df3RNiqanzxpRQ1WClMahBpFnizZ5xC1rrdLV2FiRBXO6YQ7xAtROs21NC54JM4yy9UU5VLfuJOdmhTdVFOvzYceIoqxBThM8ISawkeRX4dcyoOxjbl3OdPhmYENCQSlJEPvUx3KKMDJiNnZwEiWDzZtGOnwG6JXOAOguzlod7eq2ob6P/vyP8YUkAa14uTzTjfY8XqqalJneWQhSmdoJ+s5tQOh24fpF4p101aXlfZEN2a8KtBWP74J5buj9uRgPSpYknihesFI47ebhLbB90V5uLD+TStigZqwl06s5Bd5jgrgCkiqGl2lhaXb7ORq3edaJ+1l6qgxyvGwfECxgXbRhmorEdY2fS0VC56B1CCG09JKnT3KGirrOMli1329YKVIscggMTxooaLR8Lphd5h4gyklMGAwACYdfX5TBUK4s65JfqAbJShE8GklaGyab65dS8WVa+iNvdEP/I1fcjbqnDtl6FLT3nCSjFHoLSTBWs7waZv1e2rJNPlMJbl+RvDpj35f45H1V18tB6QoY9t75Wy5YN40HjqfwasNJY3uVo5tixQrBF2Jm6wFLZ0e/Y3EJS6upIje5CKa9XTnB/j1/aGR6ZQxhDf0m7FXl2cucMwal6hTsYR1kco3nVeuiK/1gXtg+hB28iJVttAwvsxcow1rIszsEufwklZkglipX8CuLCu3bErgxyolNaJy/twnKY/aPmsGom7JhaOUTYRKtZuBtH6JYtODyrMUkFnBJ8jcTshZrq6Glq4GAbSXJDytoeR00kMiWhw2y/Tuzs62Pa8HXBh3VL8T+t+faX4RwOAfN2qewDWewEtSYzrcA84Du7w53KCSMz61DrWoJ0n2+4URCP7rmjd2IEWw55yawgEzcqUdlKkU9zzUkEmhKb1jfVLfJIVCUkFFdJXqDk5RM3Frqt6OncstcRmHvEo/UJSgCKqLVOd2OeahNDjYJWKz9YJ1LVGkOGn/E3yQEwV7C1oN9S4TMoLXVtnPm1PgGbrdG73b6Y96m8a3jQRHzSBTAkA4uCxLLJEfPpMP4zB1Qp6YlTWR7L596U8LUj7vAiDopISJ9S2wprszIMChN42Ho30HhxRVgIj+r50VmIk535+bRGeCP8zo4EblC0G8kRPQFPaZGVkrtZXlPk1wEUuwiO/lqn7HC6Hw0t8hiDRX6IRiXHMbIrOqpr1vm3qwQXKFtmuCaCSvd0qewuzVZDPm7GBKp9a/Fu1mg9ff6Dp7pM9/qCaG1G5SPx1fvDtiId8P7fWAzhcEa11Y0lvVCwPgYv5ytKMRK7nD5KJvXrv1hACnAe3Av/8TUZtxR+WKldAeHIbIHM1icQO45DwPYzxLFlGa1FKiBGPBeJTHxpTfBlCDPQ9Z2UJtFgrwxH7aZ1MFHDB8E2FvzSiAaN6AcDQFQE1IbWkkK3tPhgQaA5L806SRqvyl4kKtTHy30IsFops00yWs9MObx48tBVmq9r0wzE/oJAtYJPbtiTyHn19qUsbuUCHHgZMuGNk15Yu8XrgL3P/GNfHSi27x4BNxkyCM4Oq7SBGlFzfE3KWPlj913Cc2aht8XSFFGxVkFJxH5BTubcIQzTVgQYf/m7Kxzo3MaZvkd/+m9jZ2IxLt5n31O3oQbexb203kjPAzCzB2AeY1AAZ5OrIzQWO2ghwVxK7+egAzG793q2FZOAhbK0O3KPj2Q5Bd8GlftS65YWlH5XzJsgYbYmkpD38nWKW95fuToRzBef90UCyybSu6/BZpqwof0Kn/mURNQsalvhJikIvA7c5kSZffQqh5QIOrkIgxQC3XqmFlMTWBLJZAlntom8dHxrSgZNWncpLJtYXIO1hRK7MKagwHaWrZIhUbwSi3c3FkEsnJ/uk2L1nLH0p4pTZ3d7DR4JYkm7tBkzbMXYVfQUtPJcmWLK0awTNB5tdhho2C6vtyWlrBundEFJm5cI7qrg+x7afuWpiR6C6zLtPTSmyU5N+ed3KInhEowhmkqaZGoBE6MzMYXnPqwYrZBQw9uU6y24gsnlEngxR4seywlUQn7dOcTXuexQEvbUysAdl/kX/D+iJ5uDV0yxnx6N3gFNk4szKN8y8fiLxZ/iTjhCgx6IMuv+LcIOOyISOsd8pfAvkEWwi6TNhg49i89V19Lb3Hiq9iHKOxDcGUwzAO324FD/zXrFy2I57VE9RZ+MmiNum+UEfi9uzAp6dhv0WiZrLsNg9CWyGLHkrqzAN8HI5/3qCns+h8Jdi4iqjafEH61e8HGni4JVgQDJ3tM7O8OCf0FZaDB0sXdVlmg4RpokNNAnIJxm66jpxeaNxkp+XLjcxMEJXTO7YAK+bHW4YlNerq1G4+2+zNGPJEr0Q7ZhC4q/wFhkcT07QfBTn69tj0mRkO/6dlmcu2TrkJ4PompbyyIkzjfEI2Fvda+tuTbKEFkbk814CehuE8NZkg+NrLnfB8kF7LAn6WrbTeHDbEn307Z5S1K8U4ymyYnu2ucwVP3Qdfo4Jd4swTt1azPiC5BCjFleyNBWM/QyPqtLeyq2MTV3kFjYWMCtVqoRAPJJsjYNPiSsTpduXFNAD3EsTDto1FWUCYOkszwcB/4bJdhyk0DGTC1LdnaNiWWmfvXqSU64EUr6PqHV0SFzL+WmD+Dg0AzOrin9vnHloIosiPvIIAkVV2gAnV7JUCn1FAR/5ANy8i1LEfyNDFbw7+L/cPl86IgIO2PewxRywtdYUG7OWOhKnE5HBKXx0VIrp+I9kFFQ3MCxi69K2diSJjq+4zRAaCaoZO6CrL1a14OeHBH707m8EWmo/9BSplrJ+RU3JulopeUkdRjhfAdzrBbGXcnQxSxURMEtRCU+LK/x4Z+kN24aQUpJQSNpuPSc50/TSKE45orMHgo1KE9bEBqlGkf4TCKOPaCC2sRDl3W4UWGAustnIWxoIqe3pjP8ag+dRCfGrnL+59nEd9Uc8KZEg96lb5BPQKjLk60nsXwAXZfxDTTSQV9l58bUuQfFm6zxa5NPrXZRphyfAo5G2Dv6lWt7pdNYlbxmkkhHmp5RKZvONfVAXsNstB+kdI/rgrto0D4dtLFAkYBn2LVrzWnqsl2zP5bouu64S74jOxSglYqEBe5xOxK/McUqeGM7IUQFLxd1XbMH7XHEDw31tC7kjJxNdbrGpS1uaVlVX/mvTe+s1DyNvdYyAvwYYupupDiQqPekEtyknRc/aT+pippNvOAl5SGb2bkh2Xwlh17Bzz5iGjBwvzgp+lsh5SFCcHkSKRRTLJTBxM5PVdsKl4QFowEhm5fNxnM7EdE4Meq+6YkXwcJDACE9BJ7yVBG8WsXw3U4mro0Pi8n70S4wFw4pnbzy006nd6petqN6NO5tf87gUGq8X6qziI6WCixJVUUd0XFjGfWFQoQOY7RA6g6vMPvwf8ziZbGKUt+/+Lwk4k+8y/TnyE/w51uei4iw+XCGl2S9Xa1/l9bxSrqX1XiPl48n27xgBu0GqTOuyjORyuzCWb++pG5bG9CVHPnX+rzfBke4Kms/n9sN7Yml/S97iZhftSoTIoyzemaYfTlNNBQbol6ODAMFduZAfKvvhrI2QCGytnfC9kK0HRchYWZHK2FtYwHplEIWtgdFXyVlNK1RMun+41IQK0iMDYRN5RTiT8m7/cek6bol53ttsUbCpuf7AZ3jU1BscEajwftDztSA8ihPytfq3YUaVfrVvltx99mDSL5COGzMWf98yrq6vTRUTx2BiISh1zLrefTAHj/g3A6XusttCbE4RnDNqhLA98spZ5uKDm15R3/IUUw4FIXSadR3Y7qYBtoKMfLGGQ64Ven4V801KPO2sUdagGhzetdu+VVU9Z9UyKG+MIVCZksZty8AesAlo1vwJHEUPQJ3ZrKMF9ioIReKXbCZWotvNqfft7+d9f8BFZH2OYFsDcELiltawBNXWxXhWtINQO0aS8ydFX+CmQP+zP0UmKpML0B0y2boMxbfLID+/2lYR6FralO5Rp+vjLzFEo60Z8+g35h5TmjCVeCH3rXLEneKUXsG+eeBX5Pi5FKDaaySQQIDDUVbLXqZev5q2EOzwwSEIsEuWhYySy5WOojcFU+5hv49OcZe9jsNUMViRAL+5edZkc5tcFEU4EEDOQgbRM39Bv3TfYJUoChvdRZdqVwm3uyLEwFaPW+OqI+rqXtI6e1XkJURr+QjiQMfIrmF/44Ncrn8NfLzPigMkMyr1mTgM3mpuSa/71bPMEBj06Az/w6RuWUl+aQdcJLvMEl3aYl5QKl1yFZ+vIveZePeC/z4EYl4aWG0QFtGc64Q84WpeNvkLPwf/xb+HxtCoLo5GCepdvy2Jww0dHSO5nD+QB3XWkAQA8PQxvHGeUQr2+4cxkWsFYfIcT0BIDt12Yy0lVQ937Z1R5H6n5uEsjDqzRoyUScBLiaSDiqT/9i1vGfaWTeNgx20GjSbe6+93TqoyIzz1vcuH+HuYXqjyDzDenRR99wlhrF/gHHC8WFjbWFnC8urWkYA44rduz81at2k6VY0toCaieULiWF9uW9fopGdd7DQA4fuOsYMj60YGdhuxXdoQV68QJtDPnYAHK2qpzhSX/AsOCckNqRqnHV8W/nUUdbT2rtA3w/JzfmlQ7Uo6UA5TcwZ3Ggp04ZoCof1XLQurgfWY7nWUBWSkGw/slTfbhb6ja9WuiwSXzlgbYSA1FD0jO9Ib1U2YKWH5/r8mjeqUnqhNDms65YZMPn45o6UoCBQpYUyqHt/RQH0Q2ugTbcf1ye3lAyBMpIj1cuYeg5QYc+gyM5OkxZavlUm/4D9fCsTwdaSZRWWPqe+ugxUsmk6E8BXhdMF4QmirCcVqbaUkwEpMwADyhTyrrt7W0Wxb8/bUPrEvqPalFXBTES/IRLSJUrICLyTnKtmlehC7lkDJDLOZjqsCqG2R4kIYB8CIqOZ8TsNWq5ma2iU1Ac1l7tc977y47si20BJRpwBV2JZFMAmogrUe1uXi5qniguhJsk2rDVpS1ufsXh0H+LXcB76jM18POoy3bFEQCqRn5Q1dkdvhnw+in+zfQtSZoAXfbQfglsUloK+/uB+BCfPz25cYPX5a/Zdg/AoEyieCRNCbMrX9HulumDd/TnBI8AvWEzaKnujOOgf0ui/9HRmP+TuvNdy2wnnInw/MgWLBU+jtA7kc+0XhC7T4g9+jxzb7dgTybq0PEWWo8BZaI439443ncxmniNQxJOHUwYyGgTipdEpgw/UKKqR/NaTOkma2+D7Cz1tzUBPohs7MVoOlrXfEIs7NH6n1OoO/T8nF0x1kmXWudfXpIU7uKO+1p9aUJO84CGXBvcjvab5E+un8JwP8UnTTxH3uowadgWZxb4Sn3Hieajub9sl2UCKDahrOYEz7H2yKAgOmwJAj+SW8+szU5R78pE+m4p7HVtzpvnA9D3jA8Z9UYy/nRb/uwcb7pLCMBPkG4JvIr/HBIr+c4SUfuf69dxEfLwBT4nio+AZQOGOCI5fWJbASHHTpNZgDR4oCMHoKdFNhyhlDORKP0FELi0gK5dOLVgkVmCix4fD9Hzh8h9Vz7l9aEnsCu+u81OKeCgCsHR+RKiudvx8fgeVFQMdLWkeHMty7B8Sz5lRzB3CE378Jse7Fz1H9dig0dWBsKMlGhnQ01Z6Oj+uodBcMke/ocPgxD0OZ7b1QBzFX9SVcl8gvPIdnGQaKMx6e8NOpgz8D16toocngeFNawioB+NR29SnFlX8m/9nwkOwLy+BR2iUsimfFy8AiarxfDxj7g+5qhBDB5LwuFLJ+drQ9TKV25K3bIqNkq79JuP8pb4nylH5wqKDeOZye05KXPSY3BF+AHHImaj08FijBwLKCXPFSBJAB+w32AVmSfaoI89IQr3aQ8lMXrTnPOBrTRr7OTCTkleMfspihDQR8+m2++0SlkQxSWu/pYFzbRisrGubGVPvj2R6SrlXlVQq4GN558b4hOrOGTzjl/CMkk7ThAzAaiONmNvo++0dN+FV2a9kA8tSOwwoeGy43ORLYYj8RQ30wYQ6q4saXCknq/dVwiTNrqKL1tTL/+ntcngu+4x3e/MudO9NH1TTXmEXvZpT1XyhYbxi2AxilXxDWfCj48Q2Zf/KbMbGNANe0o2RnaAQaEP0KqPae2kIcGk4x+WnYqgm6R/FUMIxJ/XwG9HUAPuEzGgYzksZNJGLQfIqoIa+YQOdoL4M4uVFU3Ex0CYYvXtYSKMKspvO9bou5P/J3/yAYKMbFz3+nBmuyiOGrd0WXji196Y/J8mhu4KSFkGcg+7tPqBU5USNqxMxuu0SWht87ZS/p3YdhdAdBoELuPe/Cgs6y7YNU+xVQsRt2tP5lT3H3i+6pl0sgreiaUmIhjV8aKRFHrf7wlLBFK9M7e2qdnY6EU+hID2rUFRQoEcYtAz3HntrJanEl8A4ROWDK7X0WhAFbaK5mmq+k6SDkr83ka2SGx/lewTJxy9fmJumrNt6c9c5fjZDNKM/mzTIjFKi8T+apOe3altZuIX80VQDlkPQ4lSyTCvOGG42fHo9SmkpyG4FIEkOO0HSNTSGNktHoMitI3EFIoXrLfaLrbYIWxVsBtumu02DT50MiLIjqXc3+N3e3d5Bk4yKzPtpnvOHbtFaIvQCNVmkCNQJKOFTwd300+l7uPju5rbfkDrhAjweVJFXoPQ8v2029bqo/uTRSxof2Rt8ZovffX/4P98feDXxU/drS7dNp6c9q8wufc9eFSLWb+F7DA/9TgmjYH3uBAZIXw0aNGAOd6faUfnCcSbpZNdfXTZzKl+sRz9a/hpbtbRXhdNrGyrl61HLUTheoX7sOHAhGtsg6c3By6AdeMyGXiOMNbno2ioqywTYJq+4wdCFRE3/mGYbgtSb7Dnk2H7AljH11iJMF3RfzqwkTH7LVlS9cZooxLgWPERLv11y2ljMqiegukQ1vXuI9YsHOhrh0+jPpFPLTcYugxsH7OlpiNlpYXc3i6Ttyd4XDJ2ct6JqJclXFlBsQ6xQgdJxr7Pg1b6mS/1QbTxbDJLQaIlN/jOMCYEsDV2FcC2v69n+N/2iz3lNkaBxDCxsUFQ2mqIYe0+03ZZt5+ZkGqjuMB9CiQRCqcs0IRbtkbuNrYhXdDQi2POTokS4+83JYU8ttQTz5/UtqMq0NJ9PK1LvfXE5yivxZEgUK8x0yB9RfeGRbLtUthUVV0aSzEUzXYkGLdcBwUQ/viyg/ug7vKXdW9om/8glzCmma9H+uP3A/Dn3rIo3g6HZypcOe+s6WjnLpKLZ57gEsW6IdRlskH8x8dpTmDl6lklqrVYYt39Gp/8dqEJX481/SwXLNZ8o/sa5ySJtJ8/gxD75Q12SEjPXbnOXUegF0FcA4tOw7jCpzmRwWUlpIZdFaQEfSOi6J09dAUUvHhzkX0fcmBaH4zzfGk2IS0nImelopADduPMqDxzYvVfse6kkprDRNim73ijbOjqFEDPZG3uVg3A0W/T0qzJxeGFO4HeqSV2AXVCaHr60SUiGA4QGZl/QuxiUbIsB5m+H7QO42wa26MWc4MMc43C4wzL0dtLGLbk+/1Ma+L4kyHMPHIxU/YhGwOJAmeiMaOFx2spX/yqxPfFkmUQLshwoZ7TUh83pEOWA2h8cMRWKoAv2Y1NCrsmLdk2PEQ76mJ1SiSIxVE6Q0Ra10c4Avi2fjw45uKgZNtuy/6+5DP9bl64hV35I+qzwVj2W4dpt5acOKi/ACbOlf56Of3I95H6BqFJGYG+FhsxrZkfTf0WBjmjooX1rRJOa9SYuma/azehOySHu79bnejbA1PuAxuLoqkzaeXUPm5nv/gOigxla47xbcDP7vxi/MVRSPzGt6CxPnUrID2MGeGQGX7RifyZ/wiYKUKZzmYl1L99LE8oXTgxbRcVE5cV8+i5K++ByLgsabUN7l3L4n+BdReZ5aa5WeBtgiDpmNLJnRJyEwvIbhwLUgm+R07SwgW0iP2sE//LZ72dYZuIandok0fmv0K3GRqLdzH6hecMlIHvASNM+dQ7tCHXZHLbBbBx2IeoOXvwm0ZxqzyaPa54oVB1UmOIL6FfwpL90ZVSi2EiVxNQIikDriBvhs0+Vo1SC+txhuS80CXZjO+D7ALNOtLQ/RIk8n2iFUc/o/6qFkaVoKPKR4QjVnhXE5kIpcWN3TJiDqt2JRU7aswtb1FxLw+BoZu3uQQFSjiVEXETuzbRq0JmR9G9/z5V9/+mOWZgY2i7NF8BBBNG9JWhiTjD4m8XLa/xX6hCALw/3HkJNXItzSYq/06OQWoBbvsGAARDWoBjb3Q6NV/pIsF5ZtjnYapVOf3LaHDGKnF6k6l2N6fAMw9CpAbEG27QQXLkY9/IwpW0+/h8L3HCMmyGv8nOS7sKFzxWFT3eJId9YwFKo1LSyw7M0Sm8f4MzB8ZUu/da95Mq8e0sdgOz2YzY8Kc3Xg0ZNP1FOTE5FPKw3Nsjrhs65dxnnqENHQe6kTeSFzhFIy4XSZmyrObXV6wPtl8Au5g5wnTBTGWpkUBYMo213fHyUQr6z6gEqzjkLo3yhaLVjkYKx+rWZEu21iPs8vY/zo8m2sYEqKmyX6r9NyNfu+qdqOWMBmGAStfxkTypvVHunwh9raRfPMShRJ4V2eh5h33ZugCxcq+wunPbX+8EFodNLrQIDB81sVSuRYyRjoz26EsUuvtb+V4/YnbrXl+FK3A/Sv50kZ/OoTThJmSg8djDGpFjOLlO/sCX0KgPnFx8iZ0z841S5jjOKBgnamy4byRgW1ge/A+CqkTykoB1hjd2ag3DtVaaHj1uyt7aRMgkPG5KYllgG456HNbBTgehZhu7by1KUtKZkHyaY5gthZ3NZKIyidvBipVL7OO6HA3ntv40rn4CH6vqsGWn55qat66P1mgzRgseOnpnnnyiSMjV7qhGR8ugIAv55YM7xRsOw3WFf2gUBJfEwmbl2ktTZd5AgfoCGVQQR2bLOyNOUBRoI46cmwu0fii9mCLkSGbfoyRyh8t+6/oEMAMWbzdRjp45D5H/ZobonXGEOqvmNXDKOaKq3Gm0ykIoHNuBJgqE5qb5dbcLAguf6SCaHSkjSG+InHCaBqu8COJ5XuVAhAMmqFGexXYfQ2+5kOyyG/WJEdGHncPA1tOhlzQTay338Uhq0SHCmBIh98yxxSIkHA85cyuhbXCUPSD3gx0BYhVKrFShSxzBs3QCCSYhMFpNApioiVbS2bKMRSfO+iMOJVX2rL1tXpD+Ne6Sv77pWdpDzMChNtQxMcZq1KmrrGiPnbnb/snZ/oD2JPS6008fEeE4moVajW5Me1teh6/dw7bYui/CBZYUL05vS4wdefIea5Zg/1hQIcvXUxUubOLRbtNu9KT25wkxNQngFOPLaRH5jYsf/6s/UKGQWLfl4Hf/9jB/xpICaPwFg63euY6PjEzkXAw9TbhhW7kB8J/i6qmKhK0SV+a47X2SHhaqSC+hZT+HZ2AiIS46ur55lbW8ex3F1PtlT57nXRJ/ImFmTZPKH6ybloxoKuIV62Kz3YXfY1seQmZgnPsgb8/V4LJvGqtD2zbKaOytVHBsfEj1WERKaDBasTeT53m9mri1Je1rllkzNl937A2duu1LbhwVhAcA+HKl7AaxK5xja4ffSSsCPjcisKgesugG6dDv3yl58I46IUcDLQJxnOxHVxyulFULE4zACqQBgrh80FGNvjq5Z/i8YmzCWZGsupdAFg08C+MI/x1OfrT87QDJNJKmysUMboHLqsibmW0bjdukpWl4Em9yjywb9XXK5mPB96TdUOT9kVnz3g/+NOkn7KKiRSIz12mbTJsL1oUYvUubThqWr8MACpSNY+lJc1j+A/N3SDYRONietxojFfwO39+szDWKeOvjkIg0YrbZza+6hCCNr1YYovSQ2GgNDas68Jjtm7WlSh7+SNnNkgqF3q++PLQ6K9yBhK4DwoEq8uOSmoB/dXHzr2f+aRJtLNDHgfB+YIxQMhp+0QidmeQjYL2jbDkLZ46Ws681GRzCeHse5HTTYdj5Tr1Pgbg66KywhNrrRrEdNm5sufyNoQJFOadzObntpFovD6xZhDxzrM0GHiMZ1+LxYEk+xMLAH2bKuav6VDDIbhLjkdRKjqGNPqKFMhdilefqfMU9Mx6AMQM9ejaF8Bv8Djf1dfeZNMTW4I2efYvKI9ZblTMdIHGuDWm0/KNLDazhclH6bCzpiVGHjTDQ8kJ9Zl9zgR44Q9YBW0Sika2KRiUbr4/gdQBrPdf7vYvCvCc95AaibQim0xHezfMjZ7Spmw9Hky534/kCnBXyo0xWP8isvHoXj3fpE6rk23J/jeS495KFEDMdQ8vp7ID2jbVjQi18JmQ3tOe603b0E/qG1Jp+la8Rz0/RUNPH4b0JcdtXi62EhflgPWua73OIoj8jw+QbFSdlz/xFPQSf1tsTzLrjj8kHqoSoc8TFNiMA7wHCcgU/fbcg9VOy7lBCKYprfA0GEYnB0uQQrWtCqCpPmZAhZUdy7xIKajTPC4RyRNMYd7LrOP0PmR+jwpPhsVxil6LNywdUNysz6XNp8LRTm+QUVFwX7LNdrfgjH9OkcLLicZPOrsmNpbbEGnWOQlFcVzRYWIDXQzAKvDYjhTgDhf4VUyxcOf8SGP9d53tytkiTn/b6+ZpBFd8b1B8EFJIdG8kRcGqNvOaJXog9djDRjrwowpW5n/7rErvoUFFSeP/gCHZf1sY8QkIhsYavA/JE0JhpxHbBOWSulLacKzv9Xjsj6n3N5AYIP0CsX8PFjl+D0sSQEG1zSBw+XEAJaD7bgu3g90MzV95KiH0G0XgafhAtYJrcTvlme7oUDsZ2RnhCSzBqOfHQld5qVImmRU28V1HKSN/YrJ6YCz/GPVC4aDwOQP8msWd+EcSZMxQLTSV/yxjY4T3dJLUWJDwdDrWS5VkmG5sFOkTu+aoFcGL+YxvcPWFRRKBDq0Qd4/c+maNXgX9TVpjUfkK9T4rCVbSicsNhhnem213thkI+/54GV3kUuZGj2Zlp5vAZz5PMl7nkSphzt4w1k+g3WKmHl7K4JhJPZmxv5LHxogNKPkud0iUFw6XKqKnX+Q/VzmpAaIlfvBfHtnhdBR7klHdSk9Ai7zHMXi0yPZKgYKGHGXbUKGWFa/mJrfkgZwXVT/rKGvltTEhjFCaOZzgshQ81ZtF+aEfECthpM0TGVRhQL6E86Qd83dPfZsOEKmANVQ25x01FiGH7jAz9dyUXeAKLCXLfxPrTND2s1hDKcEXI5IBfKGwmCpow1CCxBQpGWt6A3HvRxqTt7Gm3Ia7vPFAZe54o4GB6oBOu29v9J2NBZYLfglyt9FQtQzeA9Oelda5PlMyYbVzPeLrP+uZZRWYyPaIAQ5GvrGYZ0orqMZb9w+sZCw57wZQ3St7+Sz1hN0SKTG5vpXjXev5xvmSpHQyUI8DeQygC26rEKdOOr1hRqO9CC/d19+IdEtUZ1iXO10MDeWhq18UcGeHl8ZgCj16NI7+gpC7cvxIJBP2Ep1CsKWqfhPJBBAKMe1WY6J2mVdEKLSvtbpxPxki8CLtkDjfyFWVGPGPPuzM1i24qFOkYXljO0vmgdkUtjNoWZCfCT6ErEKOmF5u9JinyrBPtTLeYK1yAA3GWc6BZd7aF6NHIkDTFPcWBoAPhvm1EH9w4uIaZRGC1h0uKsPNITR02RoPPxujSqMlpz9O6xA6hXb2o63V/06DF7C+fw8BSiJPXLtMmqKYYxKAontrP9ynk4eG3LtAbhEc5RDmBfSkVA3ItcTf8u4SkLG8Ru+IibdA7UW91dkP/t2JosjR/7HYgr8LUT6WBkZSiH+2pHY+/1Oy4lVZTZOyJKAf9k+0QgaX8jHay1/tE3BdHxpLq/ZKsjP0S0RFJev1x74IknuhBNG5AisxgDwLG4fBC/YdyV3hbNjJ1D1YfQ6bdrprRZUo3mdR9UxIlrPvuUup1b+NkFd/xDCM5BQ7RoxhMGJRf03Ge0MbX8Rds6dlJ6mJIOJ2qzl/5LhcMn1f3GXYm/Fz6hfejabbLuuYVmvhkZHffvfp/++7Kjh9D17+GxURh5XdOfxhZbk6gRYDFQ4ovtsg4I8pXKyuniiv7BXwIpN8y/8E+3F4AVXoU9Fyval2IgRkoCW6rtdsd90iGoa/GXD+H4ZouCB2kk7otwPwzJPEC1ze+9QiS0rcI0f6cEBaBvKBhE5kyYyX1agiOQVz1/A3WfzI8mjoW4DHHaEWO4pO+dcm2S+lKxSM0EvWpY+NXpQKmMmbL1DOX82EtH1VrpZi//reag54jFwfXqpVn93WHNXwx+gAMv77fKINoYwdpEzWayDyf78e8jcDdD2lAYNgompQypxT571bSFGpukZx9wkDjb8fzr0n76wq/1iiaPNj3dy7N4dzV+PMo50l9CJKvl1baiNSTqVL38JZOcyhSCTlXQddQtwYWUCfLbGbpeKnlEkHp6CMPkYfyCd1S4dTcEHkU29rAwB9fh/UovI8rR+Ba9y8NEJZ01j+phUXDa7x0Sg3eNVYoESITisPnAhog2jyFUeNfGfiPoIik7McmKzCp16RITP0rOfFJxfYBRjtXqVG/VdwKpVkeicTIhnPxm1INp0iws5CkU8niboniuBbTRU7B1BD3ykMcEiAyEqNGo9QI456yl26ZhZZJ0KGcWyP708ZdTLw+tvb8rvCtgE3YqjpcZGkiyKaWK5XtjNvZqSLK0Q0EICGYQO36CkkYl1xVS6nmSuZCDu1yf/TJEk0oI+MzMQVxt09EkMxx5i65+JcXxpG+F1BZlxHA6+gQXKPE6SDfWuyjCpQe4JUP+4VmM6XPovrn7UWJpakRXoUkuyChl4quGKh84R9X/y6Se9lhwFgnwTth5H0c25nXfFSrmPPHaovI2yRQ2Lyd1W594wWa4r9iyq8wW1cJhaQKbuygt8BAGTBVuOBmGLzSu/X38TAVoPnHQSoRQIgwX9WeHLyjdG9uZl3ztWis7ps8RK9xir8sAgMuXq40mbQTMx2QhDIv3jIdIH7/EUubW6rqht9jmgSgDiN+6Dd/NJOYLAE2e+QiuYujt9PXdxWuHlJ5UxVsxv3/XCq16xTELDLKX9po3LOAiyu0GbXjkvbofiHUqetVe+X6DxGUoqhII1244kVb0SWWTLcmCQRHGu3vBuY+BNAWd8/fdtxsSbQSOJqXz3UImi/avfEcsB0FsrT+Dk/ZP27ofussrz39IcIYcIcbVBXweaFdInfMyabJbGdTcu/cKsrTEYTduy8LNlgEM8qLjpob/Sr5SuPLWRP+FVEaeSNnEFQS3AO1+MBmuTEf7tdgJzJj5HjyOjWThLf0bdDNZJ28YkwAmNf8bvyUyE6k5Qxck0QGfDR+r9HPCgYQO4EoMNKwnnuhWBVv0b+OH7+bZC8azBKOs6nRIhF1Q9DHkq7sx+F99ibc2l/4IEJMiDcnfGEORK75zeuOv68cL/DQ62T3/LiCykG4NP6da3tfhEPHWyyi53j3ewIxtHQRIY8o+QYFnjq14+XFbfQvN9op73JVPzfSayLtpAXktQJLIhwtXdAXXlEJV5LWBhlPusgB/ZfHMpk8l6mxX7PSngkpg08ZIy7BgzctJCF4e4Qzv2rP5wkNmJsGDB5VNxo28mRprgU2czVlUmBwW71XLqJwjvbPH5sgEeSxUY4vYEbmmYwNOP3nP4qQwaAoHuXA3obBIv4MGSMJYux90El6QjPkHRbFCAZzmWQSJndOto0lipzCXpEWLWT3ueLh01wE6cnw2iT1/Se9HnplyT+yjsqTF1QUXd49vGIEFUJxExPYX4VtG8p3Snt8Rky5rDr9CWEdUAHE1KYE621UoCLS64SUGff7vx/lho3swIt2Su8z78SsB12Rxqbaesmilg6eMTppSj1/FFkyczykIefNMZ0Al5hbI98XSdtwhWcFCdNp1vXmUgkcDBITxNKHx86Oaz3/E4ckhCrykIgTAMPvhuSuK5ZbFqSSrX9Jk9OdlFpqlc+SaAHD6QMBMiYYkszBvkD6LdTf0h7SQhHQpFuYm/RvJF0q/sQYG49VZJRsE7OsQIGOnjWrjqyl0H3JOc9xoXpyLs5l9zZ+e5uq0BQi54irUef5BdiPlsNmdZ0Xl+dgNbLquMQQEmNaMFm7mJK5pJ1cuhEdPcAaxwdYuN/b5Ff5CIZuxc6iVyaIfWsvmq6VLWVZE5FtSR+UPdFYdm1xYRpPrTW2+wxEVWq1uxXEW7gVMacO0lveEALGHId4/vHKpX3d7sWxm3tS5zhmz5+pYSdMieoGK1SQc7/El6r7R6WOAu+brmrjbPvUFRKzivlysuE8DuM1YVsHN/sn30hiNxwxWVHcIrpwX1Tz12wiZL4aQ0KNDCRJrpyypL+SSDoVWv8mEwiOGXzU2Y0mbBaddm6n53rpbziHIgHNbj4EcLkYvgTt6WRDeN0RjCGPv3MpQRSkGsicIQmxRCp55JTRluOEt3PyQgoWywoPPbfjO8t0I5C7PFneScrGjSEbxbmLLRsMqdHIJ7gjPd4O9nVdtfPLzmxpAhkzUzi7aUzmLvwfa7bJynVD9RDQSTYbKWVaQfbQbRVTpVi3dLixJ8MjUzxxCvQki3lZcF2qAvELoP5x/omiv4hNV0BV6LKiyFLOo+p7Wu+RCXMWKjW58ej7Q2zT8RSy2tsWQt4Et7jEz3N1UjknVhjSo6FKxQRPAYGowqbLv+mPzyzbm0Bw74Ca0bUJ7DHu815XBWfRYkmftOfu/NWk2kyHyXfGno07qna/AyCmZHbnXsVd1zDn5+buWQqTmOKYIohxrlDDI98GCs9lS4tc0oVnRxJAAnKHhllwOQztXLMUwBkM0wXb1GI9XJQAb+GOhJSW4JnxUi5xoraBqvchp4/t3f1Fi9v+RY6hMqKrxY8cadIkWTtEKLFMNTy2J53yq72PvaT4h3aXH1Nb27t4H/3PYADvHy2eGrCcw3ClY9CXZc+5jw5m9eodCUU2eyQeVNLsl7aLCNVTYLXblc94Xv9d+D2haCsKTt1sgs+BuQKuy6MhICv6HHNQijtYanlnrCONsxDXFDymZoVD0+Tx0/h7gsHNVmnMjNluW3FYc8io3VdnLZwaR9cwjQJdROC6ksWMtrkdHA3WuwlP/vqnNro3hx69gsvLzzP5DnL4MPJVs0kxhgnXzfQY6E1q9J9RptdzPCp/kLSLJQerFfqqWa0zrgynEqC5RXxnQEXrwgo3Awz5ob38/JypqOwnxkHSsez7am/Ph6MiK6nB+yaHIjIo6QoLsdlTp23kAyDFJ020XiFUmXlse7QSllm0gQsxF5j/suU+gPaiAu5Hca81X9yJ/KSoMHLhbhERniFD2Ndw0nVWIGfYwAsrF4aRF7HRhwL0ULvscUzQOfY1k7Gh3niPGBUcZW/yV5bIcZmvXiUGUJbeZSWBrKeXlaMtCgHmbqEONpzrJVcYBGUhbDBSQWSvFTVFI6XQ21qavFXpTn8IwWUWr0xJC6ORJ7tJ1rsynzh/I2atEA01RepFppVFZCo+olFLOksEJriEcMkeJi7tVgp5aGhU91RMrOwRrakzj2F91y6eWp84WNPf9981VGnJf784aqiP2Vq0zgjr4bmWhpM7wxV0JA6A3Mk70Fy5rRvaHrNdLa20O4eitLkInGQscyJRPFIRnIYvX5D//J/5yIlX7bsxCi6iLS36nXgna6BKAIgTx2CuaiB+1MV9/pbEq6FhSS+zJXTuEqCe7X2te2PeEc5IiJMQ8WE13OR/hc+qme473X+zHbDwlrNZkMRIVAUVQmC5xgBwtz1rAOWSiWiSgjGfHpGciO6PMGI4os0Kf1Gq1SaZ8PN0byJUz7Km+ryMi7l2E9yAhLdroLj3upRwrgwY1/j0vHg1WgBBrtIKjyYhkj4AVQO241s+GTW7w/pqYKPO7nCPI2DIpuD4qifptUIyBv9UYfeYDeTlIpexGhteyVKquHg5p05iPW4gE3s7VkNGKRGkfvC/mO31uNydd844WNNWRmcrYF/mBWJZNI/oqf8768hUVb4yFw8jQYWEoLeFr2DoEDdgiqC4dVafCk6X2WaVVqPtbUuGIaCWkcI1TQB1mDzcKpsMiTpgDtU2YOu38Dt+uHg5m8wYVxLYEIOAO+kGpzwY0zY/l4uJAjqUKg70AGPw4hbhCytB2Jc9suZAhcj3ajzz778ryPNAFACTnDUOUecvE1LCGBVZNW91KF8fZMee3Y5SVwI/pbBVYSwv1KbUZbPdQeH7Q4Kc0tqeLJyB9LIg7nT8IK7Fskm1vCU7V2l8ucr4qJo5OlTGfH3Ofxm2GzBxnmLYMH/7uBR7LDs2ITa4vCzgkAo7bHzKDd+v86g0KUGShvBECj9cJmdRUIqOn7bZA9Ej2cpmkgiW15MSC1bcKyGOe7cSqNQaKyC0OkyipkXIGRTSy4SUHXf3EhHm1H3yggQXriF2ujDcTSeX/7Uxx1nnNC7p3Y8ILYeT7ovrkDOEQ6ZCctNbDL4uhWXxwrylM7Jd11vaHnz7jISpEQqzAY/CAAoLQ1hEU9JkONwKdfecX5JyKgVi3gpwf+UXfUItCKBr9AkMZYx+Ef3831hsaWiDjnUyrD2/PYBe80g3KMHjKdG2er/t5DwK2nIqRaSOfwlmT5+CLpFCrLqECO9dMzTvRJ61FtSAU4+vf21zdcLP7xvhm4Fp9aJZbGUfR1kENFBTdtS2mP14c2nGkdUDVWsq8LcpfEJxz1EJ5tsaTfngML65Y8AoGcqxkxY3YaLf6mN4OQiyGNr39L5jzpdI17YJTgTzqGv7/4Zhp7V0jZorfuXfbIsX0wQ0QR1kuOFEnjFWp4LEGwqVTpZImVX8tk/NsPtuUyECNANq0yPaaNczi6ACV77rTiPY7jCAUYC+nDadxyDlSBASdTqV6ko+iVa2dT//UpI3rg+/ThrtgiUCS4O5W+PCPqZDpquU8ns55P6aDhA7YrB0tfx5AlOX8XxYhQkRyPFrlL4oOgY5UVa2CkU5jnYOSvWkAeW+EAPphFeFDnqRcO33jBTXC93iPfnV2/GKeNyJAlzz8bA0wgajAhWLefJAcZkyLh9XqQyvv9Tpk9A7SWjRf2+boUwL5dc3Vv4/HTQk6PvDy7j8q4vvSV2oss5bxNgcoXK2pLR60lEgoRttdjDC7xURHeKKc/nd7UuLZ3WSgrZkIWi5XakVenABPbfXhuPAMjXoXtN08+5FDTdnmJZMPqlAR9ZcOeKbY/mSorn36e+yLH3iVAWLHJdGColCyOjuZNMS24qUJcj7LQE0gzD8HkllHCpWtQfipx/QrWuQtLsAUK2RPM9aA8+IrTL3NJvuZcAdsRKevQ4PlujmpbI/H7RZxERlJvbnzQfgOtNoFo7sK5r6rZUXkd1WSQrw2933F3sTTaXsWuTQMvjANJfjTGKEUUrMJRFvz+vq73DNgdtfLwU+V8qA8K8i1XrUochkkxd/WdVyU8EqHnwnL7JX9gR5yZOwh28DatBQVTMyC8KBpNpuCjWZDQu65LWPVHP+UQnvE9pF7Nk7xwMMgavin1uWOdoOusOUQklbuk5xbR7d5XntpVGTJt3OgLdI4IQiF3XNxdQzYvU1y6tENEmXzzmyAySTcJj+xAvB5qPIk4KU3ZBwfL7nH8ONweZi+0FTdCxBrR5zsmrTDywHBHt1EB/LepRMUl+A1mGYiUzh2SQKdH25VttGMu9t6GcCEat2o2zZzOV4UocMZR+Oa2k3Tqlvbk/+OZSMt0GQrIdeb9xmgsKaq9vrkKMqK10xSGbhEWOrck3wCX43MUArMUquwp4K3HE+RhsZ4jkPsgGLBbPIdOonBLHVrOLgDaq+d5CCjdy38MXE+KulJ4U2PoOt4iatCZof2hBGWjLnlolPqDivRmbNmka1fxubg0oJlwFWZtYNP7qVFnPx9UEnf2Qt1GvSxkqXhzhFvJyETelyleDY+sPQVlOrRcr0ed8J0bj0s6/4WU+1LRJ3/9/fUoJ34IsnHABAGwUR7nLyA8MUqUXzQrrd0bYAj/YCaiH1NyX3F7kj+xn4cGs1b+OmoMtyzlwefAfJ8/rx0Jisel91tn3tE7STKxUVNa4fh+HwLQZ3tXjGBZNxfus06+zrb7Qpa6VE9EBOykW1bSKACNGllaOQuLC6fMmcWseKc0IqWFYeFlTmTmK/E8/5eJaJQGf15T4BuSxIrERD+UQEU6Q4mgYbZ6TMHz2IbQiGi8v5LE1XH53TMTxbSDQQlWIJAazQmo/lx3O7H6BL92wtIglp5Slrc3kafC4IUdBdVoqGKeoOzn/UV3czujgYi6uGIlhg4xi7aH2oQpZw2Hh7RREQU3CTb96fw8bSZBPRZcAx8pYY8wikahyQRNKZvhrkhas7lIBFiR16u9OvurQm1q5k+e9D38XPXsRr7C3p7MS3lumGn+JC2JyoUS70CJfA+O+DkBf3d+Mm8ur56Na2V6OE69d6BTMXBERpv4ehWg0FT9FDTqh4j8kIszLM0WoInn+N10J3tehFUTSaRzLDtM/ihJPWXucQP36iBJsEeezJcQm+vqVceXO97x9iynAjObAJ/nY65zN528hPk+3WKQncgM2JXxGEwr2SPynyV4X38lxTfVGKP7QffKEov0za9OUAA8i7xrOgQ3+326P/Ot2XJ+yIjmkTv75XxJf3p/MOlhSgKRPjUWF4CWIknCRJ1Rd1lyUwHowaybGXijP5y9o7YVO3FDnFs79ntNFwxLGkObPuBZtuvxB2DzsB3yWtzuTtYVtiVnkWVzVbT5+22SgfU+fGf74eAWI1RqkczcIbyqznD/S13pkjfb06V7Nn8ycF40Aldf+J8RyFFt0IC7QfmiEJARIR39woZw7tRjHoxUnWEf90d4kgzUiL13DodUpk8Jj2SYey8DflCOiipDzm1Wbptc7fxF8RW/Ti5kQ5oKDescvWAabJg8DdzuLCBBLAVLb8w1jT+IAU70o2tdtRKT+JW7zoUBfuBjSAgC7g4Va5QeD/PRuirgRBryLazUjlXWx7hs/RAP0kOjiHnYiQX4aszy8cH8bC+MRXm21WjWYEgMq3zBTag6xR7Kw5+P+GZjsnOpAPjoMoF8uqyLPvNm7isgF0N2Dw/ewxjD6G0O0Fy+kh28K264VixqsNnHGMoeLPthpXCUwFBKfEeqzoZk6DfG9uzfK4eIEXjL3y/E7KfZRn7Y9835NaZbTRrit8AV/Ar/91rv8w0Mfr6NR+V0yhvX+zk+UXIkKkCRIe724bLbDCekQxP7l2+VekU44wqus2hrwrDjQCLHz9LXhahfyqngU9Aa0c/t4eKfuZPmIYmtTn+7F5NhW6q7C8Tns7dpGLxy7Xh5Ofdxwws4TNpEMqZpwyCdC6mktPVpvxZ/Z+AsyBFIAbnL6rBnWVu5WQ9VhBSWsP4F0pgeNuoIepvL7Onx/djOkZBDVWsYvpPQGJAvlnJnZw2FmFRyENzgmQosZaqLqS4Fzo4roaFSlz+ZsCl6aoC/TltyYKXz3D5nw1jb80zDeioOjH4Byj+5pVHwVOs98U+55Nsh6iHbVbrkAlOC9OHkrJepBxGo3b9+TlT+DVhLZBogWCG8qQgb7tbXIE3dXAqAw7o6BQhDF9J8BQTXH3omIJbx5cUaTNXp9dW0+1lPYaettaVOx4WALUGXxf1iM0+PvdF37kyS3mSSs+DR0GIG+ewhd7qUS6+uBPE0qOVaa4KL+k6pqcu56+cmxMwQwIQdQ231FlTQ95ZVV7uZHad6rU2Yh+U+ZMfwKtONaJix9MAlfsSBQS19VGwLAhKhjcpcAghq3ctI9ZqcrCOK8PB+gKOUoUMpIxhC/JxC2LThYr4T/YdH323ngtjrXTDArOSsEiV8oNf7wuz00GcNq7O2jDhvlxJo82h7P/feKgo0u+8IvfqhI48XP13pMgI4DPk16idkrpUWNf67grLmWZV374ySTpIXEvQ/wo7finkSCu/uqM/MdxS14Gob1qnimkHJnX/hRbb7SpQOVklXtsKRMBpUh5CR58LJBCUvXfJGdkZzlNWVkJyZ7LZPj1cx5RcNY1qglAXQ8RB4D+P4YPy+53F69gb09/3NGh1LHa54PmWmoKY1Awy4XcxeZmy8DMNFOJT871pJ+Wmj/6Vm/YmYx8T/Z4UgUdc1b2A7aJGjcFmtADJIXDGBmdERSycNPnuFA8MEXsiMoxTXEbkKB4Zmp73kklSAMJtaArgDQy8LZRmR814aDRwhgSkV4n0J+0yldNPiFRhcfQlxjxMZrfj4lts1l4kvR4D1qzMEN3NV6qY+q9LINLXZq2f/uYLWa2I/n7eL5Fq1ShTsU9B/h/EaOjb/ZHoUgqH/JLshkecLKNZx4IOiXqiqtVImpvIiWtxqkOeD2irV6Tz5rTBRyUVw3zn4Zb+4oTyJLlz97K/ucitvSR757fytfdgqgw8IiF5xm1M2raKvN2DfTTXEkfv1SuxtJ58iDilqLfU/qGD19agee5PssKU+REskWotgqWg5R28eUaR26ZoI+jX01cyxOQfTAm+YkkcGvq4pRob9psjlr3V3riYE/bqTvmq2xMPh0hQc0nddZ1Luh3BesFlgwto5JnmBIc/wNulI+9g2BwxhLU7kLYCCEq0UCwXWb4LPQbWQrsqwbjMerOznlK/eeqRTqWaLycp4SP3Osc70r3J0+XXssXesdadrvL3LhO+EpHCHnbBa1JtrOIV8IFY+VKrXnNCBPjLJ5z7dA6b10GcpdAUhxd6Ca7fGj2NrEtLqqZ4zyeZED5fcyl8ej+6rcYHuZRH/vY5c1AEsoEjOM3o0uZfEtCwyqJyBbN3+q9eV1GIZGx7vLszGD9y6u3w0+b71jocAM/K1amh0+sgiG4VEraON4TwAr5/nWbFDmDJ9AP0GDlvaxdV0JtPCTHW3QCi4VxhXznxnZrKCn+Iliv4qIy1N765TnvzmU/2kW97Dapn8zSLSKhlSqX1GmKOk023zngqV1NYAhJfuf3YMPx/OVfMPr+dkdmNDo/cuw8fCbykIp6hcBp2YDbfTtP4yn2DBxg5GsqZmp1nPEop6j7byXUGDktUvC1nQHmqStLEz7NgidpnLBmRpyjoWoiLNs7Xdx50rCsTG7s9spwAm93sI2AscLW8XzK9QlfGxOh+Ici4HLzgEHVi7ND3SAu2wp6fCYyBrMdhXUj8B1rhs783dZl84uacU69A5OAEDeJhatSV77sIpjFL8I9rc0u0VlT+zYkK7RTkA+L528yAsM/URrVwHF4+uAd9+rGeNIrmso1Oduz8yqonjQfqRzdw15077zfiZq24ATcq7dZe4P7o0rozGZ4pFistgFeNkkP+o8mfzx1quAAZg48wS340ua8Fi4zJ6JMANQPtB2Vo7nYQfyjMmc/wUbCmYgD1DJux5r2Y0WXj2VPyfAGmhS/EcUJV4xnDLx3alBULHY9mYDabtl/BHliraw5qLfKRifZIWURo+TdS4D/yoXxxCI2kTIC+r3uUjZujCm05BDfJQGmlFzvjkSAZvcFmxsqR9I9yUeL+DVWJNomk0zFX7NL8fAw2g9TfbyxR4XViGn5FTONL8htkQ1Bcid+UNJpttOFdotmYhoGWElLJcBj/nvF/8aLNy00RH3hkuqU8lDVVWxJRk06OLQEa3Epjt23OcDlr55vU5ifbrpiAb5tChtQD+pYZ0J0Md927269RKiQYYUn2uyozMwG5IjuQmANGAp6akVhOhC5LnHGKocLmFkC3RGRaePWC0febpbT+2MrSwGhi6gN3bgYRkIBH9Icaq5LC0AnMXDqwiGY4tvdy3yS9iojvGcytlZbtSIZPYWLTWTP7JTOLtMGLNB1e6s2hjZ6L8xjOBKrlTv+EBLAqHrCFza500Nz8dPYivE/xOUZeD1OE0qC9xN8AanazHeuCcfBCVGCu8dRB+8qLEcDBPDnHucE3bnF4fbDx3NQZ2V9N2C4q3Tm+cz5DBRhLfLOIAA9EUy1fU30L9cMeVXd38kE6rHcM0soBYSAJDpzXnC//wqPuSliZm3a58bnEO9riSgkdfK2G/c0a4eBWPaXJjd0ZLdHrHBGx1KHMeDjGKPwUPUcDYez286NQzUihWJGw4qHnLHkwRRGK8hYbmb220pzPIfstrGETxxTaiGqVuT7HYThXdqeuf/Ic6nmS4URwSMJXtz1z3+pX5qzZ1vbQ3kp8f7tB3jJCDmQkqRetnZwNE+BC0nK8+mKssMoFBwImBJV3U71lmoLyKAtXqSoPxTgUSN+ENNZceaEpp51xzAQmt6CQUU2WL7BZhjLrx3H8Ek8zlvNek44k55YE82Ym8MsgkWl5VSlp4XDFR2ey9swUb7CZ2Bx53P9QLNM28OLRUl63iQy2KY+ZFg+ukig12+bpqZ9fbkuC2tPJKZJplnZvM+8IPThCK3vHv24PvczCbq1PGuCVzdwa2LmYnySKpzv5tOjSuPiqCAazFgHr31GrXIhoLlJGzx7RuqvBv4JS1p/IaGls2AGqVLjJ+ZlG15oB99/F0GWhBWbyrBRljtQxAex/ibU9rVA0XjsaZYO4gv+uyY+nxBbH6hjcN8tQSsUWv3K4/Ba1YTYgkSAezL0tsaDq2RRRCqQfu4zn3nuS35Gt5PsG1XC0Tf3uAj3LjF6ndhuIWsxPOkXjrz3hSlX7DruCQrtAxLyi/bAATa/QfgQerXY3v6qmssub99hjF2ak26a6tl3Ldr1GO3b711N6CG+1I81sxnftVYsbk21pVMJWcbQxswUVhe5aYedfFB8v86VSbGe0KbD9obAVS6bY9xTK3xq5GOJ+j92uGi4jESH07xDmbKEn8HMV63G9VWXr9Z8QP0Z1iZPHw0vCVUxj/JVOSdRz7nJ2YA7E5RdRg0SWEf/094OLCjdpiKYN3UnhldBexf3x5L8iJRqMlWTCar8m1OIoHCHtKsnDfRcTt4qj4fOTFmnujDjuioG5LGoWkMBCHxsfxyvJoxmXOyWQzHYnZzuxtvkDWKAYfw3j8MHIuhLJgTek/oSJ/ICygE2giaHsDda5fOKaqf3B6ngpfx0rVyBBIJhGefSY+OKOHWObV5wgui9B7exmJkpSO+FaaQCE5bKj8hmmahSKU+1+tmSF1zKksz5417mPZCLtQWydWGUzmXkYqlxSfOJwlkxvA9hvcwxpf8hg++aFPwAzQxwGP+TXV/dk4S365xhdSalH7E/0sZqY4xYDHnc4YN9Fj+RK1+k/Zs0hlvTwlYI0aNHEfn4Mo6tO0ToF+u4NHDhT6hJixK5aH1DK0HCglRW883YmtYW0hQcCFjQvEOYCfyQCvV79hy+k01Erim79an8IoKZWAVcjP/YwFkOOclCPrPqCa05FD9EclZti2/VXEtDEXpm+IF+DZ9nVGE3rXI9hwejXyFVnttR8bBcKfsDF0x0EOTYMxGf7ig1ZyZAiJNHQ3kZyXhFbacAD9dnsAeFOKIItW4OkOpBGLtt/BmtZLDixbPZxgYBB1qY/JqWSx0JOiLD3KrZedl9Rf4QfBlnQFxadmn4Ovz8Dj0UIFvuX+v3XGtw9VwgDrTsBFasvD/gTcJY1lfWkV3MKj4GJO0/aXW9viCHdPxXDQCmGf3VSqKF0GOQQ1oi5gdDzDUDFJKgFz9xULe0qqtO/nQnYzdetYudJrF9Ik0LSdTV1paWDSs+tA4krsJAV6y6q4v/yogR7NcTaYOUgHpT5dRC12/P1XGuRs5eO5lXsW/fdZB8k9MlkZQTr/WHV2YPZgsrCixvec58Fx81M6aMCUVirhQqHD7aeqKPwYW/IR++ixaLLwBHVlraW0kjAnpL2MTKINudjBAtwHz9xxJZ4gPgztNEim/KZuD6fqeMjmexSGJzNPv+Q7kdUPPPrR8Bn82Ug39i6yHnE30ptu5zjf+QgTBGzzAxhlnguA6KlZ2Kmc2EdvKUxJYn1r3S7hOsdts6vcLPjHnfAg3L5nbfwOVlpuR8PqenSlnUeNC/qveNq5g73evmjdYxnog4qWvMSeZpFTtkgEwJgZ2/xFlvOVLNV6WkqORx7cMwmTtgLgecPld9ed90kATIi4+o/pL5rlyArycj1vv0cw2QFbngx9mXnTPovxCpGYQS24e9Sp6NJmryJBY3dpg0+ixXtV/UKQMWR891g1FWvYhoP3PtQfz6ZUyww3IOcvGObsgQ6fYzbP8d8yV2cwseYmdpF5VDF9NNCo2k6qDjxSZqRVY/iVYdIjeehKhV++bHlXLrc1qf9KzrNFqZYDKwbMCSqcyeFf8CIbZieLHh4/7GOGwCAsJtnmBO6S5ZsJnOs3Qrn0cVDV2skMUh55ozFczwgpaALY2AGtUBNlDV6MzICYduBTJ94fMTaty4Df4iVPrRxmHFJZgTup1/f8QGrrjxgoMjXbQ8pO1x7cF2Iw1WfoSPdLavPWBAb3Fb+u5QbRgPbxZc+NLl5Y21yHcStEvZsxIL6tJIbWz29RURPGqLFR48u7JzwQ8gemgS9dPwmrttMddt6UzfE5evwDwPYJffss0Sc4OuXm5Yg4JOGgUnEuZw75LYKPKPo2tMADgVckQHgyAENWdLWC23dojQxayPDBCqV/F94szaFQGH2WcJH05nC29NWvnx9ZVYXJmJ8LD+NqU9YBCE/Fxw8ElX0wwthauIt2i1T8wGCHhiQ449EduN30OV6B8ZeIWmRQm3229RPX5L3lFHu6Qljfb9cVyyjUIv+KCxgV2M70hZjM1F5AiH6XKm+gMqPXqJz/dexw3XFMnJaGGrcpm56njPEa+ukYz0+j015Bxlnwtb766sRyxsx0MsAQzN1yqL5SkND8Ey/fmVW060fcEvWz2+w0v5JkRzv1O1Ug541EUvwuqtVSoXNYb9A1Llf/t8pNu0KXUZlKNYc6TiSBrEjtZsVwb1PndTsuxudbvtAyNBlXmTho7XmL3MDcga0/SvdTImm9NpfBd7OKO+GU25HAUkT0pdwtcvAKN0v9ioLIg2Se/J0Xm0tUgZxtN2l0xPCqicZIbfNeEDcEony1Xj0TARFjZXM3goBTKKYCt3biKHZrs30vs7vNIZr8NOZlS4VMxaSf5SCzZZBVkFGz5ciFgll6TK0KpT2q8zg7iHzZ1HBBYJ0WggzcHkfTBV3wBfXgFESHw2Is7IDaHzsMvaSp0XMY8tQyKq9Uc5zfLwCjgyHW671/eaJ+xQzquOSityt1BcuigTelegdmw7qEQ0e8vdLIfB2P+Fi8KpG0Eizx5G2lzisJaG7iC0I8YlwdiUZXYjZDoZ0QtF5WfPDX1yQ967HS+/G2msutrHkVSISbPZqJ+Y2GrGrz1N6Le+hEDeVrPh5ALh1IJMnDZoJkhCmubLpusLtDozXGT4Hg3yXR6N110HIh3R//n0xkpwkhGzYL+WAPzSQ1DnjzRPM1b5eljEcHWcaZ1dIwGi05uTiIcBuV7vVbVwRtdhA3Utvz1d169YdSgsTddUe1xBWkaxDDtmmYZHraywif4nMbPEZWCbNLrpeVNoZTM5WX9WnaeoXVelmTcy9WBILB9giYTJXpeoOQklnrK1Umj8iqIt0Qr/MStJ6TBOUYbC3ynDf7B4lcJObbJwE0uNA3d5fVz1CgkM8XFWlEqXcqe7Txe2mf0zX4WHQjhHSfqMtbKdEpNfGKRxZem0tFdPVW1/W5CUvb5yGN9tPzV/Onb41kvfC/NujyTaS7f59kXA4muwsZlEi18RFaktq6+5/Kl6ks3wZceNqH6NLJHcmCyJXjcqF2/uISCCPRtSwIWnVvwHn0kqKAdr0RphhQbyHbW3/H33230Nvcp+0V5qAEi+ZwRKNy2F8hWalnpAKFy1pLFy7vT7SYRjqgBDgnQtwcAyts9NUVt9zS0U74YwcuzRK9c2Fcq29CTeqWEBG2x6nEmealQFsR/83cyamqwoImD7trtFNWFSvSfrjn7c6FDa7qsbQ+dKeHLUaB+RWhpsMrsjsY6xag6y5Ke/O41+X4/0ogNhQ5XndT6tSAgksfhhYZDVUeBL5/X5NbSsH0Y85Tos9n4MN3YElvpMQUbp7HAGyrRL3XIMjSMVYFeGxP6aKM7Eax23a0QmG5eCqit7Bjx64zNHcMeLRZ+XxSKtz7wkVbnduy9W3t0HU4vXoxVKQ/hYU7Kph89xnh96uJLGpklT8ldrZpKlftJA8dUbTSZVwwCJM73jYOGK6VdpDykDYT7KNM/DFi2e1YyEMAPZfZ2xUxxf4G/1ksIR6WgFfdL7+sb2PZaIA+aIoLgXjTP16SOERHXo/UEoSRZd4zpebvXu3wWRA3ngvhoxohmHW0MFcc4aCkHtCjuvBDL8k7OH2pUrv8KfBfXMF5fKTu71c3oJIOmsBO1ZyAByUS1+eZ8rKOXzcW0okm6vLzSAzCmWNXp2t87Il7R56/ppxulymCsKCArXqn+w03GbuD5oT5h21naoCkSuy18oEj5l4+0Yt1tzCLDPHsujR5LtYFF1JETvUCJnbp2tXxDAsWBpxR4OkelDKJjq4BQz/KHLfMZZM5RNx+x4eCniKnvDlS+kaMC9lA24i8NO2dOBLFguMOHWwH+na5tYQ/QzP2qFCalMw22M6wBpNBZu34phQBSbZM4bIrbNM2fLG3mRXPSG1LADbvclAc3HKTq17DexGWfecROkeJfYmdbGK2V4dvcEmH6uQ/rYtkgNKXJJweV5a99kH6z35Yy71qb/0srfvTzlpFweT7NLyu5+UgFg8bM1ZKbNIWXGrcnzKuyvoRfKOf2KIupB8ZQ2xZsq4FE91C5xki2rD5pJMKS9rysABwOQoJZpcV0L03NmsS5uLqxL0avx2php23i2WDgqGjdItfZZgP+ldjdMsZvuqu8RWn/LWKHZ/x7kWRtAwl1isOEDa4FlIaQFc0TbQO7ofA3aCE4ddj4l7sq9o0HwL9RYdNWDtmIS+UrlGkG7sEXmYGvw0FjLzUS7412v3+qfD5EruD7HJnYFX63a88ty7l1OFhLeR4KgAKPvp4mL2Z2XOlZybcGRjMgmmxwBEk3zoI84Jy5tN99YP4NNQHQk8Wjd94JPw/T01PnUA3uOHghxXrcjTraKdlNVnmI/0rgoxk2YuAgNrgGaRCo4jqKzJmIIBdC/04io8C5FxukNngvK1U5PrD9esygkXyjQw3vsX6KiE2eaOi0Ctke0atw/ab2YBAk/f2U23WQjN6Z28N8yhyK8BNwwzZzPxdVMRSm/Qe+IRohLUuMndkyRHQOZ+x792qcXogIA+LjzJ3jpKijs/0MGL15cZhcm368Ofr6K7GQlkp8Pgp+1lUUJPxp6vvQ53JnBRp4yPiU1V20BiSMUV6t3w05sByqn9uf7Oi/U11nXQEd4TC1XUIr8gMpCHYyyDZaPWOqx9xoqtHDcGUbgp+iWEgzuDMrNmSYMrBEXW3bjOH6ujdNWUnJcC7Z+6Pjn3g+mZ5PKuQu3cPdvuZzbNN9Fs268o4qjwm69PdoxstJO0HoIKPl7fjWGGo/tfVdTIzRERcS6zx+QwjOrm9kEVXF2l8UgWOvr3soMSHlFMczU4A6IFw7em4DpeAoKEVy2IeiH5Un8NsbsQRxGqGy8eytINxYfrCnNhK1wW5CVW+9lrrwah3deA7wGadYgUPM7Bdia1QLReOjm4mKUDmEO1GapTsn2yixy21Drh+0V38/xFLxBmcRf2Ud1mbZR7JZ0qL0Q6geAGrDkkr4dCea2Xu4JOzocFdHedyLlpB7nnQlLtAKSr6ZkrUr+CkyXfoB0nxZ4vPXVrgtc9jbHqG3iuNVcL2r0kiBnX0A8PC9Wc0REwnLQHV8wEpux4UnlrBg6qTucOvYlAvdvprp8Kdgu/0/dL2iyH2XOSihQIsTQkSHBS3Aqswg5IEUFhFhdukFrv7VnPNcTc5YnewGtJuBQkhmKLqDyIJtyAV2sxEMOCWPfSaIQAsdmBc3Hr1tKuDJ1i7OYIUz3ZyId/Um7rDdq4jzakuoXtaVvJDSUOeQzY5CtA6EU9xWFZtdEAu5DwmOGtqXpyenh5gUm6JpPQCvd4YMVEipswiT5QUsMONyZaZmyg4fQJjmr7DE/QComGRpKj15DR6VcxR8idyLO5vnBgIcNFIemWwYcnKvJhq61S/YNOJXrbUY9/ppj6v2bMKjSkT0Owj12QXCh6yr7NTlOTY5oZTnpPufW9Xvm8UGgdUnxalxxpH9px37JgRV3NKAdhEEz5m08060cjUfesAL9yj1hbojGv5T5TWzVZzL3Xkll4TZXhYbAZbWKSKOyQ3T6FpUCXry/SyFM/FDIY0apn9mJ/6GM0kh7Do6q4ZufBKgG6zLSxoS5u7HVvBBtC+pM5tQ22DccZMtypojxtzLlZ3LpbZpboGUFHO+FB+hsxwO7cSHxR2So82TfKfhLGNDMpSxEL1aCuSatJLKB6FdjYrxojldepeLcFZHzRDQah4OS/15CCdzPTnGI22dQNNIFx+EAfGN7SAHtL6wD/73MNZFCDgnwa3Rt+QTp8yz8h6EXJ30MmAL+Es7jkaXxKzYtJ5ttRWMggmi0JL5G3lbmU5A0TezkJF/Gq3b5+ked5khEl+jp8ELd+opD8jLKNH8ia1QxgMg+c2LOqE8QW4T/E2Me4M7dLmaw70qMnEsx76zW4zYOgFzO9852qwJfLCheMqv0ABc4ZzooMgISe8orIjc7BOcKaQOGQBXIBM1tJqQKhN8/8cyM6JH916/0l2GyjxWJGn38NHUp78CpX0ub9IytiKLRv1/I8xvpthZ8L/bK+RO+1EJ8jGGBb6J+QH7WE3+mSyN+3pOE8Q9SMkfzTIja7q46RqFrvyl4+USss4Jr47/gZG1GKtCX5Szch4ooSNdmjXk2SdSiiueBKHoBfBCd7Wumd8ZmrfFI7SKyb1MgdvkoNjM8dyB0Stc5W/M1Gmw04tcYf1q3fmiJKV/MotkOD6erGOlSFhWgZ9CRb8Oh5/bAbVGVDBNlGjmhRF7pYB5BeV2hu2mJMmbIXdFXpkKYmwFDp2zdT0vP1H9Ut07x0Abu3DfDw0WWA7lQrqs8W9QSvMqWfs6FlXpHL3AkG8RLIVwbunmEhuUgxPSTZPn1TE6oQiEYYz0W3GcyBlqTBnRKNsg7zt3leggN7uFNm83iAWj54TnWvLk5hiiSxnTU9TW7pnQ6uvFv+BjWzI7zVWYhaByR+8af0LGVuJe4y/MgGeQLVtatvolKzzOVQ5+OUmmIcZHsZKh6fXIakhp4DfHVYgoYTFmf9GT0VM5DEp6G0iLvVmJZQIhpNWeLr5VLgyWK15SEMo3N4BH/ve60Sfv52nIiJZfNHlzNpReWGtsMGODyyfRj3IY08pxh/zwIS+x0GmtZFATW7e5NHvZ5ci60qAHMUbUgyBucFa7gvdbQgmnLHwG9ojSBxm73qn9zEmwvFK8lO6aEnyNjsGc9nvEpxe0AUT4ycQ/ihFOuZudZieaDMGmER5J4iJW2mAjcHenezOU7aQQ77itJfIYP22RANmUAJ4r4ynQfCXWA3fwsGR2c5V4jjlxuaV2h5pF6hQAoR8lWAv1TlxSD84mwbkSoJ0Fp7zn+z5MkmhPZ6vDt4EXpOVixD8zDgX2CYehgVCjb2D6hop+LfZjhpkRpvSptw7ZsVOJu27M42Aw7AEdsOPQ43i0cZz4aacKhHJNKs5Kt3YubWxqFGWCKjXTrxdzYuAVGVARbVYhRavN5CTl4m7qXrSNN21/EeqpPVEpP/LjwM511QPAsXiYXazuurpSR1gU5Se8TDmlvyat6xrNK4ljwu29jinn0D1SOw+3jkYmU6j3AZRXrtu+dTvsGi/x+Y6DIhB4YBKKQesX3CvpD2mOOJRVu1dkfL9Kj2GrS1m7188yUe9Zia73mJMyodJGT7rfnQmwgym4lMolHMadCzhhtXBgSkptVQ4U9/VJS4uT447xfx1l5Jb2qAgbJhzgDxISqKGEOon5HG+715KDo3XZ2lL3e4R52WTRS2soR2wVFf/FOzb2InDyt1Hq5y6FoWt60ZMs+qPE6uZhX65dBN2siaJaO2KY1gqLTdfhIK9s1iH6z6h0TJ/N2pApjM7UR+awr9gL2sVojpF8e2iD/T8RIeSzL4ohCt8A6k7xh+uHi0E+BnI8efK09owjBhHfGG+Fp9tAL63Ns+iHjln0ML0PYvOz6rp5VuI9uyBj82FqaptMAMxUlfpMjNWQJP5hP0M8KCX4RICFMj/iZ9KNPsgrUaBkoYsbKS2UygfGGVBis4JuUefZCBJRrGjQPmmD8wpcBU5nDo6H74U9dlwIBlAc0Uy8nAs2jyTjG6go5XKM5o2mR/YiM6VlMyroRiJCKQNRdh+BIh0bR+9aEHbazZ8+kspsVs8hFNjWr0V+uCcLFKD9xODkfcyE1HA+oNvdsDjJzkL1brGu0gm2/g1DEWXjKT5D4a4U8sSPbvLxX8m2fPQCUbQvnad32WfgcYIhZbVc10U5hKvNbqL54YOt5utqqNP1ovGPZWgy1Og65AvdWG7wHRv9tP1uvq9taC/ZVbQEgh/vJ5ISohhQwmehETi1ccJPKfuO8pMG7lDPWM0+1DqIQ9PpYdzkGq2sPy6NTipevzXE79L4bHxZvaeKOehM8LBeQrm1hiDpGS4mb/VkfZRKL3Cs/ZOnHFrVJ7/v7wZgc2P3qdmjqEde77JXHDiQiBFLfWl+O/og0E8l23tEXM7DDrpXKathl7Wr+2MLplwcM384ryFbEGbEFrHkiUKGbz/AWgG2dPdEoK6fyuPK95m+nzYKLtdJZRjtN4NNIaanBSSA2GkQAoQlwh+EZu3z06bFIwSTsacN7tJIumrvtDfkzCqFewXaGCRbyzIhaeHFIm3J+UHUDKRDHT+3F3dOQ82hCA7mYW36uL+qHDWumQNlYr2A6Ma9OXvL0rhhk0OLNvNwHg4zcM8npeASmFK+LOUYjgjOrDDZzoQi48UVXZYkW+qu+0FvuX9yzHxbl2QvO7qzULG8oYY85qdKlRN0WIkZFwzOS2YaPHq9DJuH/lnKWsIUyT/FAZBWB/+XmirlJouL5Czb6HIw8dT0r/RcByqiL/R4hZeFmzeIZ5//JQ8RZ1d2/g+2s/q6FWsXs5vLW/ieB8GeBF1P1SanSeWWrTvKF2z9SHRklbomOex/o2wvKn8+iYLppeCHPisLZaK41v1eGBrbdzbH0UAmbBznQ9Ih+TXyWP/5UWAjOygJBzzbmLCEG+SjWGzLAstDDSmYrepSNea6X/9VCL/BDFIn/uGps6apl1N3MDvHqcogYkoSqY/tUjm5e1HSdPc5ccLGvwgXz7/stRnPnsEigZv6P+dNxfIPwT8/dh//Rpds5e0cPRpPfLNOYUQ5TXe4DafCIR9FFe8YL3ILr2J/gAF/CdcLmgDvKjSllSjKrr12LoDvarSBQEKY2oVV2NZ5em9/K+yX5m96DD0y04msuYdkCUolM6Nsbf7BbEJ9kWyAECaSz5+qkhN3Ik8F2ApTcDiZdTGPQj8WdIjXr32i5Ou278PHTP/b0LtY7YbeHs+PISqOtSxMQ0ybhf41WxRyN5Nk+jdxymWJGOD1PSKOYcYZ08AqfHzFViF/eCqRqmdiZQuWzClUEFmZSmqNSn6aRMqrxk6yA5Ob7hfP1EPcjINvJnFzRYV7qDSM2QBCJ4tdUxf1/g/HNQS/2TNKmbBkAP1F0XUdXButN+cVY56HcDJjf8sqgUGYDnWEoolV+vYB3fKZOFCYt3/J8kaqm+szcxUctarquyAMG5tBQs6tL/Jx79Wc7zRPXHBu5t7B5x5S4FgEr4s4eGDz6eQth9wQw6hMkD6I07cPNuQZ/r1UqvAxkjT1mtXS54I3tHzXvY8nTCR3jP5pHY5dXENbpyfQGs4FX8rxStgml5ZfVmqOl0+y3XgZsTzG4gX1k1rv0VFBr690cHpUeVNhdcgKL3ftNr9NwErKeqtfUGJ7Fy/a5e7YOnnGHGiHPGU9T9vkdClzJj5vs9jEo6tmvC0bYcrjszKzFcBN1erIIgZ4jNT1KK5cTX/xeoKX0i1agHe/DHz+cyhsuNoPWLxFb2VPU/wLvki1IwLQFW7CG1hKHW8PcsZaJKOtWKbIK48SS7otkSirrbH1xvruLrduY3wASAYzjqvV2cE3DN2EFykiC4LihzUl7mNqSNATrKnNYC4gk0X0hNJxvAkiI7GjY4NLUuJ0POjrRZM1L9zWpb83C83ae2xLnn4tKZb4Qc0kic5+frtR6zEAHNJgjFAWHAO/PZi/rO3JQmAMwDYIq2yKEP2IuhUwieOFYi9jMEo9tNcxQqq7NRsQ6B7qcjZ7k5s1XCjZjwTD1UJedIIMaWH/zx/G5TxoQUXygOedJvBQkM8FPIFis85vVUgnCk52gonvGcGd2m4i5MoCZ0aWRKSQOj4D3P+YfR+zyWHgy1AVd1SAbDRXQ0YEHe0PHp8cFsnLvgmiRjapCPXWQccFjJ8A7rtZmk2Yf29VjGyd1qnlv3tOSLaLX4ZB+Wuq22sp3iNo3ClddNiLFKvduDTsyTn/UX8r24sZcozogkZ5/Jug7nMtvaJFKgqxD4IFC95KueEZNRgZC8vrXcQyiz/qzG9XmLXelOiObh9Vm01H6c179BlJapqI89CmzuODHvUauEci/eJsuxAnq2RMPZMEoVrwSyAZhuG0pPHFOZeiEJZ4DpM+odtH72N/UZjsZAdyTQiTEkWIZGCX6C5wE9zy3deNwiJb+fciDwIx5NyUyKPtn6zrI09s9PDoeUE3WlptObeQAbkEvpRymjLCF3lHFabz1yknfmX0TrelzmP3QDfoKc1iDdVPLKK35RjKFVQPvfPPqGSxtspv+5pvklqiK3uvGclik+zEJpd0jEiXzt4+CHa+t4RmvrTpf8yumr1u5PU6IB3YVxLPllI7QEk/ZJPEvH/myr4kIk3wjGXU4g8tBOZ3LvRzGzCh2kItdt/We6RLHVusM3GgdW41Mb/RHsoFy4x9W+BB7SpFBhpphm1u7SpnaIJA3xMy/NIANdimw07iMhNEyRqlTo/SAHCGYpfzRPg/A1wnx1DoKm4zLS0M1va8cNh+oInnMJ+Imc/YMqXljTFp3EDoAKqghXlQZ6XPO4ij3tPfYhQdQ5/feuNqytbXuz0dz6sB2uwiA3SiI1mprTuFhoRa5ib+BewjyWUuFmwXCavbH1DO89ccxooatbj/LbGkzfDZOKruwWOjjsOMPU5VEVreBU6wRywe7+VeA6vs/uMbs1gCI92iAYxsB+ETXsKqwq9kof/8P9hsikTcVcBbtYAD5ThAqf/L0gYANnr/qcZbtOGofbt+mNAEe6jiJxT2a9ACkifN+YtIq+dkVgmd2uyTiyvSL/UyZTwNXdthtQY/m+nLPzi7sQ5PPPM5x0V42QZtOj998vaH1rUJqd1BnIxlLnKaKivndpom0m3kOfzdVUMML/LbgGR56SFABkxRxdNNVvog5dfk1/Mev4hYg03ROOKhw+wVunoglJauyUT2xqnT23avGNA8ZqQgY6v6BC0JeuRkH+MzWLk45VMyjRBqZR0sWwXMVAAVsx+R6j7Hx12dfdAnq3VIgx5LfQUVI5imjUQY7ryNLZLredUYL2aUKfAUUVk15nub/NtgIby+YFp37kZX7j+n60kjyQcRxhDUCLp7xw9MNv7bqjw7r02w3II5qicBL3LdeadD3pPw0Y25PqH3ne3gbvff7/UoeK2N6uPSbdeiCeRHWs2h2TFmculvoF3zYCX52vX4pzuO3388PTYb3t+vwnDtSCZI/vizbOwJrzBQb539ZQj1SCvuhXZxfteYVvCrsNI9afDo+jPp9Uq2+Z0cmXmTqhA/L7a3ijD2+Lg9XxB1poUnP7XN/JVWEAsojuI/xGkzX1Z7AlbAdKVHEMedY2BV4H9K8WiPCYfVBdVRDHO2DKYiTqImc8zLsvEBd8TSB1wJNO5B0X/RJcEBp7U5kfkcCgwZqWNf28YME8Hir/SYfNVShiFE1xZqtktq3NVbmeB4gSOmnqqEB4rGwE3/ca+la+h2K/8OLBwmAoAZ3WatejG+K7Bkea+DPajZGBz+yPt/a1Y2ja6EgScN7MWFCpYDY2J9Jx2ztsHSBQ9eyTtXqJVUT9zVktQj6CXtByTP3Q+gWLNGEhHt9wPz9B2TqyO9G1iOONpnK3weaWDF5c+/R7/6epr2vkUo4Ou4A0PYAQLQ9Fm/mQDVnpE4HaSKXTJvCPN/YAa3yoJL9PDeqiYHETcnDPVk/qGtPROjqrbFpf0VVzhPdHh12/GCD91fT4ef76BX18VEDolJI8W63Ev3d3loy8tBKYRO4YR3mDt6Wz5YItc+0ifCrUepdJJ1TcWD8BeUQvGifMHeGHWeOPCrpXUYtMpuDEUPjXLYDDw9BXvUace6fDnnGaBdGssL9pPGDUVEjZ4akm4xB7WPl43aK6jBVRDj+NDjVUHCrEm21WRiFC9dOVUTVxc8H0Ra90x9urQz/N7T6QdO3YxbYAoLUh8plasyDQBz1L2R9hpqp9GnBd9LWs+LIcv5BzlcJXKfLty18uOVvyikmGF5gvYIepKwkx8r4iReNWa1QWi1RbFg7eIv7990900lsK+yIAPej5hoWsD3stfUWWufr7KD/3pI/3iJlI3Gb1AIIqoHWdj8YI6d2SO4QPCA/u59vO7PNa9jjvNKEb52nnJbLpR3E2MLV2PluttypwjpNWWgh4L2rcfANKIKG47pWrGirx7tFAbDjJNWcVhIj2w2O86TmPZBkCTZ7OaAOp9coUELVW7xxAuvJ0TtgvZkm6z2B+0GUwTcRnGqifOqTvxSG+ll4vyhS8M3+vO9ksT+9QyGYTy551ng8hBiZ1L1ogr49h4CECRX2JmMgqAolXqKA94/+dxtKNe8SqPq5EI9+sCUU1e5jHB5DKc5AdsU/avtcqiGW9EN7o0i1Aszu+vq217UEo+gPIOf2ceGMM1/70AjznkKZostFo3JlDg1Gy33pYKMoshz89q+jlTgiLYCj9wCad1DeqewRhtawKqL5EF37LM/fkhc5Is4QXHnoEbYhGgt25V3zgU1KQodKL/dme8+z812SvbY5aEY0eKOBtXkMk77t+1DSUdtmwFw4+I9ueQ49pn7Gu4Aj4wQX9c1egX/78Y6hafqasRX7MrzbsH3xa4sOdWs5PiD7ZTmQ6QA8psTmuIXqlsC+L+aYoV8StMoMKtSKj2UCK+dFBon2Y8nSOGyCs1QkfVcif0hoo1pP7xqdY/vawhPPPbRFfhdhdsTCrWAIzaecq99Pk2kRXWOU4l3DIneJdchpda4tVFs+Z64NY9ulbN7WXkhJLCw8x9ALKKMaCixtOhYLNzE2u/SvTex8hv2D/XAyjGtwRDOPsVrLdphNxWWw+9FfztspM+uHwSdZLa2WS8nMUI6Njxj0TdXYml6sSnSUOYac4f4N5eR4Un3Pt1yb6N1Fzzhsk8OUER3nG6amUGNgiqR3YGxyPMkhtfidUj+rmNpetE85g4LtgRXDDYEAwxqrMNYMFp+CNnQ9tWse6LZmbYrNu2Pnr5pmlk8WWqOpvG+IEsNjeF6PLTqtye/cCjdgQUjzarGYL2j+tXylhqlBwxG2Rp4hfwvXBT+SmTWgoq43x4HDuIyngQYNHqj8Yzw6aIYFXNUd1hm8A5tnHg6FmZe2mTgbpUSvMnXwdmfHmwrJqKYd3p+sDrXFqY4QMr09LKuBh0ivhza2Uu1lOpAotdjWwKWDYcPwm3EivXbQk7MhHSfn9GB82GCToBvsgq8VIzgj/uJjG5RiJ8r/h2VjU2VM1pRZIeZjXp3lHirvYaS/MjpOajPg/hbAtYMWEatACTxIT+cbIzEv09Nl3Q7OdPpKyxANVEt796d3fbfTC/n4nyRut2QfUCciVAgmfQXig6oT8biKpNFX3aCQudXldwFXFiiTgnhr3rZ4hoLfcFCDuoKvTi5U9WMwses5x0OxbHU8IgSCC7jsV6x7QQNGoIV8pk6m0vflmwAGm5p1s3bmO5kON9g3kZECQfhQ2AUoiZdcWHhKqxadN7HAsyCE4LEsMJAU3hNNX6dCqgAp/MbiFH2APGll+Zd+1msVBZjHx8ZzZAZPm07jec2B0hV0h796zsRi+GbIjykWnHfjqoFv3R29wPlDdpMmljHO1VPkO/e3nvAHCK4hSHADrhNpQZwblE5mx1+EutvJ5iqyCYj8DOSgwguqo9YNPZgBJh070bv0pxTCZtbzRIbniQusLfg7Dmro0nr+gfx5UD5MJBstsdLGNrZ9ffUd/yvuTwilVjBz2X85MEq25k1o6UCAGNk7FZNkJCcHUidy+Ittbr2dh69IKkFtO5hBT8fVA474HbgzY6aMZvYbsUJgh+z0CdWKak1MfJlD/lshO3QgO5LBuTCv1WNMjiMIO3Pj4kf/yah+nHSybucc0Qful8hB+/29Zq6Fb9+2xtfC/h3luNDWLDrXrgnRKt7NYkMQIYz+hNibgV82zmfyhugZtXEE+H/WrhrWWfoV5gdOO4iFcC5A0oUfduGmkn2jYW2oZrrtbp9fna9pgZ58ieD3cm79gzzW2hGICS9oLNWz45rvDTZ1s+qZMzYVznGntr5SbaTVq19db8RMi2yvQE9rpg5CLteEFj693nwR2z/z0h++t2Wc/Dn3NHAwY5ZejOQ3E1FmW4Za9ks8filqkl1s2FpBL/HA9x49zHFF9YolBXymFm1yK35AD9cXmvom6ME46haT9s/76kA8HDWVVgGw2dBNJyogyYJ4TP1ys767bHtDN5JMxxy+ozl8B8RF2Z/WJiMQxjEVfT5Josf0OShxAWhbtp5VgLvu26plFRYFQN+FlQx1yBkIgS99OpKOGMaD0KkgUTwe8fM0xr4vn7Kqwzz+1Dp8Ka55bYyfH50rhgBtcEB7PKt4U4fM7nuJbzA227smv/O/xihmUfkDOpGSrR1GNdE7biDoOtrK9z9ESB0RpWWG4LLqEUsrH6FDE03XKVdAEMYi3t9WaQ81wIf6h5zlnsa9OmF38VjWni6vxb1wJloubxfrGRS5pkWVlz82t5Rljv5qfeOmkH61FrjzqZT4aOYXJMpzRy6aICeiw+aOCJrIYsKWOLQIKsI5CJM3wheGOpIKZP6f+J6+KBuEpUxxZ0pEC6LQEQJOzycfE10kvb9+JCGfS/LtT1Zb8RditHD4aJwdoPDfUxtGEUDsjZqIDkjfqZ6s/XBuTpZf8w0Jsl6DKNPsMvgRSY4twnUNKdVVmMH+uSTrRGikSkVXLMBCQNO6blODJ+zG2ho15uyh09f6bFwNdXHbcdcX0+1ozFOgfc497pqMgGqBpg+WP99tk+gN0USIMtAjTmBgYpbXveGOG+1ppqLidV5Z7lobaZoC+ZJ/DlXKMypkjVXomJ4hncF+x7Hf6yj129Aiek5a3ljkLNISwJXu/+nqCF/sjbhfSOF32neX1+b6bhw7deCz40LjbTjji4rTDAP5emw/w1dCk/U5wKDqybFA37FojLrqV70Mif3dFNwYDaQROJl1WX4sKTzLcLQyVWvOfcvozZc+8hzJZ8ylaMFFPP97uqL+XmI/CV24TwDuAw5gsAgCQTfgN9vDNtSzWFP87u0XjR+b6gAzbVm3MCrJr0fH1Y5aDlOZPF7XRJLphPAt5SZMzTNroQImPdzrmGJfVHA5Pe/66rT3NqNq4fyIZQgGxSsNcN0Gp9915mxJMxegVnWNA/u0qUgDs3f11edwxvZXaTe+NZRaoBXzSRu98OWb0aDyQW4RyuoB2BkL22eJWJnhVcmIDs7OvkMK739Orqjc4OY1QaM9iBSBtIl9HZmreAvYB/E4aeIxCkFSupfyF4bcovBXgu/RMuiZmrO9WvmIPzB4KgLmP/X3bJAtSB+0OTfbWwZsWc5ozcAF6SmTZFlxn7ylp9OQF7QN4VjDdVRiXtSsqLrINbvvqIykPzgKuhgLCoMVqvi06xUh5HjAfS/bnRlG/A6dk76KdIVO940KQ5glHjugMRyufAZThhQ17e77E04pnhFGO1qnhNBLnGIuVV+s1Y731UmwL4q4iXIdLTG698vCIcqMIUPHilFbBBU6GGIJtIfuiWfFV5/BpbrUgF5kC8J3BwWy5LjmHeZThSyIBI+Iis8xTWIdKjOABojjx89W1lsVgClBADBgGkDCyFjXhxWwR3TDip+3JGhqcsPeVtEd9PWT8MzyByu3/EvwSS4kHyaL6DU9PaypzebihmKnGCUu+M8d4g5h4Ym8bMo/63GxwRpouu4ymkuz23b38oGJn1W5A0+wad9QMQ9nbP7cO9A3e/wUYGnrkLtysYE8dOTioYXWeNrcnX5W7md+Wwe+8eF2V7McwVlUQ3tPLWEmkxqL486zX5MS45zSKpIdfh4XYMJiKiybi4oqMSTq3ZluipNB7QqzQcBAuRxY0jUBzDcZltCr3veS5XUbtxVDlp7Crd5c6try+piMLPbTx2sunxs2evEK/y1vlQV0a0ES7lznVLbPqqw9OP2WRBOgN+zjAA9KOYz9BzXXwvfHAZJ9ksi1OHTxHpKAkmyqz5eNmeZdsmrV9pVBBnwNscDw19D5E4B/app94sBBt2kz68L5DZz9XVzkcB0XeggzExAIImEDRc9LKRA0lMye1v1GZqDvK81p9HU+z1d9zj0JHmgwbtxqqbElc8pjl6MdNL+iu6yd1Dgyv62geMqm9QkTp8LiTZ1CaCL2nAXDK9c6cb1ZVeLAsBPOho+O4b+utcSulFo4Sad1GvQ06zQa2/nYBJaj9tZ+aFsYcNoHrQyLxJ3cDmxzdfJfvrl50ttiD3H7ZzfqWNT3oA8i9hWMt+zvrP6vALHpulDcEgjU8/dQhdOCi8vJYbv18OUnw8e/uYLd4I3cuKIYacp1tgubhaYmHvsmLnoAHFPSO7r42zV/wrTolL+8Sm8OaAk8znv7JcnWUORWvZP7dlqD/bGljX9Bb0sSnBha3CfRSo4+8SdgovwArjDdQUfIZjGbWltVZx9jSGxCYNj1x8XdUrUbwW1jbyJacDyRc1gd7ShTKE+1b1quORmR8RejUS5B7uoQUjFoICTH+u1iD0lx+OKA2EWCmgmJAKBwHCp9Bj2T6ieoRbSXRlQiBNGvdh6C24IJKme4/Pl5SJDlFs3DNtuYgXNLYDquDUEh7itOxyx0E3Eb6vlBv6z0+m9TuAawFfsAj9OGxzNFLhJPp2FclGukZypSNSv0RJKLAEbu2Uy4ql9niBMRlJXXLwh0FI3YXvD+k52bVcn4Oz+ZR73Eu92MoMex6NPk5jaZf0mLc35Yg9Fs44SITQkzDJpCPpnIWIJbMFUmtNCJ+rNh5GARenZBAILDN3AO9DJVwksI5zmx7EOvhhV96bbDN4+zwnjznvkL7ZjMfuO2reCa0KdrDK6ItqxNQXrOX2KY/f4r8REDRtPZaQd2RVf8BCYnNsMjEKUYAqD4EhsiBVA12aS1U0M6NKqxYeL8vHFCRv0C34IFziRNxhT6P17VoMMJopelt5/tyQ4+rumBrldsZkZj+rqc4/AzukHg04S6hD+/66zMr1XjUOV0u2A+2u79adtInaUc/Fa+hzJGhx9hteQM52dzyyz+QRBOfavuUBlTZ/UA8iWVPFV6HkCKsEojjZqA2tk5OssIodTK+soute8s1vtWHesu10MhVItwGDeiTEOFXIWdWN1y63L+qhWRlnbfSDT0TyJgq3s+cnpd3B3KgbpEa7soLdTepK/EXmSiwbQjo7p8GilOPKB8vP3S7o8Zqzw2NeG/kVQYlWb/J3WIDz1dC+XIaObjEd8DiUnDV43ygRQDmmCXufBmV5QQr1L2yKhykWaOj6D4SzNjujj+SSnhtvbGYqj/Ylh8wkmql4Vdwj25MZkpNs3yms9qyyLkl8CE4rdfFK5mDQY9XIQSZBWFxKjt2oXfVeFxRQbSKfvVtNV0pFE97WcB4hS24s8feM++zO+0h3rR+ttR3TSdcAbLkFHOhVXbwxtNVIcOwWk/V5KaD3/4DzxwY+hc9tBS6WMlQiC3Rr9GOWAzHJig4r6hk0aROboLxazVrs6hzYkreEaMFNKF5xE6J8F90q8EKSaRRXREacSy3kQByXeRpgNOb2h8LvUwY6YkV98MaevsX1etcANFnsairVhQH3whub7Vfgk1kZgpR/j0V5xrOdchp2EmizQ2gKwri9RwFrMBBQCsDDkF6VRTy2QOiOWf/rV+xBFtLx5TV/MfobVHU3x7KVd2U9cayS6lk8t8x2zvOHUZtJcWe1yaflqIZ4F3BbJGW+XqNCOQpdbCEKaeh5N87HpxqzPG7kHSXfrCC7KA7mxnx9LarLFx0GX64rwpBtZxnlbFjy/aFMW+DPOZIgARYgAtaT2HEdy/6nZROp1VIYhIhU4yemRtRXZdglkHh3TmAoLluNWRteX6F/fpS4iH7UypOv6JUm9r6QmWIJCcrqBCLPEhufrjQ2FVrxDIlGc5AQql42YYlJH7s8fBiW7YN+GARJe60zH1TXc7ifeW/1yz/M6r3dv1lR4HBpOgwCS0fsAsgqtK0F97R60UOXLmiGRi88rk7ktb4/sx3ZM6taKrYKHgg7LQpmIaO6kU6KorXcpDv8thyX+yCsqicMn0dx3zTTJ9ABs3SaTc8ErWYZ4pYPsjdIRmZfGB2lpTuQF4oCEzzkFKSjDDWCpGaKB+MwGf7XWf/UEh25qRJc2gu1lc+8ok0D+G1jISyX0AAnM/hm/EQ9BFNkgbv7wygPCo63Dcw3B4ezdp6HeBeFTdlGm4f7tMRz+4z/usmrKKPDMj8ABoMwP5NPifOjM554zAhK5ODe81ihWsj7E7vlXO2Y6LshKJ5dPpPaflk/3MqRLXLZWXtQ+qMbdlXOu1wQp6vBT+SNRgPFkKP9o03iXC1zRDijjJRQ0zhdEKMu5dgPsagFSKUpUZKt3l39nUGRkFfKE/THYKODmxv0ycouveTKRHBC6YOw0pQ1WVq+EfBcCsPJv1HxdTjMfjaln0txgRb2o20gndyjVCz3eCCKeYaVRcVxuAkFucn4pkDyGLBBc6G7hLiA45bOzu3mRTZcIBmyEHPvEecC3LQ9QS/ofH1dbSXCGcNqwF36RrmOaCZmZadOqyBC5wU7K1WR4Uh/tvDyMlbynTS/d/R+NKSR7KN8mppiR7P4EJuxoEBWCs07vXM1YOEQ4NBku2qtt4bfIrq71KNaY83jR53j2PYpz/Kxnu4pnl55edU1/j69/racehF4yIwrdmlyHWw6eh/Mht9ExiFW2MzoGeRN2QhvMM/rEKBaZJKuwmSZkuxBudGhHEauedP1MDI87lP+FBYgB58U2ubNsXvnz3HnojEd1Ei7ztKMPD7fF3n2E/6OFHMC7j0i/Tcy63UyQeY3QiMJZ9FMj7jplA3x5lNY5Y9idi0rViKtvGbtEcy6xN3tDsN2LNMBfC6/Lmtl4+EiLWzel6TTJyGMinGVt+yG6lKJc02GdVy5JBTws8UlsupFA0WaWPmh/h7sumD/lkhU+ozmDTHdBJFvKuHXkFUc3hTSxImLcQBpkn8txnqkCr5Hw8BkAHuwzqjRr1dqxP7zkaqn8Vyj5nhIC2Rzm9NaT0OIzvNFwJUzb8pb88YL5UjnvwSw7a0qSdnEheXPPh4m8BXI3EnKEd22vVCvun2WAZ9JN47j7ZD6uDLHfn0OfbCx6/9kILoDk1Yq+1KYyHC9fMkuYP4swztq3kROHQAtb5UlMIPbcI3BZyGRA+FNKX1vIjOVnPlVSx7dwjuFqZQ2Hbl53+PxReLxbZ2INfUd2VZu/o/Um3Ysv3DEyUiV0FW2SgSmJ2JFxd8nS4nGfs1WnHDsUH8GUJgqFhrD9LLlosAhXZaqWNcKeUfEw/GzTLjG1bu4lJyBWNbC7opYvDuc7O9rhSwndSi5UJxYBvlOLsv9bx5qzDkBwN/bE74taUmRreCW0MbkEfWxEVvHvGlxTiUoxWfY0TVIdFaX2/+FHI96/U09dz0RkOUZwl5Z+GvY3CIoZ2e0/mo/sAZkU9+Ftrn7Yh1wAa6tLGESweiNWwpmfXqiNa/5UE8x93zTB/N0DmlhcfpwlKXQNCXI6fXcF5iMBexloIEVSsyerjQ2/ZuCGynItz7jymJ3z+YD+7p8zBTk4r94ngkOr0KNjqOWvqjwM5SzuQYJnhFw5jk7NVgSoKeNozMaIxk6Kvv2rJ01W4dnxofOKwLBpYAGg9PyCmL9Sl9YBlSMzbxEaWYDXtufpOmUfAPz6fNDcjXZWn8yTWzaDSAvW7oKT65x73anGN9UJdERlSIK/e+6uHz7A6JUK1u58gUVQRuCA4jX0tkZv7lPmBr00VHXbar9dhjIx/wq/aDdnUVFs/S96w+LF6nXnVW+R9blpgpbfcnUQjLKg7gG9KtraGFUgl4A7Xs6wRBUZhQR542/uIAx/gvNPorUMGPN4ehAcVU8WHeQiX8r66D+x+sEAW8CDFRkIR7jPHGq7dfpk2RS2vMN5G9hg0NV5/xI9RrZ5Aha5nGKDlTMNQmYMxbLfg7PRi9VliHCDe3cVxyfTVolAJlzicdRlGzPUKZy4XRxTYIRTzT/yCxms9i5VtelPj2JICYwVhZfi0BVWa/edH/DefIaWhj9BtduofdtWSiqWlb1g9gYLcLv5FC7Xq8PiXAkOtMkF8TxVgg4d03SW3Ig0MJhy2//hAaQBleRdPopM9ig0ntgsKiYBYDPErhAxlJhbfOF5QO5F7kfZJgXa7ooA5x2vdH0ay6FKZXIqxYKvvl6DC8et/Vs3Z1KWPzoQOg5a7lovvqPjbOmx/BspwV5GvTozb5Ys8SZvPaoOItrfd7x6zJRC9ezcxFG8cPUwTezukBTQdBFRHyF+QuHzAu7psb+5lhse2MQx6HsGJZauQpYWCG1ekTdC/SFilc9c1DL0wtxPfadNBDoSzo286G3ZMPzHB6eL3hh8t5nO0RnvCokU5rCcAiDTmeXUwatSwhmg8cuqV6CvC/JDWACl4Rsc7U7xQm7yaeV0APbMwW5Nq5ASF9J2LLJ5WaFhFt0DtPQVeBJxfBlTb9fzqMZEWD/apxd/jOn5gaDHU9mcomT6tvF1jpRNMscoK9bQ+4MOuRED8bBHOyZbg0tTri4O6Z2RbJ7OXg+EI1JEeUqnOSt2U3SuowrNfihmJ3yPa5OMnwQLF8NsbOuZ2fF3Pw7/OZ9zR9/q4OPAzjz9RDxI+mS3QGRh2acWu43IjtehL1S1woTphR0NUoHesG+cKz0ELiePLGgavkx1zEPYcqjEUbnnQZw5W6Wda3iArO+bnXGUoqt9ERP17qBOMiJF1yKcAb2yG4PnMy+QeihYNfMVSjuSqUh1wKZSiGKcBf9MgiJ6SHCUJ8rtwxIyD2lQIyRprOXH1ONXHVbrJi/9cJk35oKjiiXDvu/tXjJZhxkJXteh88AYUgqv9AtZWOi1g4p0+Z6VROfqIns4K7/1heX2Bkp/fNYYcUHyxFGCPsKthVWeEPY3rBToKTsARoDNUPSSJuM4TBNYeb3Pb8sZCmwUESgUFbbNKVELpSIrLuYSp1qLqJDNbFskPGWazJhQYNxqkWTVbHKoGe01PeDJwlzaY+SOHDQSFVJNtaNdbxZOzNNCvLsNyXlihCTRLLiwO62z0tWis+b2e+7RHQMhdSSb8LaWTh9xGSt1sOtNZ+iCJeaaQGlrjzDAYiwRNdNzBPZXCLL6mL9OaOvbD/BK2P9qW4Z9R+n5c5G5x99rGZUXbCy0kDiTKZdaZDonRu6HWgjudgfS+HNgekuGz0GgJT30LqM4nCBHKXE4u43UFLnhpCzSaVR3AxQNBHqLnBKbNkwLFXCQJP09RGjxlxSo91kMyMLqX5iqcco1ZAVqUhpE9XShGhqZM2/LAdO8EGWH3FJAWU+0G67ClLRqNTNRAvha02r67GvDI2kgMlDhluwPME9ATlHsvHfAZy2jKizW2ZS4GV3qihSa3l9dxCh9tYR405IPgM/x1m1xlyoVIzglX2FE+RwiLtCdv0EMP9cDJhfz9fk5WCX8OOb/i+6LWEt5vqvsW/LrWKeHEjeWyQnmtbHz3edRPVD31Wq9+GZ7vyHL42Hzuqa8jsp7xag/n9GUD2B2KiXHhaoKrTtXFqODI4T/Hk4jCss/sS/EhN42bW2uM9CkDdN17n6LSiYcyRVtx9rP1HlS0vwb6NVKi/A34lm/jldLqsQLNb7sfaAAhqyHr8+CRgBnmRDleGaY8JshFXlk+rT5sZ5O1r34VDOdYx7XQfwlaxdsMX/8Skk4PbIJPGID5CxKRtoqxtyVP8LrbtYsrvxW4G86yDfA48mHbfkPYhI7QFGoJqsphaUvpxmsrYN14gVDftIdP/tT7dQA6Wgnd5weYXjIH+cnZJgjBt4Mkrbbo14nd6335duWqbbHRVp/yBWXgKEe5TFeQTjE+AO21rV+/f8wG6/ZWjs0qbx4Q+fJKbR8TT0yjuSxsEJTNweDwbYZlBvsd0y7oJRADMDB83o5DKZZj2W1suv5xgP3gppDr7l4dZLWvTik8EnMAJ/E9fhKLqw6ysKs+70PUrXL/j5F6pphC+AeIFt7MQ8+ttzKj7wZDs3XHQVijINhV7nrzSwHyHUTnzN0Zo/Qg95Z8yQvqSUEl1rY4Eh+1j49yGG8428DnmhGzxlgJmc4NqPls6CjbNaGphBGSMA9cA21MeGh3OdskjQQ43wCrElx1+jiDCMiYxeAxwpd/g0K9CEwsZTVQrplqSwIlciVdMNp474zMeE3mDk8JqemJU/stmDzlOsCbiIvkkJE9y7M0XnZXxgGL/S1qCNLpz1G0sCZZ/K76JsHNYLFq5CQa+MQaeQEKBve1PMrhaWMOYtSzqWkiYnN3Et5TLGgRSutKIxIberjfwm/M90diCq1IXpnH96EeI/f26hjALI0gyej4D35KJKL4mh58/rHy0810cFTFTz4/eShkjK/VL226X5ElbIaz/fa+e/kRtnkmJdyZQZOD2aMI1O8YCavtSPCnm6nIkuiLj6BhbKQ2COkwnPlkMC5Y65xx/efQFRJk86VYN6JujTXFE6ISA6qJ3lu5njKDQMa7td2OFPbbh7j7DP6yuVe/VE2eOHQuL5bg/KBCJrsPpaOLW85GhakBjQ6KkyzHOaSBXq56OkJolhW6x7dmRVGCARpkl2Nh+CG8LQvz4nHys9nk4NgGybKWLy/00GjSN+gjm+uwEkotCLDBVC33TLiQ0LGyPaSD1jg6EJWiNBFeTDndTFdRiMUmsP0va3tKxMK/VFHFq7kySV6R7m0fRTr3FJXrOe+5iMQ3OFtOxiwvLAdKPaEx3vbVeASBf/eI5hb77D45jFYV0F8iRveHLrPNQTiJe6N4O7vUojCpTpuhPJsVPC250Y9MjBpeS1OluUWxBRj5Ht2Jl2hwmOn5ks5Psf8B72CWklSff/732HG0aCjGDhJYdSUgJnl+FSDaOOfVPppoXc64aG8fuuCskg2E4rjtH4kitGB0LNCTuwPY3rJinXlptcqKCUyUiDxBYjzXjbPR2wJCgOjSrciCElYJqJ49qz8E891A+k0l0/eZeR/Ihb0sOhk9v70x7g0CA47ZeshsKxg2WhcIg8y0ygd9YVAdzK06cPrYtPvYFUqYogU2ljgNuXINEBHF56KZNcMoj1oXY0PQcmExUqRkwYhWeJ/2fKBF2kW/KpVY2LkeyrUQsjEN6VxXF09+9pR3sQW/oClYGWic/7NncxE92BzlIORWN6nZ4N48wxfvBmRMtoPtEKzVPw/XuUoIDssLm/izWGDILk/QfWBBZG5tmwC8mKxvS1t4hSkFpSOvtmPmOZ0/EXHdS3pg2OM8DHjUL5vtx61e+S7zRSeW5k3OXE9+m/j3lWuBmbeB30YwKK7dNNBzBkIBibSXByrH9D13yTG54hNY8sk9ZdRChXPAnicM94aGNxRbFxRTsSJT8csuSF6LRH52VySXDkGsXh37pSbR89A5jI4DzSiWlZQ3L55W5BisIgE52hbaXWALoLeLVkqjBHBhTby4OlRK94IQiPNwSgQ9BoIlZoQL52GM7FzK6MG4bhFD5szFIIwRcat2Bp/AqptOOkIjzo3lkMAqKNMLdoSscmaX4PSiovNkL8kiJw/c9qNtEepAEXrhWmklkgss2rBUwwxXSnJ22yPBu2zBIndW6O9uRiiWKAKgPNpHOT3DF3gJ992OGJvQYNEgRORgUAeIIP6wRXfm3/E3rjXbeHSFdn0BvrsPSQkO4Zf87wna+PrxDqLXBE5n/ljeDsIRZgCsZpaPLzeTvIMDC7LeoiloKbO03dtbbjVkPXgoplUGwcG4hPTlAr+fvPv8E9eqtuSyn5AM1uevzuPb7oiNRQHML0KA0T0Qr4jLWkYKvk9kkW0gSsg8ymFUjQcLrurQKER/SDyESXbx2XgSOfO5PJ4MDIQYLhgkiY4cIltU8Pn8QDbU7Biueft5jNeKaRys6zAp6WfYyk2Wx01ty1IZ//K4uhzPu7++VKpBiDgBFoYNS7pZWtRwt5EoXua83jxr/TitpEYwl1kXjTRA+2YjNpAhyMBdpNbt0ypercKhfQcoNwCFOFjMxib3NHVv3YvIxkhfIs76pNmBZq4gWAMPK54bng59VACFQmzKXqHgjKi7B2ZLYyagqAMjgMxBcRKESGNVD+SPYHzY3BfcxFECLodkn7Clu4zHw7IADw62/Mox/ltDSdi5RgHdsjaibzSqRJtDa4gYPWR/oKG6oY5SJRA5xMeragW70jy4vo9nb2jPNKlWh4gQJuAaBvgERJr9WrE3qQ7rSnZB1E+3S6XLxzk+aIjNlhe8WyP8V5SsJDPS1mnRk9ub6knWdWTJaE/IanZtwplqZrjPUljPYUdxh1+Cn4KiONZhLAx8JHqVUHJgOSFTaC6v3D8dWd88oV6hMng5pLAFrWsGnyU26eEK/LQ82zDPI1XISvK6dkV3NtCPyo1WIDSrGXEsfnndrVfke9+t5NYYmjFY8uLgBrzfeu3Fe4r73FKAzK/BGDuh0rgRvu43aLiOOfsCMd/fpX2gTaYtRlRvQX8OYLz9uzJ/PnMH6R/Jsm1EsUVRvY2fznhQWThpNSgl+t0MR6Amk+xvHa/zDS5HqVueS3YyCpjrNE4K+N3ck5Zreq3D6xKRnmki55n2ffM1RcFFAnvSXCaTmTOgAiKTkTFDgg5UKxL2D1v7V0GB3/fc36CE44HHjyymGJuj5iVOMcjEMiHMaLcrX7IWl/Si3VWZ7bgfZvjZYdx+tTvT/WA4Issl/P4muapPAQIPox2SGZLy42ly8J/S0fVBga6xs6RU+5Bg6/0HGyH0DaUpjfuySU/x7fwdFa0J+WG8IHwGYUiG82zTT7R1Hb0lsB2siX9pOo2d8WVpkkEor26tSv8CzZtwzaoI1lwrD37GrS+yb/C5NLSmCel/AwQ03Y1vAw9JUwO2ZI33jYlbWitqvZmZQma6GAHgdVDBn8Se7DBP8Hc3nON1Gh55rty1MpOE+riHOjaWQ4DNcisH1Hwt8RmTYkOu4L746/tF28vsEpErC7CXr1B4NBEEBWdodZhIwm79GA+6+gJyDkdxP/QVFbhJDqahBFhKW2xD81oCo6yiI1yalF4frL/lFKAFYtw=="}, {"check": "044f733e6a89b605cebbec9a2a4b61c9f8e0164884a45e1931e698168e3bf026", "nonce": "2b0cb3d42ff7064c1c690d4a3c280e49", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "eef3b082902b73a26a42f47c4b6987d4bf56f5ffff0bc95974970017cfbbd982", "nonce": "0f37cb4ac070bdf6a59738934ddaf8b0", "chance": 1, "cooldown_days": 84, "data": "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"}, {"check": "421b8776ae279fa3ed6adcfdae37863c27f5c359b82c857001b958a2e44ec259", "nonce": "43c0d13fd3e6dc1e244128df4930d6a8", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "a08bf29c044fbad86db26e62c8b41e1e84195cf48a18871913d9b0b4b81b05e4", "nonce": "7ba34dcd9f61d88b41ca415b4f37c966", "chance": 1, "cooldown_days": 0.5, "data": "nOCXvkH1eFxjEfWcpQ7ExL74u1qTgrplyZQLolAYK5nFxGjQeK9bnWdPThd2g9LXoTd+hGOxqIMpUiePswGCTp66L6OpQ5Ndoj3af2cL2o0+Um5XbS6kVum8JKXEFspviyYNIJKrmw8cMkRwVy/o2CyHSDnkesHLPzgeSQMOJ0qnVN9vMiv3JhZY/8OgFzrx8sWrTJEfvBwlX0S+ScQCishj0axuWyAsxvzNCCfPH5Ep5qklOGxMhN4YWEj0yAvK4qd//SyzV2la811kZUJhTxH24/wqwrVbJkq090dKiTTGl3glKhXJhJPYt6IlV2VOcXpfMI1lyEx7U0b+9MD9t6JELxcxaRWDF8rdLRe328PhVv7l5oy5+KDOqjwuzFJxr0TjTK9oxSYO63JQlOBo7kkFDqCwddW5UM1y3BA6tIDdF+HTJNmqzDYKGeGbilW4yX8IHByQ13hNKY3LpSd5CHtmJoy9jSGRNYigIUKUIt+cs9gN0BqbotXNym/ir/nKKP9CHx4DQjQ8mP97E+Ze6nF2nW5DaJu1X3GMkzrTOL6MeH9+LF/SVRwd/w1YewL1Ajgcc9svV6pIxAYaNNpqX9WU4FDgwkdNFGmKitSZ/QzHZaP22Bj12pt+pU/+kIOWsbulePOE3PAaJaXhXAZrK0ozwB8oXol9hz95Jke4e00F6wNkfJyJUrZq5Idh3q7Ir4R1njS04/IQaERXILQhdolp4QB02vz/JxpJ+rPt1ZstLGncZUpdDnwP56slGs0sNPhzHe0XKI71s2C0MVDUAotygoYKmfKq99Qq5SvDhSgpjtGor87WF54QFcpeb+0yJ43DClFR66rZ+O/03n5IWioSgcbd/RsceVqtsZS2/P1JzmXvu8GOW6KAxlOOofX/7HL03PSn/vM59PaQhaFIxwbSCizYxGbAYwe6h+Dq2HcCibJIX9gBpptH5J+3vnwYhn0TZNSAUtjqfJ9GQYV8OoBmc152AthTiCleizlCocm9h2rb5hEwCTCj87PBp/7VktHt4Lwl8VQcFyhCwLezLMuQHDqpvPlwljJwvH9cMrr0pWRwNbzcw8ckKDi0aMco/CiOjlBzHkmpoGyYMZ6LWJmCNvDlPX30YU+6QYT0w89BAFTlOuf4aJ4uGMa95Ab6hXLk+c8IHXO9nmUSv2j91nparX6/Kh+aXCvfehY/RR7BHD1zK4J3LO22RPnme713wT21kDellFxg6EdiW+BOotOKWFPb0iE6T1Qq/0zBZMtSpmere5UwFOf8QW8H5goEfUIXxBElCsG3z3G102sSq+qPjDU0AqPThV1UH2BXO5hgtblpC3lHCZ61xwcqszzzFUUGoOxdJJHp8o5wCu7//pw3R3XNMqnP+PfYB4WLBPshUQyy+y7WNSZpq27RnubO4bZfMRBcmzARCSFEfeauEpFDODLRDZFfW8MJo1EVCd0yl2OcDHdF5VTvnWomHwAQDMaDFF9jFt/NrF6EQyardZdVCeMrz8QhPX7F/hRKBNcNQbN+aleMUv9WI5O55OWi79p49VqyOj4bP4N9N0FPU17lCHaMkwCT+51lx28MBWRWlgty6DYLL1kurDMKqpSr+cTTvrNfAg71XpzYCiDIUy+p11+8XD2nOD5F+oP2qsfBGO9WTUkJGWBcFDNGF8WJ+JPylLIceN+pFPz2Bx/lIG/rsIKeJbOq7lGhtgZTS8oiAu9yy3vR0IZwp8GumoyGl60rKl1KySVjTxm8NN3wzw0ra+L7/0Rdr71BTVRDnQ53lGEKq9T9zt4KCG0ERD6CeQeR1leuPhtxU0kUTEKNqZqQ7duqfJ6KmllLwZNgWdL2tyvMC091gkaCotTCbusnLODHr7k6drO5yCaWNgJXIoZR7DNr4FuDQWauo2W/WjSe7alQkLVHdmV8uI8Qli13b0AygPxQ0N91xutSOT7qCiQZj5rWhdSyUZTNfotCgZW1emlfTmFx1ZDlbq0/8f7TkAMBIRLMdICSTzNF00oruPgp0ilj4W7s+fS9z+9QPG7Xk7uulxdoVON3MhveTYWY9HqNNy94owl0oLptvdBx7Qbghsw6TAyAly3SJUPxVnWoAUFMnJInV8hZDkemSKuGhzDBI3CyCnttwuXkvNu+jqpQnGHJYSgZN0sCIP+85AjbK1dMwpLomRSH5iZ81ZWuixGn6UBDvYZihruw4w+xFddlOxmkX95WAgM7tk75tE7xTERJIzz/PX2ekXRgsXoBbR9xREhsvZ6upmWQqF9h864jhvr5TxZBo0jK2LvIe3xzlN9LYR9+YaBNk2uQDeLG62uw2D3gTY06ju3Cq5389JrHnommMibLaXK+r2es9kj0Wf3XebqT6OrEsWax2ef8PBtcLS9Gzxzz+j3NM87rqnxE2LYKtTFRdnZOYlpXRiYB+0vNdRGxniaNi5Dp7+d8+pl6izVubIh0mAsexyA7kqDQYmQ1ZP+bm+iyh8/n5ByL2hipJ42QUbTynGribxSz7D5Wokc87XfF6S2kfpwUXJ7/Rm0VYFU/DFmGaTJIsNpJtG4QeE/SRE+tVWIW4vy7kujnhjc47BruYxGZQo9TWSAIJD+TBc9BMhakMdIGAQqBRcBkWMdLUcy3u2sXyU8cKnanQXfW0uLFK4KfQjV0Ozt2L3B4yhNhEqUVUJ2hwjTHwcMmEBIIkScc2WNtN8nBl/Kqm/cc+N1iBNrE4PejYPZhX8SL2lYLDgX4ETL3KxQBlkj6Ry6ZDlrGNp4N7vVSAHzNUjPp7smT2VkuiAcuzVrNtWJSQIgzHzEDaxtj9mhp0GHvYF3jBFU98fulFtW9nRIPhv9gK4+uk4WqFGbydpxaRgGlZC/bOT0lAL6C4DR/wqmMkPb4zo7BRvvn9Q7/Yp14EQDxKby/z1s7c8HLq16BeqQtx0t7Krc9QvP0YxCzXRuGA85ewpTE3cJjJ/4aQVwJpgYgNGekj5mFDwsbmDscTHIZMeTn3fTWjTGsQBOZhZJ/485QIp/aGIji3BXIO7F2saRUyR+Nz3w/iCtbnKadqUC834UECtJmWzEaGMq66m6lzwQRHa/zO37Z6giCfYnZYw1bINtyxB2ch9BAJ2qwodX1Kqv0uFNsTNRatWLS0oZG9iNAXi7LIxgjB8FwOmnU2Nv6HIH0NJ1R6BWtd5vHcVJ7qh04z5t2YohB1VbJ0sbpfMLjAITpyBAvn6jbAUMaF+BKw+xF71UE8bfOZJ6nGAVBpV/3YExp8bDwrbPhukUrvmy4VgPmw8El+sycgpeFVOB3JfrlewMp/HW8JbcBgF80wLxo4wsDajpg/cyFbX5hN09xnkY+7rHymm3sRQ7GoEnOhIr0oaSxXkH+GLP0cj0/XOFO7fzzTSbY02EsFA3kP6mPJ4kSW6HlYA1OrguO0JKzvHstnuD7/4voYxaeO8L/ysXnT5foV9JIdv8uhd0Ae9Z+AxXel3lTWR88QpFufipm3L4ySzPDL+xOAvSfxFyWDwCs07xzrkJhPFc2cCJfv81qkALHezzFjXmuO3n7BAywI20O91UVyUP6AVMugVV1Vc5CMbXi2Mcpm4dQf6qpFxHSh0C4TvH9SkfHEVqnaSwi2a3cFdErPNTRzhpxf4wHdEgfUOX+AOouEQwx32Ij0yszmRa/UHcMV2UGkQz4O3SXXuJX4i+LJqhKyhisAObFxmVUrMsU/sLPqFVlWURCUZdIATpX6WBH0oLihq3fAQmeOJKR+DKMlmdn2gR1J5Hs9h3LRzRr7PpFrKGlC2EQEnPVdMcs1onr/2temA+NUektoAgR9lGTzdvzQ8QYtp7bvJ0/sfzi+BNN17dFebc8qEIW+uyZmAbDm3DR3GLSagnIRt7JxeHP7EBwNSqEnSFqnC8d1JBPpID4v8+wry9KnoDwYBVtXf8QHDPrUxfUsRhPYG1aK3XcBIlPo4Ztb4ieVZZdd69OHt0D2Yrj4McDlnO6tx4mKZ5J6BXmDQV5VdAAxCjfx2zey6ep9vpZhN5MUdWQ0GmxxbidYia6KkbwLonOO4xKgzfzOjX9ZmKf9tcyWbg7eBKngUsgWMBwDVbmmfrLGFWMiiut2gPC8S1au4Amlj4xKdp69iD0qKmzmbGb64T+CSmAQ5Ym8DqWaV1DxJ3JfikeLcNI8HV0cuOGYc9rB6A3cqxQeyIiZIC+AiLerDn4o7bL/nZay+OgsYo0s59AxjIrqz7c8Yxrt922Jm+5PSdr2Zv7wXsrTR2toIJxCuLjy3mgrATeVABZqgaJTGtEGdOxqLAVVeVf1RBzbwqiEg14Mjr8Ryr8CVW+LAouGDbn8Cv2vhTxRT/CEBTCgVbc+GB6e8/egheNOb9ijUCXHrdufPrAYSRX/is6RRbTuOPjFYwFF1YqVDdcWeB79p+E8sqPPjqqQBUNzyhSq1WiMOdiHFzO6zv2JUq1P1QFIu6FntX2mi7Si6p+SHAGhSTwN438SN0eSG+yx/r2l81aFHcivB0JVfyDlVE+kObAl7oEu7oLbxrbfa67JSK0L2YSoxD0y1BuVvBr/WmvyHXDKOZ+ghytgd3nHs0Yj9pZhg7nl0YBHECiiIHNzciNq8y0T6+i4I9Txd6IVsWEziZ0sVaC3oAVBgNZXOcf51ttpHrRR9mM/G+Jfbk87b3x0I8Zdu+tkya2A1v0BPUUfCtJerXbHZUNPhf39ZOaMi7m63GfTJsLrUtJw7/IQIdRqH6LkDVFDA2U3zNUDrTz1+hZ8TLDgCySuj6CcFj2LSBtBRRHiuuaKeMAsCcYRPbNBLWEu+E9WpraPI2xqVuB2MqeqAoVz/HN7t3DWwh4GgIAvd50Lop/8+78s2qlSTv5uRF846tAvdcs6dnkxTFSdVKoIk6lpsx2jAaDHGnEjy/7s+0JEOxxrKl3tM4fk1HLoBgUk/5AgD4+szp7NcUliYhegw819tXVrd/gM5Ny7ilTwjLzooVKGdoJjbrc0fx8c7lSG91ixqJnLAYT3rv0D7ZxiAmSyGGHvAVgu9utTAj6B7NwQ4UEpJaB8Rgvswx5bjdo1y2ypregksl4J65eWXawqZYC6Bim4AeRUUkXpLs0wXGdL+m1IgK4/nvkumrYo+4ktkpeoy9zghHvjjDBYih3DvurgrxToKniAi4Esrau9nGySMJO+wBCbOsF0kkJJoSB6Ib2QkXog6ubrUBv+iksTupQuDere5R+gZjCeqvHr/IWEAMVXyPDmA4yRQwJzHunxjrlM12gWQrVKD64O6dd2kzskgndvsKRayH5bw8zPgryiPsoidVGzRHUIEzUWwfMBZM09bSTd4PpMC/PDOIWWNICSoWd3/0du8JQ/6buIiSExQ4VAOzFcGA8NGbdGL4bPoI6uBQnNhKWEceqwJXH9P7ONS+ya4sLlZCKP1NMLHHovlLcQhtAMM4WS9IjXingYLnBp4xg20swKT4uu00U221czDDWZN4Ls2nHQ4Nha9vbQOE864CrENe09Uqbmei25mbTgLsxZdbmbFhhaCdQwyQ/VfWbvkUIBr9WxkH8dw3Jj1qu76Y0GRW3sU3Ueil4bIjXzprfIjkA3C7Bkvo6ha4Pi8BMpEHcqEKqUnnD9s7dEp3Yt1Qq4eyt0xy1FCDvY4M7CvO5Ce+xUmwHnhd6B573yOxwRFUj5DaaeHxut3rOIqtapujiHM09Qxp5VHS08ay+T9oYtKdxAjZvX6T8onVV1aqNBCGk44o7EA4h3VqwP9n46f1Nftjd8mMI1WBQoVHE+VwTXpngJFKL+A2Zuf/OiRQ0XSB18oCEWdJ9HQj3XhMQbHx1BWEzWhtv8QNqxeoGGTS8CeyWACJVRorwFeOQW9jeHlQ/j/KmvAz6TlbMwcG7ctkLwMq9TIAj6Q9b4iB7qDFiuBk+Wy3TCxQQX8tQpWSTCnHZYvJlKl24QN/D+O45WOWmY84gj9wIFovKOn1DObON5yR8s30aw3DGRmIz98yQ59cvBY04uQgQmA6LmoEtyyETT2N5FIkA3TilnKz2nigURTEs9Gmk2zMCQ0GZUm8Mqi12UnWG+gq8BLJ54ano3ZfGXHA25//CbObqi0XctYnDCeYzkzGE8SLNF6wSTY3TuKWqAynwDH0wMHveuYhnP34lOmuTaBqifDf/P98pHfzNC/qhgjxOnGwZ10sr6UCyP848y0I/cVnWpTH544+kjKSVUZiXbKQ9zni0ndKr223yBXZeUVjoliHTl/Si5ON/7J32Z6XiK/OXalAEKtrUD4waiGmeOFnQaRthhZN6LAexU1vRmVGg9MSUJFO5y/sb4JuwbtF0FOEx4pBdHbEyTvgP2CmAne5AZJkI+2z6SYxm0Z6q0i9MG7SeaudXMDzxjKElVoKvZMhelWxWhbXxSjAfkMdVwHe07RaAVIEZX3JNb4Ls5fyNs6t6e6q/nTrPpo2xj+kr+nkfoWVpre1IyBxnhDJvWED6qFJU1L0wAsEZCbyit7U+vdbnYAniJNaElLhziW/SFTafHB9kE4l5Re+M2n893FAs8vDa1jWXVSajOHlGm5i9DAbw8snynZ1stcylmA/26Rf08YzTEv+UEbkpQO6X8ZEmAbtpSR/fPPaeK4mzPfV2SN43sT+DmaiIZRSmThEFcWRn/KRkJEH5ltJSJmHLQortO2dWxP+wiRVaWwVd9Q0eaNsSAviHkn28wLLzhLWEDw+FQZtX1HM3VkyksTQxFhWBq5BY+KbTIaA9DUKjlh+vBqcoxd0bZgnqZNiqJyfEpLwsIa9NoSKEE+CP5Ob2TgcNJK1X5yKXpvdILgEuBoi+R+jnC50Fw83w4w+koWdZuhJvPRQbHx8uk+4+WctXx5JaS7S37UcBuBiqjRPuZ/mzFDzfUIIeqoQgdgv5fJsmd5q5DA9Uu4WR5p5tngU62Umn4kpb7w423GTgQ10DJZrVnna52hjdB2J8uEIJev15Ym/3F1Bz+TaJxvVG3+6oJ+xc/BujK6Cu1pBT3T06TNrMNIYFs83zkTuz7aoXCnhB3Xcty8bPAoPzpQDPzZzdz1KD690LHqvksbXMRGrdF5qKAKUo61AcpdyuEicEv8vakPaFeehkdz3iSvD64dJX8FalcQFkKIuUSMqNMXWFOzbP/DRTMYNtFw+E4gEaTzAZu41YTJn04pouPBnhDaMK0fBkb9bOd09ROmw7VZ+hRT5UDY3Nz6ZJadTYa44m8SX40gUK8RzIT618nBxKqzR+QILHXpB80enILGJJE8lAgr2NWi+gDWxUIH8mzosh5oc5bSSAMd35OVaJpAUtm6+u0kzTPxAp/S5YUoef2C5jpB2+ZiYp0i6W6OOc45m2+1TiT7Xf80qNxM81ckC0nV9HI97GLWc2aFLcMd5AwpBAvYllx0rSFId0wOufK9N6Ls9Bo2EI67lvhMDBGuXqtBx6OdqyoEV9P3mPvrZOBvviewQFSR7Pytp9WlKBeesaDW/tbseoBxnPCH60GizdfRGipu4DDXS8JzppFVGadhCnp1x+0gpY5wUiIWJry9X3RUf+0gLV/Oau64ENg6RJnKri9UiJEw3R0YQEv64szvsq52M+Wjbj/XPAeSJoRFLw3+JFPUnlCIyMMkJuvPCPrX6UNtew6eLI/fzpkFkn+NlUDfdtMaJ9p2dSYBUUUmKiam5nwIcQt5qf5pNvO5cS4DUeKohiDLQ0M9djQSVogXGlxRJac2iJQ1RTI0A+staEBM3NMtWQ7Zz8MGxj6crAwfDH2qinCZCF+YuwiricXh06p4O6EwpZdnEiWEjgT/CY1S5fJRZMRFvO9WfUQAPSLyHmd5F7NF5LWdSqWCAA93LzonpVpZwxeDyvNZe/92aP0/X05SudYz0h1pD/C+p+zBbZZR/wj0WYDAuhMQJzhHYRKyJgb4S3tyTqUfVg1U6raYubnY0Lyi5QmvnOq8Rpm0MBjfA3n6lXT1rWV06Q6lXDvys1Vi4lrH/sPs+gne1SI+RXn2UHy3hECB6NYhxGZkmRn5CEP6D2ctDPFqmpnfZPwWPq5+mzDHe8NfNXKFU+c87RWhPdKbRygrzv72oTmDPQDsXMILYBuvfgngYKkKEgE5cdK6D5/c/qpDnrblo5xFR6qCciNy2X8Mi7/hOP4aYU1kM2RjEzfoQTMLTWECxM+sXpf6PjZsO5amVvKiWlha8G1WIT6GuLqRCFPwPl2up5pQOsf/6pXISml/89kSBMGFMjWaR0/tkLT5wXyeal/KbkxoOEy2pPMUlHLImKgsJVcqI3L8c19ZAtuXUzXMFWDfovj7f8yBBfwwz12Bufp28YOpcYOhnZ30KF92wcj9jYrgz9tApDEX11jrp63znwmqr71dnaFLgIg0mw61FM6ROOdHcgV8f+Yeots5Cl5/6vGcvk6ccTEbXVfDVW9meNW9TL/plbX86c7Q///3fuNMWBUc6Ka3IeWW/5MxmAmyKJ9LkGBpCQxcq/w6XLN7pXPT1LJZzMO3ACdkKY3zFykI02q5mKUH9rt/QlzOdQglCTGy2RnQwZq67xLs9sP2U7/cAT8QVHdn3F3dyB4a+kFG+dzpubQJNEJje8L43M8dfedqR+jOkeeh0Mx0yfIqncTtrSQRPwZugCZRtzOkVF5nw1xzJVLmwSQXshjj2k4KFdCDZ8TEmwVo+9UOoHPiu3kEo3++YOZ2Pb56NLUX1LpLIjSniMxwOqFJasUASnzw7CAr6QGkNdr1fAzAZXIDmMbMfNJKKa5Zo6BFyphOTi/YROxX00v+lgb7j6e1r81yNGkLypGKvUbHESuPvtwGoP9Q1Z+FWPVEuCh3HmMHHI43JmIPsOiz31V/IcgKlMka8haEgIfWtC9c8sEdzk3VTO286QF9UGfywuC3xru7NLAKZaGgVHPh6pqN/c/FxsfTiSeUAG0nQ6GueGcBcSoDFRqJPUJTD0ZS6IeS9Uy4JOkFAIv/sgAyOGt+f+dpLw/th5lMB6cWS2oOmuYpGnfQECR0j0isbSI2/XfC3GfFuPeWwvwzfsnl8sIFbN79db0tHVFWHCXxJ0RctA1zjPS0YE210lgJetngLF0A8QN5JpgHOmW0WIQUPxaA8p20foXlXxNPR3wt4ekfGysVYn91UqG5tNQuJQf+L8WdJNkVrjlrQdO5vJKbE6kri0fjyg/WoO1K7MwVPvZRRf3EY+8DqEGbIqZZgtP1UzMH59xwQAc+zslfzVK/IIPvk/VYmXrnMrpn6u7SaVYRBel0TcF0R1eq4VwZEA/Jf1hWvKOi7lDacCwM3oZYH+Kee3g2DTFl3EgueUOKvttZlT8JJQrs3hht9RrU497FViiJWGe5cQYlN7PaYm7IwPe1OZcDEW75hpvXgteBrX0KFuXga3K5/d6tfV/98CjYBPqUODw4VTZ7PtolJ+vSgT/qIouEia/h8gX0xBNM0V9JogedC0bYDUkkfItc68fn12OWFfjrWnmLpy97sqFCuTbqsvoZQDPWHZh98Kf2YCecTHbQGvz4cwlZhagvVkSQnChminfBufsc65BFS+i7CzkfLknwsGdwo8/sdBTODGSh+g1k8f5L5/95hbC6PdQ9DF60fSxnjWt089KirrX1gxUGP4VXsridDbT1UFQuA/ZlKxNwcgbtn2ykwG2lARW2XS/UV4LU09N5N5fNZtrSwXY0Gu5U6uuw4vtEmsUzoJQYzSa3jRYKSgp2Jlb1TNrTMC1L6DrvuhRyzgD+GJiYNeerkcKTvedkv7WRpgSBW33/Kv6ZVm4aCEha3GozyUIdz17sY5y/X/sG+kWUBkpu56sm/b7yCCkWVUnV/O07MLToGlfHweJQC4kR0kj3u2eJI2vGWKRxTmV1mqfGHzV8WO8rEcYmlgdrU9Oecx54mJXk6eMfV7j5yUivp3FlgrIc+SUmgX/cm+yLA0HF35Ra7o9g6pQj/4tSINV3KiVA/qvIEDCbPVczji0TXU181uogaZc4iZHYu1bPL61vNCWrpoognyUQH9SB+YZP0eaMZyu55z+SJAer2UG+HqWK6x3cRkJr2TU8bwfArLW1VEJc/SDpnZbFZpuiHCOD11KTDzVJzFe/8clWJl7zXpJMumntb14j14i3dOzBSuf09NOW1gdKaMHSgHEflhnYCItvMOzw9WiGlyFoNZGWuN/9VB6Hrm/tWXqapA5LClFlpab/4Iij7X9sj3t8FzG19yUj6KKGYAJabqUIxAnwwQliS8PerDJFZTOQxWeBda+lWJ61fnLzHUHpyqaRD0ap8gKiv5SnsBFLDBCtOc/iQbVih4rz/l5cPb17p90ZIAGLGC0eMG8uffMogwyf7ruGix+/QAR7iV2MPYa+glATUM6QXai3oHKrfaDb1C5rIuPyWZwUR2qW8bR4V4Dd44Hh4V6+B8FIgE5ejC20bAMUMJQbYrNoSvYjZxsE+zDmZfyq5V0KTI6NVI0gcffU7a8TwibhGBBxpCCSDGmRXZBfYF/PWqS9pPs2LYk3jE4RlDIwEHzuzvAYMawHdkIWdTc/EJ4eHD0ZjqgwLFXLjntJo/k9s3x1d6kT6nXjFt36a99tHyelU/gYGjtPX4Lyw/prk8Z3P/KwVQIcKq4ohlIxGWkoEo0eLa/tnH4gnX2aYfEBw9YiXjOQ5V1HixJBIDFy0qAeKCTIp6GP8TaTqCHajipuG0QrIEzyDqB2JnP5J/Jn2JKGif9r0BzmoINLhTY7gsoL/yBDgS/J75KWgpixCPk/khwowwRfTNBUXKTvP+XSLWSzIrDetzWqY/8VOEdZaAymW9Mt/p9TUthKgbMh6+Wmsz12RA40Wnp8OGvVQaSetdnBAhfxz54n7OnOpr5fhccwh7B2N+2j45okU1/n+IQQ+ZLu17gvvetdgL9dF7PmfGNgokL9FkVZurMe8OMSxUdisoKLvVs/wz2HfgAI4AceahPqxjqvjSldsqMEBglNxdGL+NNhp2MnBnp6SIWqdw/rZFAGf7czEgH9CT7hihEdcGjPsgLqq5fxlI/k5TCI0cNug/t0gqAuNzFHkrbFuA7qYi+PMiwwwkRA+G8ruPhyW/OJehc70hlrMOnix4MbNuQqV6sdO338m1IAOwdJR+PRX1TZjCpa9y4ZDrP3dMm2C/ohjPDfzoTzrAgcWNNJR1eswKtr0CupWRFaq4IWNbezlbXC69jzDBnh6E1xsy5R+L9yZCIUBTfuh/SSyWH7+wq3qigzK/RyBH3gfJuGITA3mzCWdBt0cvlMY0kAkSLarr69vCxWmamelRKy6UlSH66PQfMHrjP5uMSGSczkG9wKVOOQzAEjxFZSzsgKZH95D1zSCHD3fHuquD0vQ4zTDzU1F9CKgeOB1zCrFc84abK4TB7OE24xxH9E6QjChqLUyV/yT4TFHq0JWolNA44TRtqR1p0vVPxazHZWEGJKkjFkNzeenhTxosZUJ6iiPAtJg+gMfsZ5zsR5TMxLo9oH2XKzR+pRxQe1YO93RwFMsxl1mb2wC/I+F8cRMqNQKG4c969FdZO1uxKQXTEypAscCjEOErD/A2fwVoZ3eZcuQtgVySWizobkrCKEs6+Qf6wO4k2M/u5lnJ40ZryE9T7VWpjxyLlwS8jbxW4TaZ7eyylaLFgtRo7aBz96PcN3m6mAicJlwfzuU85hJJklrz4uEkwlbysDDa6toqEWYHwFnA9DUr5uePIssHK9l3HU2YWZfh2BR7jDT6wZnNDShe/CZjSvkfpHmD2oK6xp3ctsOQgpbjgUuNCFf5u6V0h6ed2VrL6YPEvCw6Xr5Nh6PKbEFypPNnCOgf3wAwFiFDtVaFTyaifBxLQLmWOd7hsVhJliCXBr2D7D4Lj4BqWEfDGp4HQpYAtmCBxsWejuSrYuLI/ZYbbQN+LKHrlMsQyK7vtqjut36PTOrdMokHRzroE/C5UuMfL9XrXxyLMXM57yWav4SibyzRj2JwCJM/IJhcXBno5u0wQzrurs+62GLuq/3/oyqBukzCjpOYwKLPi4TIfAMiBUKD0xjinHMreb65iMRiOUNfnktsyyxkvYIH2FLI7VI91SOfKhXAQA1dl6g2HBXtzOZyNmJZ7zI6/aJ0knLZcu6LKTb7JOE+G6FPdM/vu5hgunzaCIcrB4ejoo1LjdhKsYP5ZrKUMPCWoI7XHRkCc8tnlE+VOlngnIP4WPRZROFodoxaeBm52gf5xxHp/c2UnQsGghGTvVPywf36qWHkdCHxQAM/4Up8OzyIkAtR0MeApLltXstbXkvoSGcBjnzjN7J8ue0IeCONOAJO7nX1NlfZZQFaSoZgxFEQ8v44C0yo15Lfz7VSCixgKapYxCAymBchVvEypPs2soyMWu/Zf5OsxwzV8eNKXdFJalmK0h3WuISHyiGQSAEDWMQWQWM5EddSgSfYgYLB0QNRwhrAOTRqu2fUOvg1I2P99p9Cuc1E5nDguHV+cCgeO7OWlrX17ubGuE8lcsyJ1cb3GS4FWxRKVdQli7EaxKklWSPB1vvT7wtFTDi1yJgF6Wxdwc5BzE98yoKYc8sf7EwzZIv+K/sE+wJcwLPlV6f+4FDh6beYN6QYPylm52Ftz7kaXXqEMT3UXfm2lmDa7mwT9hZGF2vaO7C+Oz/EfvJlZHNEH2xgUlxw4XqwQNZY7jtummoXqDdXxt+hqBBusQO61zN8CNXxTSPuJfLZw7M+TFdfvj5r4a4yHUCHo0hEY9ffj4gpYxvagKXK6pzroXIlB5ChhKWHPHTmzJcEipYAE+odkYaPy0SrvG7VDWUDukyB0Lo4/tTJEDut7z31TQdFL/RUQpbBCIWZmQcRcKbQAGmUxrbnD7DpmCykn6RaLLIJJ/QEszOqKSyT7z+o3/m/hSrRV1sWif8uHKjxm2gEsOcTtvgT7vbH2aSMie2oVN7kzRUMWw6Cp4RY3REThmAYBbv9BPxS6FkaHHME9lxChL5BiHbXkb8Y/uB+RBCasIvJKUS8h0jXOMZaeiH9Dp1Zs/bQHsMFtcG+YMxZdQNDS/WEEsRy9MBLX+NzD/0OUIHP/n+kX1Mf1Wo6vGvEtEd5Rv5or37l77PNYpzm/eMxJ5eq2zKV3UzeeD6rzDNnCPrQd7OoqMY3BgLHYBBvl80hMnimTcrjXd7Q6/g+7JF/0caVebXqHMVtq3T04ezlroKGOUJf2+aavH/ZQ2o733he88ylCtCy4ScB8lwtMIQAOMMr7kRAx8QKq5AtXzKcW02RXTsDa58mKXwg0Am+/8ipd/ism58LaodIGcdDPnFnYdQqWXd8L8GIMd+fRjPXc8A4L9okKjgF7gOM38nzMJREZsOECy1RJFhrdsCM010qzhrwg2ALEde5YNkkcqVLTNh9TK5lwDPv5WPOZgv9xE/C9GOcYRxpxSDtGFtBncK4RSYX/ORMn36t6bbznOW85B/47RnTN1bQUSh+RvheBJEu2DQd8f2mERuc7i1DYZxhqHsu0hozV3NTB67rnCAUvY2GhgjJCo6lSigzP+4vF6jJ2S96x7SHxNxtXdWaVHZV9uyfcOcMNN6kBa9f1v2W3BBkSnoEtXikzMSX0wes/N9QDZgYXCpyizlEQ6nhfsCQamamTftS7muEZbTNUYtHUBDBTEIg6feP9GxPlArx6ox6B1ccOOeOqJx9QWv2fLN5O4lz5NonL2sHaTPhkAvMlffnArDW4Wc5/ELD5dGhN6XFXqYXrqMWS1GT0W/sR2NNzm5YqvSCS0MLeHrlFjBxGVE2VD4+kGyEbRqoSQgCrSGw8eCpkcUWui5Zq5Cp7o1ogi2Mvp2i2LahJBQPdjolwpsWie6pQAFtej8PwMgVWsIbEhNebq0GOTA8Onox8TooyPksUBEkxbL0ctaR8OdyHXi0A0kiLBHD2gVDgQ5A9tg/vGarNpCujqMQT+ZwKqK8fo/G16oVSXPn/3vMaYhKgMWIuwSM2G/d2wYlFcdDW5uQtp0flsThGr4PwGcMGApBtLIBSxyEeLedC3/I9gtMapLPrGwHnnyiYjjujUl3+A/IywVT7rcEN5Irwp9W215ba6/dDF5lrMsNTFOZhxdGjfuo2om8WUSX5TVOPrYeAAM9I/Ui82+7WzRxm7fkrngr/7SExxbBwLfFR6EA6asZlaLIHpG0/D01wrkM+a0vWLkjNWk4gnNyAwkfoH7LEqok7VNEtQ4cQPtZDgjI27DXnXpL/qB/EMpblri3Go6Ft9z0ku5MgJCBybaGOdcvGKsbDqNscHUaLw84LwueDy2L/5A8hBUUBC0yJLfslmDk6zBjAIP3288AWmx6S2sjTbd0ADNoKYf8hkl9doJCwLNbXBWoUA+C9FTe2TfO/+W8+IdBvYcDDwa2PpkCDzJ0X2lFYKPQbEEhpKcnMZpFUK6L4ZCuCg7cFc50Tx80F6Zh3N7lW/Aqsgb4bIHvGY0KpiJ/b8he3UTMkNfTI33Ji4IG70pFiHvLdvwm1cBjf17azXS9Jjn8sy2T151Ds4z/saGrX85XcNBsANAKJmTzDr1yfsVfXxul1l0kRR5m1855KBKzSIdVS78Ojf1XhlPJOosV2tQjUT/daE0yHx28ITr5memByy/AGFnPtaxKpk5ijOIA+ZCV7yX7TWF2/HEqJJ1QZFk/+EqCMc1On7J2W9LxRBYKRvsLlOdG3kkBR0glNo7mC92VnGDwuZVnJohs18mHa/lD0wsDcW5FqeGyz/D+HJOOTkBEAXCXzJ0t2KmYX8jIWMZFeK4L2F+0jWvXgg9eRGQym+trQnxWAPQjZfpv2WO7z3oIR9fCgmpq8VC0Rg9fp5r8zxUYdkQkPGe+OcuS46zD7569me1dQcxGVPkYMrDuWb4wIiNvCThEmg6OfMPgli4ikqQ0CeY/cZ9+MOTEutH0I0TVp+BmiCLV85CCjiVuoqFnlDqfTIQ0K0CC+9AY8bUjLRYIbzdRXafoMOxFVE+4cpTkjA5uSZ10pxsguhA7aFMmMBj1aEhzd4UtmOkGVqKO5F9fpHN09QoqlB2X6ZmzmAxUVMn8ezEgQUgaCKAilsPkOSgfBdd4x8HlR2csJ2nKHgTIFeyRlafbjnE0PZTiaqDM1AE0LPVKu68T26ZvGI3MZf5hacbhQx0EEN8JvzSAh6EWkqhOJgV2oktzlUYQwMZP/YBOdYC/ID0Xd3duNgS5XfVImuHcS0d/yj+CnC+n0MwUndTvZ4d4rPfdQydbQ4SfwHJbFxj9JzB3XNdYSJH31qMZ0flfHcV6Cy6jqM39KIQs1ZvyNDnVDQ4lqKnUHKp26QeH7p17/UphT42iuXfzAIc1a8ZDiAEKHi/Ct7LvYaz+8aJ0rA9+rsU5317QmsJHLKKTDNAJQaOaL/EpeDpfvVVJbiRjCU6q771eACUhBEKcuHQDIZ8/KZmMaEfGI1IFrcK8UvVH+2gXr0Uu2TzAHp+XqOSa4MScbCK4yFXlv+omkbsJiF80uwCBujdBJkTnTr7noksof28hivaDW9KJvQznBY7ACXkKcmkikiqcMaAnCwSP+Yu6wMQNUvj+2DnM6iUONcK7UV1df93HYTXHbRrH5vlT9Ns68vRUUEMgogLRSKmCiotocV5+nSJ9lYpBwQ9IJeUWFOgkrf5mGJCka5ujGQFAMsB/SAXU+uqSlZElP5xNQMfB7QIOvEUkN62JCJfcG0B1DFybz6NAm7c/zNSBZ3zyBFt2GwDFQhk6NK9HWioNWQUW3iba5zE+Mcdei+aKIxkZp8v2mZ27537UU7PX9cqeMBj1QcMLIiOu8aYnctv4nwK1Kjrb70gUELiRMLyVPbmoP1AEG41gOAES1rQTwFk8dq9jqGNhQ/WmLbzJ5togJsBICGE3TSHKB8mJISkDR/x9vmDMS6V/wFvGpfqBtUafUWq+4yK+SyfyQzIUQXoYALbXi+CqMQTh+HIVIzyl7CaBDxxFhnM/hdP9e8tR/wZACkWTSZLTPIZPh+pOv8VivGl/FTzS7+YdN/7tde3nQAwWOoEsXUGiVoC7eHDl2u++0oGiipB12jOwcHdeXahtYyKU1mb7BPfCn/Nt+HhY+1P8JqQMr3f2TAofq1SXry9WHGlUb7+eO0rm4hH1wegHEBT8v3RbQk97R0HuflIXCXjNYWCa4+FYZR80byF4qqH5hUIqd8meBkH5AGU/pEtdVD9VRgXKfxKlCHGVliMnwDDixFGUK0mCbeJ/vUZbTWwHH+wMoKnie0OtkkI0h05Ypf43GfZdAq/jk6WYXa/3eMhk4Z0zlDvOCkEXEQB66P+BETY7s8E0LZtn0jZ+nrl50b8a3t9cwBdznftMwzjIahQjFa6BJUR2VburB13Jf16lGvoapOyw+VWF9EV1K5XCVJN27FKEUO32KhuJQ0C+rQ5Ymj9JKq+s5CXhHOGYaw0YOv2IDkNxTU6CbrL/5/6UHLsQdoq1PR0PR9x21l0k028n+N0tt8462TbbyDY8BgHcA+NklZ8WjTqK2iJGv5dYxyAmlHVnVHva40p9pF5V/XMyZ5vsdBFR8bRFIgIezvv7lajbTc9VCZBvzpGgW4BX62x2pKLbXDdr40YXKwpMV5NYqdMweLU3U0csHGPM8gCM074Ar3qLiJxENEx88XYvY8IRRqBoCKqWkcY86u0+i+adt27/VtfCJUIjZ4HZdSl3/sdVaD7rXnAzTdXhWv3vvCZgdSfjssB8PTR/8LADbMz5YrUXBrbxA5Uobt0oGNbIiYMZqnojp+amXnANBEKnQtBSgXTO5EojPILHbfOAJNPfRRLgql/jTrP/Q9BbBFzZrTkWgTruYJl2/Vb8Q4wMUkKUeF/e1xZ3AR0wF0SGVZY16NmNoFzdNdFEtxgotKfeP8R7IGQMuana1bcR1vzYpwuA0IGjp6O9UFKXDtewVBOee9Pu+IEJ1zF7DcNazWx+TnISgh7xO51SdvT17r6CDeCUYXvXwnCENRcp0gjeM43GktwzsvHab1kqO1cRa+K03+j57n7oyaJztU1ze8/VAGH8oPOgkow4IDNaAao++uuoIhdG1PbSPsQtJmwYf9ImZYM92673clRi0XDVWxHsOFqMI0msO0NPUrEV/UmoEYf7EWhCn61TEZN9N8XH51cg//Lc6eNN+w9m5ToeNykJGVQGUrDK/9p4p+xtQyYwVaHnn12qJixoqAFp2IUgG/SB/QJ7e1wAL/JujM9ot2pA+c/isveUDVijyWPYEGV3HR5y7wn7KnDCe6rg/aGh53eMVd0aJH0OPgiI54+ahq27F5BqsTgqVx0L6u2OmlcUl9otKhoeC9UYEd6qhEhg8bAV0aUtwI49DuDRdcTwm2HWsEfw1XI3dcMgzT8nKx8eRcwYGddCxVn3K0tYCLJUws/jyfP8bpi0KP/W+jf7Hcwgrhj02ByZlFEdjs5y6Z+dftgH9xh/iTn5Gty34RZE23qasTPlvB7DlI725MBp08oGzIka3jRNEiAeIyxSB5pQso0hk1Mn+aUgGKulxeMUIDrndHCSzgnc3JWLafRlUl0pILqTB0GPwCAh7Znzy0CmsRFI5pDz2SVhSq9qSuXM4jfqzF93ch3dqYCAw/mV643WrtrEc00W7E9FAJvHBxi+bKRqT60Ar6uP/RKZleyoY0guUgV8zcOz/td1FyTPaxKrpkgkxsAszB2ft6gVCxiK9VrsxyX036Y/RUO5Kb7+mH1zQnEsm/xkOHdQjHM0LzBXmecZ2nKXkic3nqYKhr1HWaKi49K47broVvbeTwrEgxntssMSAXvo2zDAyd6lDHznXkpQDNahC/ABw/F9GC1AXbPD5s7o0rOegT0fnBkX4CxxXGthAymkzynLz3GLk025wPvBjF93RXiLvLcmFkONFRxeKiZVgtzSPtmK3XG7WB15ww/lu41BbYluf1G1/vAKAWZ9zzGYozQmoaGZGOpysjmzTt6s1pF4wAQvC2ukx/GSMED2J+4m9K6xPaQP7RPXLwWvz/4pT5OtJJtID9kKfLXSqEmGaUKBS9deMyTkHWw2OAcmvjPJj8gQ8HOpBNp6VzlywQklem0+SPYRQd0ouJucLuMhY1ScraeX448JkcmQPMRkfZIGUpOB5dvCE6HPdr6bcD4mceN29GkfEqIOQP/9vpAcHRzxzmpwvwWwrpCLpgwtv6uOF+AwbsjchJOv5tKfWKLpvReLNbE2gmZrC2DRBb63rU9yGrlbgvwzHOsFSmw3z9irTMLaYnRvDlep4WGDS6bf97IW3O/YuN25pOVhB5UfjYlISdq4aVOUJaOcwUKmB+WiVN+unTinWiEVu7b2ABm1UHYi9wztq8svn1yNwn6phnoBobQTeGzYUa4+AmreH87n8Ti4nM2Ez1QgOq8Uspq3vrnjUEv6aH3RZDAVimfRNpBc6dgBa0HSlPTz49htWWNsj0GeblSYQcKg27nS/X8Mzf97cpYxxwwiKHy+azjz/PdksTEHwiZo4FF9+mU2u/kj5EIE/w62wyVokMRw4VIyVS5OGq/Gd93D1ExV7sBnliMpeAsy2q/dk+9V9+FmME6PMgTYTl0pWPyDLDAhTOEgUc6Ab1vMKcxNMhdZh9AXUf0nl3kqNgKO4Y4gVS+U1IDs07dirHPkJlghXHa2mtZEs+6focY2z4ISun7KB3Rl8BeABAag5EMXnXw8L2DWW3MXxsRAG/nVE8dT3UKWKunkl7syBFRExcGru8LwqgcxwUuzVD3lBO5HDXAlQpofUwUTgMZ4QtcYPqX1wqj+sdzU6KVLFsn+KB2fS29xgIVROMOfqziAMF+8VRqDruyBvo8J0Tbwtz+Q54LAXU79/E69u+tMgZUnE6QZOd3+PoGcZKaRwizZ36zRla3gTMmpv6bzC0giaauMDEVqwLezXHSrRPfOCk60D7B1GXg++TqG9VVFAT2+1GwiWL0x5kODMt1ZK/77NCrlSubn5WXFpfUN6tRmWqz2NBQ4XW12ffgBrns98nzayzVnhdyHaY7hjBj0r60bTBOeI3XTuwFPQZrXEggRaA/OnVfUwbmTPhCEc3vt5iM55IA7UyIsX1axf3QZxH0exTr8cO7zjNhQL0aHjdTkguOZJrOr9sLHsutkWgm+fhH3IVkLDHuQnDXENffuWWPZL64g3grcmtoh0sMgCmOpzWpo0Sh/8C5cNKpoAupf3syt4BuYru5d6L+/gGn7wtpFnXh+clDNDF2MteHiaIFZ4k2xHCZK4X1zRASNCUROX0G540iZFlgHm0l6ZuHvzYcqZjsh47IG0QvIT/PCu2RkY6m8wrT40g+/bcMvK24wKo3lMHQdJYA6ZkwutqJlTDfAk4osMZJWNUKK5s046+M3mfp20xKjWyTk94AlymWl78IuiAXpOBM10br6wiItgJDoRsDzpR6WFOdfpvzFuv0ZpkkiQf+7cAe73iG3lrLjacmNSE8tQsMCACX2O5kAtA7H4aAa2jjco67K2SnhFke3ks+MYem0Qn62Zfl2tu1oPHToyfu/M3TEXrlNYwLJTU5OxkeoI5Q8JoZ8SlI4BsbKvZbECGkJPlFC97OoSHsSECpet3cyJiS9OO8a0YckyUm8/o6h2DCYtEN9d4UOGcKuz/mLwludtoG+V6Ib4jdPnbeYMQiOxQrSvoNpmFoEmWnEV4rz7OjpYogUPjhLi2o/zTzkqDs4MSu/N5n/MqfAD1v7bRoR8a6aqye11k2AAhZL/53nljW6k6F9mw5XCEMVTXhRpkWYeL2XaUfau8eT6OBAw5aLvfgHXlU7UfoqCADV+ySRPddjqH+0vGSsMkD96pm3VoUmFJoFjEBh6lvF5esIQtxb829T/+ojw3qOIgPIUnOlzSTFaPeVGIrgIUEHj8v6tNNMl9nHvIJWczMn5QZ0N05u3TRgKZ0ypbuIwlXJI6KSVZcc8FK5aVwwi7I+DkIDl/jhPFuDGGjYeN+LTSiqj8ktDcSvC46VcsQaZ0VFjv2mWsda/uW1wZo7FHtjyHbSfxFG18qjOrq1ZVZ/oDpBSiXF5t25twunjGqVS2tCja2Nn3hgxKbBFTCYNcOYB7KEptXRRINIGHn+aOuZVROEtmLG3deplsTJEWb0iVIn33KvJyT6rJb+2mwo+jGD1KGJ7Bs1eq4yWNFiKT800DVkO+zOx/Kcevs3fUg+y6h4Pj6D0mZSTNMw/mKv4G/E4NRTYdHNm6syxcPO2LNIYZREmvdgJw0HIHQ+m2G3B9fxN25G4FABRvdqYGNhVvshyRY2HwbP71agRQNalIUiA/iiVuNnWcgB8vpjRmLHF/s36s3MpsaH/G9mzBOX+DtXAgxz3rPjWFEUhuZcUs/FDPbkz+gQMZGUXx+ATpeSH0OBtRfq6mvrX841LqXYAvyNqcSaq3Rjv1iZpv5V/yl7n8K2Ul0+hFT+hd5irXZXQ5A3ApZzYPiraBYfYPuCjLNtqagWQ5iawDLhHn9UNx+uj1dJ5hPrbqNe3TFl2ausoAKWuTglBM1TmE+b/+mDjob3hH9D8RBt11LQmsQqX2nJ+Kh9eeyPDcu9qf2pPJ6h7sPHGRIuktRAPEaDERumSxvUrZB4+NzfhmZt4/xAHwQ3Drz3Xthw3M9Dj7ywbBTr2oMpuxA5Zc+aqm4WM4w9OIL2A4U5px7ZBdO1Tp3n5WgavvBvdXyAl7dEXQisrRd7xNgpTrpTk/9vM15fydoIswhqi7uNxwWb6lUinXzOXF9pb2L+KOBh5E8BZscg0MAWnWEDePGkfhPAO0+mE9a9qPtdj804S9pvqWKde6jFPvZp/8hM/rQYXEAyJjO5myyG9jUkiCgzA8zkkpE8RUhPej/iIRB+DS7OcDoq8jF5V/eZDgJd2FNoeFgL7q3kfwMJTmaGP3Yzs/p7Lpc+Ak6SA4FUp+qwWYxqu8sU6Ap4dkktS2g+1BB9f5IBIOSgs5C6IVcYnuHUHHy2Z4Vtm4UBwcqAYj2uTU8dpv2Ow+UI+BDohj2tt4fWOt7yfA5xGgwwHIRQcRi0LdyhkuaYdaO8S/nSVxUdnCiPBw1Z/7fDniklBNqRGycBLjTgY88yeYYdJtv83EH0PF3qQZkFltbGwjAm3hV0E00PyPJzlkXalLOVO3X8oGgcjotWIPiXvVJcFyyvga7RAZPBrVZ+K0F4rjXDi26M2n4se3iTMXEIG8iGQCoQSrT0Ji7ZfAxazGvCNMP3FYJZkKkclyTmI+C/X3oHmMaaDeBsDAbucNiQmfGLjojDsxJFXsnvBQkGzAAk1ByCrV9wSeRx5T5C4B9v6lMXwTsh8eZhTw4oIfUjD6drzU8OEGKSHC+CEjqcXWM2/KLh/wHuCfE3qCcL9CTm4cqJThPUwpug/A68+r7SLa4t1mmY86tz+yzmCYNkQIfblVQkaz1A0arAfKhXkHccpmp3SPaK37Y1YbAcTASHypdt+0x81ThjvgAvrSUh7jSNRsSwOYMG9HvCYY8ugTNZ8+ybWEjzYZv4bw0fcJXGVdy+m1DKfVofsIXiWs13e3tQKX20JkDx3LtMpBEPoOLJIV694Gsh7OdvO9OV95quHkag5J8fTJC3aYbC1g0oN3/qtplaqMk7JCKqY2nHKay5p7i+04uw5BMwOeL8FRBjVRY++7bN7M86cX5Di1yqfNL6LD3zYecFpTmArWis1hQIbQ7I8zsaKnurV1Rl6MQ+f+e8ff65OkEbLASYL0cvcSeMmSD3c1UL0ksGf0OgVq0RZLf+UOPLKRzNQnic8Pj/N51GzXQbRNlzreEQyVrwkfam/YwyNsMNwBXpBOFn4l23F0A0NCtksrmXMO7tZVy+U8CyfxQI5PbG259EGOwnorJpy/o3lJ+NU9bVAmib8aCeJToPLQTHrLALRsBHWmDTbVUtECWEYnAYcjqUVqh9gh0sY09biP84zE0ve2efsM+X/d9viHs/juuLfFnPQc57hvuUGgOxVUyrZU1fYeiiR6VdyR+9hjFIsMGgf2YpYN+Yl8LeXsUzks6w5+tkxRiJllgWjafwO6EQERDhLQP3DGg7OnjzCKQIkt0Vy3RVett8RQDKySNnd5UOa65vEIJVm2WytjuR6QNzDedl5jpE/e+Ag9d0qO3Pg1Eh08GcOYT489yEvHRG8JywH4qDYcybi1K/OJY5MDRDOcz+K3qzBM6K30lfDlR6jQuaR4QCxMnuaMm8dT8TTtBeOi2v7XFMTSrlyV6x/ZaLejH/PiKiDaqgrbGB7ftJhUr6twEAAdcO8kYnoM7/xKRLjL5h1WiiCw8rNNsz8aS3KMbMs0bsY5LF3tVAIY4BQ5gcgalbzgveyQkJUtgoDDJL9IErLKk49OL7Jpuoc7bIrWYxv93HYxO/HWWnzfJ0pmmbC0VcAiMRtIBRc8uRwSZbcAfkxdICcvx/UJ5OHWIAKIUOTeLR3kMIxf48b9fFH+c7OKgYQDwK/S0ubY5dnB3YRAB6HZKWnVHWU6xxouVJVyXVIAlkIShf6+Ax9OIO6UXcb3gq4zvVBgiAIJEPByA8EnuUKflgrV6/c1apnJ0Z0v83yeZhrgMHVLMZodr34pBgphVva2Cdl+5r6A8DdT39QeSTZD4h3NC84b2VPv5MuBTAO+VVBj9cVsFllInSZRsffonv7tHxllF1eUBxs63oIwTrWLXecHQVxkPqNP9azK765Prj3yVodmGQWZ7AmInDVyK0x9GydBbOoymKIo4Dh0fWz9jtxp6rAbTB4dTLKL9PbdKwbPekm2o6Czmf+lrrl5Z47rNHXsjjYOlujVqDATh5sxAjURm3VabPC6YjqA3W8CVvauoW4bwxLTadF/OhV5WnlvbwnPVL7FnMFH3ICm0f8wKJw+slFRPXgNuvIDygg7O4A6AMn5Xef8O6aLGunuFcMGG0jHxnvBxapSPpgHYz/9Mys1IAQbiUlpCRI4EE1Dh2aPUDPIyRDKy3cNS2L7yl9hlT6xLIVtcklP0MHjD7JschcuXHeXwOlHAUVsf6X6bJC0GbsqxVfjMAoWTTAuzGBSQooyqlN/Y8YgmRWzyHc683kBW+GEOSYzNbTPQ9KLXMUuoE210zRLM8YYRfyqQT68+AfDhpOoy2l8cw2qDxflxA4DISLQ4qXzfG2XFpOGTbUKZoNehi3+lkPZ1U9SRhK36vhCibOjDZbCdCxz3CRweELlSu9Btf87dJEBgRT8Jq3a3FvtqowT43AbN+UNFznFncSZGG/ptBTa+0ynn8ASJZMwQfamj3lKGVYX3wu0jtZMt5rKenH8kPiX8RKq9J5WLP+iL0+l7tuw1dPy4WJbDVLUf2f9OHbF6TmvMOmDdYguPUrBCzvX+iAcAsZ5N4766L10LKb+a8Q9w8cY/OjqSifz5SYp0YbGuhvCyK56hI/Ce4nFKNZEhp0wD5O8IVp9PNpr9KmV0lSv0Hou4NXxVLgiiuuYP1nDa4kz30blfE9fl5f6cMhYvf8ug7ZX3SljDX0Dp/1UxA9L5AoqTjZ1bx3XaGaBvot9d/F7co1rzLwQrfcZBQYQpYxMqyfzqGdh7lIqwWKIfLZPlXUxZ2yowOKTw2i5nDWCWJ1CI322C8i+ODa0yb56C8sJmGXPusQA8mErqkJjbJqGE2gvxFF/i9+hXHR/ygR+Y0WjbTtn+uQa1Ib5pLny7CWPzUDX8NgrNu2VM89HHuignex+4rzmSbA49U3+JfLq7Q5RBgZWQ+OQQ9obl7C54s0olahKyS8/nC7xTgyxoZIjiOEpo7v/nTvgW+HvJ/AdP2wzbZ3elAsshMXmK+AuvNpq8BdigRudtEc/zlKRwiTM2MOUXI7308sJGNJ37LuyyS9pgs07zAWgEOD8VBWIrKGUrs/RfQnj3+tKiKs65ivZhzm5Tkh+Lnmf6oXCAjSZEvIkKNqX1BAt4DHeSyRlLuGrqo3AGj78Qze2SzVh08H46FATsE66rMrKe5T4TcexJAnYCc1arGLt8YWiHsUZPsj02v+bpArE9RwYjZLbgPpEsKJRJRXFj9HB3sC9pMDdvSOSFOu64SxkQaNjzF8DuMsYnusjtzrUbeJ/gGFrOCV2BL/5U0af9MWL3A+D8DZCs9IcdNA2BmS8zkmVj43BMYyHokASZlH2eoWzt8GO4QzcjLiJi/Da6PspBY4PPpRh8VcDPLy2n1FAh49RAlOszMeEvQWSicHBAAwU4yrMTcm0bqNMnALgS3zG3lcUpvX/fEPxF3whAje9T6RTnKD2OBrnP4ct+4JVdR5Wm+/Ky9b6QYgFjnoBC8QodSs228H3mu/hnCaZ9gZguxW/Fvp2WEyLbL4/RF/6WW3nZJqkYjYBN3ZVX1bm4Kez4NsLcoMvPZZ4q8cIgld7r9IQlYLlb97Adl9B/vpIWv+3fdLl+IpXHxKLj5FokYDDgTc+G/uCvHibRc50vap9+RAtuHujkwRFweoRFF3B2TxoQwsbIC80x9zAabm+18RskjIVsAY2rsLo0tF+R927SMhAWS0/UkhOGVDmx1A5VI1C5KEVwypyZCghiYWcEu3B4W4OM1IXAN/7svUj2GOCwnkUa982JOyy6ydiSvzlMYqJNu8YukEZkmNuT1fERBGg8id2Tb8uCcnn/slxLBZ4I2T89uZBzdMCEwmTKzJv+Zzb7+bNh/gwk2MlNdWGviIyPxuHkk5ZhkhOee7OJu4E7boIoCGxghJtJ918FYr46d9Yc8VvxNXjyRDsuTCLhp+snTD3hDNEJ5ShyMoOn1Qwnf/87GIDPRpwkjB1zmHS0remVvdV9DUvEbP/a+Q535L+kSSu/QiElamnYDg5hMyVRp9mHA/EGDotuhocccPNdXAtH7e0knYq5BD7W9wN/hWEJt26P9Sn4n6fRt0+wo8zVk11osG5c9TypRIvGXKhxBLUAYfnasFY2IRB7cc+RfqVB4kubpSeFpHz9SluVGAFqGLguGmtKvbaN5pp+xZSkUIqsHeS6jGeLf1cOSVw/Oxu41pF9iWOEaKF8JPLmq0kZ8StDLRUgD7BmM1XV92Mrk9nNf8AkwIVVhI1tCwNprc0P1mfY6bHBB3wuf9G4ndaNuU8RkWM7mj5Y+7w6RnJUj3OXtdufJMy5mbpiT5YAOpUe/rH3sCwVJVIf/nqiKXX+iFmgGIRalzSZtm30L4B4nY1wrgPHhDqasgo3By5Mf6NUs+lqhZNxm0egRJjIg3+x/3eXe5MPEojLA/NwGyld5/Gb9zlWHoUufzVQO8JyOwlmOuHsKyIGzmwuYuFDoQ++HUgw6vqpIBQy7ZP3KD21F78P/ZjyhV0sHMpTgGx7s6PABsg0bmgrokflMeT5CPxjo/L6OqrdEJLpTrq7RKEqhrK4PrX5BwaXrf1KAuekdznBZkDJz8SaPQyg6XT8fY4zKabUC50YSWEeCvlWlh9vbJGCxmBoAlXhVebR3h+veCfIqhM/BvOY3Yv0R+RjTddGMdC7ye+TQDlD4rEIxkIWxos7Gt6F/FjL6agEVvVYbPNEsQHE9K0V9mHr3geCbMIrWbIHusyrKai7mYOPvVdJSOYu3151y7mIctbm8YtmWAWo8xNl/avCxx8o6HmbnGKaloFv9evEn0DiAlWiVR6icdUCCJprYvAjeZZv120N3O/tlf3sNGiSnj9KC9VjiteNfa7+606X0+Gq0pRUycT4ROmwbd7q+u3rMEjDmAzyhRfPlmFG3mvK5lwkhMPaAGEJS8RMwab6Pw6fHAdSEj/nwu77SWTC1unhIVdojLnyGQAhKbwxFjM10CG/r0T9MoNNgoN3e7ki/l6o/Uk3LHwXT09jYlbpQWPYmx2/OSBHqTa7uWm7Prum346Atfgq4c0+C8PQUht4C397Q3t2itZYcxG3g1y5wbcw="}, {"check": "c76d37f3f1dcfbd985e2ddf1b44b88600fee346bc81582e56ec5d8a242c33e84", "nonce": "e230e42e326975d773af485ec32e4d5d", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "365acd0988810ad33594eed9fd9990d3c1481c9105d567dfe24da793775f91f6", "nonce": "c0e049bb1217d1b948e47e2d585a3b17", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "7955ff00a59986930d21d6c9887675844502597c4134476c6678068984b0de7e", "nonce": "f3ba59eb597ef9ae78336b6c81f12eef", "chance": 1, "cooldown_days": 0.5, "data": "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"}, {"check": "f59f248775a9b0e23a5faa9df8b9a1fd235c042a0ca740389cf9ea20390e27a6", "nonce": "79673994b3da6dadcfaec03ec417722a", "chance": 1, "cooldown_days": 300, "data": "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"}, {"check": "7b05f7478511791890601b3146d9d3f71deed8f03df0e69113b88b8d6365b3e4", "nonce": "f3ce40cf6c44f97e78efbdb318277bf5", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "f9a416230394e1b21405377d5e13fb48f2d6455d8c7ffb292ea6aa2eef94d12e", "nonce": "06f98df7c4dd859cb7e2f7bec51411c3", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "2fbbf11995e01766646d5bee295e8ece3d58cad5e6c7406aeb14319d6bbb8478", "nonce": "2bb4e2624cd651c24e65ee0016fa911c", "chance": 1, "cooldown_days": 84, "data": "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"}, {"check": "9b2cb1554313d60da1ada48790d998ee2bed5721e7a02f4e44582e762eab4e2e", "nonce": "003d1bbab6e620a73baa7773cd7cfd22", "chance": 1, "cooldown_days": 28, "data": "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"}, {"check": "1ec88be301b0698366372507163d19b86d4973c2578ed762bfce6e04e856be42", "nonce": "15a09be4b13c27af88fe2c1b3b6b0155", "chance": 1, "cooldown_days": 84, "data": "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"}, {"check": "e190d601d06ae894495e2f6bfb9c2e2cfeeaf10c2aaae194b00551749a131e55", "nonce": "63d7d3fbe451725d42018139e6d75fdf", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "17dae0df1b40614824793a83c36ea2b29957c74804e7d1af13c25c3512f35b4a", "nonce": "2c967112ec2469d927050a910250ccfb", "chance": 1, "cooldown_days": 84, "data": "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"}, {"check": "a9be1dae63000503540144ea7487ca30ac37b0e9b93a519aea17daf899917dbc", "nonce": "ace4584f6bc10bd19db2d72793d2e4fe", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "d6656c04959ac84fe4c9fd149bd40e2e739134c421b049a825944a1709e7f9ce", "nonce": "55950c335016d2205e96399e5861f0e8", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "efe826973788ae263c4624c925c11646d0502cb9b36a0cf52c1f747198b15aeb", "nonce": "4e6e2a69f30a83bcbba10d2eb936c486", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "393a1473958ae5038f5242498a9abc9e3ff163665eea00eaf17ed8a8ed0dd14b", "nonce": "f135d871c1538864f0147f2143895cf6", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "ed213062ace46e0ccb91ab46e70dc481e6e354a3b94c055690ef8552159abd4a", "nonce": "8e1e1ce49b1f854049f8195980e3a9ee", "chance": 1, "cooldown_days": 0.041666666666666664, "data": "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"}, {"check": "019a682beb038d01c357b9650a29829decbc94ce45598bab730f5f533a3ea2d2", "nonce": "58052a0f3edcd2fa38c9fc719142ae25", "chance": 1, "cooldown_days": 300, "data": "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"}, {"check": "12b39534078f774cc22aabea89767d1ffb861f252cc72d004b56a978698e5e53", "nonce": "6428399d6074ef24c535c86819afde3c", "chance": 0.5, "cooldown_days": 3, "data": "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"}, {"check": "caa75b7bf1bad9a935548fcc2560d608269ffbbf34ee7eef6603d11491fa76ee", "nonce": "8b70f42c84d480f7fae2c54f34657f2e", "chance": 0.5, "cooldown_days": 14, "data": "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"}, {"check": "d01adcc7b820ea692afe7c496793ec1fc09bf50d52491f524c07ec64ec355710", "nonce": "0d2e2fbaafe1846d0eaaa020ab6afa6e", "chance": 0.5, "cooldown_days": 14, "data": "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"}]}\ No newline at end of filediff --git a/token_tv/assets/grok-pixel.png b/token_tv/assets/grok-pixel.pngindex 4176c1e..fcf2fd1 100644Binary files a/token_tv/assets/grok-pixel.png and b/token_tv/assets/grok-pixel.png differdiff --git a/token_tv/bridge.py b/token_tv/bridge.pyindex 11ffeac..988d771 100644--- a/token_tv/bridge.py+++ b/token_tv/bridge.py@@ -6,7 +6,7 @@ import subprocessimport timefrom token_tv.sources import load_config-from token_tv.state import UsageStore+from token_tv.state import MIN_FETCH_SECONDS, UsageStoreREMOTE_WRITE = """import json,os,pathlib,sysp=pathlib.Path(sys.argv[1]).expanduser()@@ -28,7 +28,7 @@ def main():if args.ssh_host.startswith("-"):parser.error("A host name is required")config = load_config(args.config)- store = UsageStore(config["accounts"])+ store = UsageStore(config["accounts"], min_fetch_seconds=MIN_FETCH_SECONDS)while True:try:store.refresh()@@ -40,7 +40,7 @@ def main():print("TokenTV normalized account snapshot delivered.", flush=True)except (OSError, subprocess.SubprocessError):print("TokenTV bridge unavailable; display will mark stale.", flush=True)- time.sleep(max(60, int(config.get("poll_seconds", 300))))+ time.sleep(max(60, int(config.get("poll_seconds", 60))))if __name__ == "__main__":diff --git a/token_tv/cli.py b/token_tv/cli.pyindex 60848bb..f6506cd 100644--- a/token_tv/cli.py+++ b/token_tv/cli.py@@ -113,7 +113,7 @@ def setup(args):except ValueError as error:print(error, file=sys.stderr)return 1- config = {'poll_seconds': 300, 'accounts': accounts, 'display_style': 'digital'}+ config = {'poll_seconds': 60, 'accounts': accounts, 'display_style': 'digital'}if device:config['device_url'] = devicetry:@@ -271,7 +271,7 @@ def start(args):except ValueError as error:print(error, file=sys.stderr)return 1- config = {'poll_seconds': 300, 'accounts': accounts, 'display_style': 'digital'}+ config = {'poll_seconds': 60, 'accounts': accounts, 'display_style': 'digital'}if device:config['device_url'] = devicepath.parent.mkdir(parents=True, exist_ok=True)diff --git a/token_tv/device.py b/token_tv/device.pyindex 301a816..ff4d393 100644--- a/token_tv/device.py+++ b/token_tv/device.py@@ -1,5 +1,6 @@"""Confirmed SD_PRO photo API, plus the SmallTV-Ultra image API. Never flash or delete existing photographs."""import json+import timeimport uuidfrom http.client import HTTPExceptionfrom urllib.error import HTTPError@@ -8,9 +9,16 @@ from urllib.request import Request, urlopenFILES = ("tokentv.jpg", "tokentv.gif")+# An animated face goes to one of these in turn, never to the one playing: a GIF written over while the clock reads+# it can leave the clock stuck on a broken file. A third keeps a picture that comes back (a resting pet's look round+# and its still minutes) on the clock, so coming back is a switch, not a send.+SLOTS = ("tokentv.gif", "tokentv-b.gif", "tokentv-c.gif")# The album page accepts GIFs up to 240×240; keep both well under the free space.-LIMITS = {"tokentv.jpg": (60000, "image/jpeg"), "tokentv.gif": (400000, "image/gif")}+LIMITS = {"tokentv.jpg": (60000, "image/jpeg"), **{name: (400000, "image/gif") for name in SLOTS}}LEGACY_FILES = ("tokentv-c.jpg", "tokentv-m.jpg")+ROOM = 300000 # bytes of the clock's space a third slot leaves free, for the owner's own photos+MARGIN = 30000 # and any slot, for the clock's own files+LIST_SECONDS = 600 # how long the clock's file list is trusted without reading it againMODEL_NAMES = {"sdpro": "an SD_PRO", "ultra": "a SmallTV-Ultra"}@@ -20,12 +28,20 @@ class BackupMismatch(ValueError):class PhotoDisplay:MODEL = "sdpro"+ SLOTS = SLOTSdef __init__(self, base_url):parsed = urlparse(base_url)if parsed.scheme != "http" or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.path not in ("", "/"):raise ValueError("A plain local display URL is required")self.base_url = base_url.rstrip("/")+ self.active = None # the file this clock was last set to show+ self.enabled = set() # the album's enabled files, likewise+ self.sizes = None # file -> bytes on the clock, as last listed and since sent+ self.free = 0 # bytes free on the clock, likewise+ self.listed_at = 0 # when the list was last read+ self.held = {} # slot -> (sha256, bytes) of the GIF put there and seen to arrive whole+ self.last_used = {} # slot -> when it was last shown, so the one longest unused is written nextdef request(self, path, data=None, headers=None):with urlopen(Request(self.base_url + path, data=data, headers=headers or {}), timeout=20) as response:@@ -61,6 +77,88 @@ class PhotoDisplay:{"Content-Type": "multipart/form-data; boundary=" + boundary})return {"file": name, "status": status, "bytes": len(image)}+ def listed(self):+ """The album as the clock lists it now: its sizes, free space and enabled files."""+ _, raw = self.request("/photo/list")+ listing = json.loads(raw)+ self.enabled = {f["name"] for f in listing["files"] if f.get("enabled")}+ self.sizes = {f["name"]: f.get("size") for f in listing["files"]}+ self.free = listing.get("total", float("inf")) - listing.get("used", 0)+ self.listed_at = time.monotonic()+ if self.enabled != {self.active}: # not what we left on (a lost answer, the owner's own pick): activate in full+ self.active = None+ for slot, (_, size) in list(self.held.items()):+ if self.sizes.get(slot) != size: # gone or changed on the clock since+ del self.held[slot]+ return self.sizes++ def put(self, name, image, digest):+ """Get a picture onto the clock without changing what it shows; returns the file that has it and receipts+ for what was sent. An animated face never goes to an enabled GIF: it goes to another slot, so a send cut+ short is never what the clock is playing.++ The clock plays and answers on one core, so every request holds the animation. Its list is therefore kept+ and read again only every LIST_SECONDS, after anything failed, and after a send to a clock low on space,+ where a send could be kept short of whole; between, the sizes and free space follow our own sends."""+ if name not in self.SLOTS:+ return name, [dict(self.upload(name, image), sha256=digest)]+ if self.sizes is None or time.monotonic() - self.listed_at > LIST_SECONDS:+ self.listed()+ slot = next((s for s, held in self.held.items() if held[0] == digest), None)+ if slot is not None:+ return slot, []+ ours = [s for s in self.SLOTS if s in self.enabled]+ for extra in ours[1:]: # more than one of ours on, after a lost answer: keep one, so another is free to write+ self.toggle("photo", "name", extra, False)+ self.enabled.discard(extra)+ playing = self.enabled | {self.active}+ # The clock may keep the old copy until the new one is whole, so a slot needs room for all of it; the+ # third slot is used only while the owner's photos keep plenty of room.+ fits = [s for s in self.SLOTS if s not in playing+ and self.free - len(image) >= (MARGIN if s in self.SLOTS[:2] else ROOM)]+ # A clock too full for a second slot: write over the one shown, as before slots.+ slot = (min(fits, key=lambda s: self.last_used.get(s, 0)) if fits+ else next((s for s in self.SLOTS if s in self.enabled), None)+ or (self.active if self.active in self.SLOTS else self.SLOTS[0]))+ self.held.pop(slot, None)+ try:+ receipts = [dict(self.upload(slot, image), sha256=digest)]+ except Exception:+ self.sizes = None # what the slot has now is unknown: list it again before the next send+ raise+ if self.free - len(image) < ROOM:+ if self.listed().get(slot) != len(image):+ raise ValueError("The clock did not keep the whole picture")+ else:+ self.free -= len(image) - (self.sizes.get(slot) or 0)+ self.sizes[slot] = len(image)+ self.held[slot] = (digest, len(image))+ return slot, receipts++ def select(self, original, name):+ """Make `name` the one picture the clock shows: between slots two toggles, else the full activation. If+ anything fails, what the clock has enabled is unknown: the next change lists it and activates in full."""+ try:+ if self.active in self.SLOTS and name in self.SLOTS and self.active != name:+ self.toggle("photo", "name", name, True) # the new one on before the old one off: never empty+ self.enabled.add(name)+ self.toggle("photo", "name", self.active, False)+ self.enabled.discard(self.active)+ elif self.active != name:+ self.activate(original, name)+ self.enabled = {name}+ except Exception: # an answer lost or cut short included+ self.active, self.sizes = None, None+ raise+ self.active = name+ self.last_used[name] = time.monotonic()++ def show(self, original, name, image, digest):+ """Put a picture on the clock and make it the one shown; returns receipts for what was sent."""+ name, receipts = self.put(name, image, digest)+ self.select(original, name)+ return receipts+def toggle(self, category, key, value, enabled):self.request("/" + category + "/toggle?" + urlencode({key: value, "state": int(enabled)}, quote_via=quote))@@ -86,7 +184,7 @@ class PhotoDisplay:self.toggle("photo", "name", f["name"], f["enabled"])_, raw = self.request("/photo/list")present = {f["name"] for f in json.loads(raw)["files"]}- for name in FILES + LEGACY_FILES:+ for name in FILES + SLOTS + LEGACY_FILES:if name in present and not any(f["name"] == name for f in original["files"]):self.toggle("photo", "name", name, False)self.request("/photo/interval?val=" + str(original["photo_interval"]))@@ -101,6 +199,7 @@ class UltraDisplay(PhotoDisplay):"""SmallTV-Ultra (Ultra-V9) image API, read from the clock's own image.html and settings.html."""MODEL = "ultra"PHOTO_THEME = 3+ SLOTS = () # untried on this clock: one file, as beforedef capture(self):# A new clock has no /app.json (404) until its theme is first changed: there is no saved theme to restore.diff --git a/token_tv/display.py b/token_tv/display.pyindex a4c77d4..c6aa138 100644--- a/token_tv/display.py+++ b/token_tv/display.py@@ -19,16 +19,20 @@ TEXT = '#d9dde1'MUTED = TEXTTRACK = '#28313a'RULE = '#202730'-PROVIDER_INK = {'claude': '#d68e68', 'codex': '#a799e5', 'grok': '#cbd1d7'}-ICON_PAPER = PROVIDER_INK['grok']+OLD_INK = '#e0a860' # an old reading's label, so it never looks fresh+PROVIDER_INK = {'claude': '#d68e68', 'codex': '#a799e5', 'grok': '#cbd1d7', 'copilot': '#3fb6e8', 'antigravity': '#78b6ee'}+# Each service's own colour, the source for every new style (older faces keep their tuned accents):+# Claude orange, Codex navy with a light lavender, Grok white, Copilot a teal-to-blue gradient.+BRAND = {'claude': ('#d97757',), 'codex': ('#2f3aa8', '#9aa0ff'), 'grok': ('#f2f4f8',),+ 'copilot': ('#36d8b4', '#1fa7e2', '#2563eb'), 'antigravity': ('#e77345', '#94c45f', '#4f83f2')}FONT_MAIN = '/usr/share/fonts/truetype/dejavu/DejaVuSans'FONT_NUMBERS = '/usr/share/fonts/truetype/dejavu/DejaVuSansMono'-STYLES = ('pixel', 'digital', 'neon', 'retro', 'hud', 'space', 'gameboy', 'retro-dual')+STYLES = ('pixel', 'digital', 'neon', 'retro', 'hud', 'space', 'gameboy', 'arcade', 'retro-dual')# Gauge-only levels; labels/percentages always use TEXT, logos retain provider ink.GAUGE_LEVELS = ((50, '#76a99a'), (80, '#93c9b9'), (90, '#d1b275'), (101, '#d8877e'))STATUS = {'loading': 'WAIT', 'auth_required': 'LOGIN', 'identity_mismatch': 'CHECK','quota_unavailable': 'NO DATA', 'error': 'ERROR', 'rate_limited': 'RETRY', 'stale': 'OLD'}-PROVIDERS = ('claude', 'codex', 'grok')+PROVIDERS = ('claude', 'codex', 'grok', 'copilot', 'antigravity')ASSETS = Path(__file__).with_name('assets')@@ -43,20 +47,66 @@ def font(size, bold=False, mono=False):return ImageFont.load_default()+MAX_ROWS = 4 # four rows still read on a 240 px screen; Arcade takes turns on any number+++def has_reading(row):+ return row['status'] in ('ok', 'stale') and bool(row['windows'])++def overview_rows(snapshot):- """Select one visible account per provider, in configured order, without merging quotas."""- rows = []- # Show only the services this person set up; with no accounts at all, keep every placeholder row.- present = [p for p in PROVIDERS if any(row['provider'] == p for row in snapshot['accounts'].values())]- for provider in present or PROVIDERS:- accounts = [dict(row, key=key) for key, row in snapshot['accounts'].items()- if row['provider'] == provider]- available = [row for row in accounts if row['status'] == 'ok' and row['windows']]- previous = [row for row in accounts if row['status'] == 'stale' and row['windows']]- rows.append((available or previous or accounts or [- {'key': provider, 'provider': provider, 'alias': provider.upper() + ' A',- 'status': 'auth_required', 'windows': []}])[0])- return rows[:3] # every clock face is laid out for at most three rows+ """Each account gets its own row, at most four: working ones first, then the fullest, then setup order.++ The chosen rows keep service order (Claude, Codex, Grok) and setup order within a service, so a row+ does not jump about when another account's usage passes it. Accounts without a reading only fill+ rows that are left. With no accounts at all, every service keeps a placeholder row.+ """+ accounts = [dict(row, key=key) for key, row in snapshot['accounts'].items()]+ if not accounts:+ return [{'key': p, 'provider': p, 'alias': p.upper() + ' A', 'status': 'auth_required', 'windows': []}+ for p in PROVIDERS]++ def rank(i):+ row = accounts[i]+ value = primary_window(row) if has_reading(row) else None+ return (not has_reading(row), not row.get('active'), -(value['used_percent'] if value else -1), i)++ def service(i):+ provider = accounts[i]['provider']+ return PROVIDERS.index(provider) if provider in PROVIDERS else len(PROVIDERS)++ chosen = sorted(range(len(accounts)), key=rank)[:MAX_ROWS]+ return [accounts[i] for i in sorted(chosen, key=lambda i: (service(i), i))]+++class Slot:+ """One row's place: its top, its height, and how far its type grows for one to four rows.++ `at(v)` maps an offset drawn for the three-row height to this row; `num` and `txt` scale the big+ numbers and the smaller labels, so three rows look exactly as they always did.+ """+ GROW = {1: (2.0, 1.4, 1.8), 2: (1.4, 1.15, 1.3), 3: (1.0, 1.0, 1.0), 4: (.8, .95, .75)}++ def __init__(self, y, h, count, base):+ self.y, self.h, self.count, self.k = y, h, count, h / base+ self.big, self.small, self.icon = self.GROW[count]++ def at(self, v):+ return self.y + round(v * self.k)++ def num(self, size):+ return max(6, round(size * self.big))++ def txt(self, size):+ return max(6, round(size * self.small))+++def slots(count, top=3, pitch=79, height=76):+ """Row places for `count` rows (one to four) over the span three rows of `height` every `pitch` take."""+ count = max(1, min(MAX_ROWS, count))+ gap = pitch - height+ h = (2 * pitch + height - (count - 1) * gap) / count+ return [Slot(round(top + i * (h + gap)), round(h), count, height) for i in range(count)]def row_shift(count, pitch):@@ -81,20 +131,20 @@ def time_left(reset):return str(minutes // 60) + 'h ' + str(minutes % 60) + 'm'-def mascot(image, provider, xy, pixel=False, size=40):+def mascot(image, provider, xy, pixel=False, size=40, box=48):path = ASSETS / (provider + '-pixel.png')if path.is_file():with Image.open(path) as original:icon = original.convert('RGBA')- box = icon.getbbox()- if box:- icon = icon.crop(box)+ bounds = icon.getbbox()+ if bounds:+ icon = icon.crop(bounds)scale = (size / 2 if pixel else size) / max(icon.size)icon = icon.resize((round(icon.width * scale), round(icon.height * scale)), Image.Resampling.NEAREST)if pixel:icon = icon.resize((icon.width * 2, icon.height * 2), Image.Resampling.NEAREST)x, y = xy- image.paste(icon, (x + (48 - icon.width) // 2, y + (48 - icon.height) // 2), icon)+ image.paste(icon, (x + (box - icon.width) // 2, y + (box - icon.height) // 2), icon)else:ImageDraw.Draw(image).text((xy[0]+16, xy[1]+12), provider[0].upper(), font=font(22, True), fill=PROVIDER_INK[provider])@@ -125,18 +175,46 @@ def horizontal_gauge(draw, xy, used, step=16, width=14, height=4, rounded=False,draw.rectangle(box, fill=color)+SHORT_NAME = {'antigravity': 'ANTI'} # names too long for a clock's header+OLD_NAMES = {'antigravity': ('ANTIGRAVITY ', 'GEMINI ')} # aliases from before Google's pet was Anti++def account_label(row):- prefix = row['provider'].upper() + ' '- return row['alias'] if row['alias'].startswith(prefix) else prefix + 'A'+ """The account's name on the clock: its service's name and its own letter ('CLAUDE B'), whatever the alias."""+ name = SHORT_NAME.get(row['provider'], row['provider'].upper())+ alias = row['alias']+ for old in OLD_NAMES.get(row['provider'], ()):+ if alias.startswith(old):+ alias = name + ' ' + alias[len(old):]+ return alias if alias.startswith(name + ' ') else name + ' A'def quota_period(value):- return {'WEEK': 'WK', 'BUDGET': 'BUD'}.get(value['label'], value['label'])+ return {'WEEK': 'WK', 'BUDGET': 'BUD', 'MONTH': 'MO', 'DAY': 'DAY'}.get(value['label'], value['label'])-def reading(row):- """(used %, window label, old?, time left) for one account; used is None when nothing was reported."""+def shown_windows(row, count):+ """The windows a row shows: 5H and WEEK together while there is room (one or two rows), else WEEK.++ An account without a weekly window shows its fullest one; with no windows the list is empty.+ """+ by_label = {w['label']: w for w in row['windows']}+ if count <= 2 and '5H' in by_label and 'WEEK' in by_label:+ return [by_label['5H'], by_label['WEEK']]+ if 'WEEK' in by_label:+ return [by_label['WEEK']]value = primary_window(row)+ return [value] if value else []+++FULLEST = object()+++def reading(row, value=FULLEST):+ """(used %, window label, old?, time left) for one window (the fullest by default); used is None when+ nothing was reported."""+ if value is FULLEST:+ value = primary_window(row)used = max(0, min(100, value['used_percent'])) if value else Noneperiod = quota_period(value) if value else STATUS.get(row['status'], 'NO DATA')old = bool(value) and row['status'] != 'ok'@@ -209,16 +287,50 @@ PIXEL_GLYPHS = {'%': '11001/11010/00010/00100/01000/01011/10011','-': '00000/00000/00000/11111/00000/00000/00000','?': '01110/10001/00001/00010/00100/00000/00100',+ '.': '00000/00000/00000/00000/00000/01100/01100',+ '!': '00100/00100/00100/00100/00100/00000/00100',+ ':': '00000/01100/01100/00000/01100/01100/00000',' ': '00000/00000/00000/00000/00000/00000/00000',}+def without_service(text):+ """An account name without its leading service word ('COPILOT TEAM' → 'TEAM'): the mascot already+ says which service it is, so this is what to keep when space runs out."""+ first, _, rest = str(text).partition(' ')+ return rest if rest and first.lower() in PROVIDERS else text+++def fit_pixel(text, scale, width):+ """`text` in the 5×7 font, cut to `width` px: first without its service word, then with '..'."""+ text = str(text).upper()+ for option in (text, without_service(text)):+ if (len(option) * 6 - 1) * scale <= width:+ return option+ text = without_service(text)+ keep = max(1, (width // scale + 1) // 6 - 2)+ return text[:keep].rstrip() + '..'+++def fit_text(draw, text, font, width):+ """`text` in a TrueType `font`, cut to `width` px: first without its service word, then with '..'."""+ for option in (text, without_service(text)):+ if draw.textlength(option, font=font) <= width:+ return option+ text = without_service(text)+ while text and draw.textlength(text.rstrip() + '..', font=font) > width:+ text = text[:-1]+ return text.rstrip() + '..'++def pixel_text(draw, xy, text, scale=1, color=TEXT, align='left'):text = str(text).upper()width = max(0, len(text) * 6 - 1) * scalex, y = xyif align == 'right':x -= width+ elif align == 'center':+ x -= width // 2for index, character in enumerate(text):pattern = PIXEL_GLYPHS.get(character, PIXEL_GLYPHS['?']).split('/')for yy, line in enumerate(pattern):@@ -229,40 +341,87 @@ def pixel_text(draw, xy, text, scale=1, color=TEXT, align='left'):draw.rectangle((px, py, px + scale - 1, py + scale - 1), fill=color)+def pixel_window_lines(draw, row, wins, box, scale):+ """Both windows (5H above WEEK) in a roomy Pixel row: name, number, reset and a gauge each."""+ x0, y0, x1, y1 = box+ line = (y1 - y0) / len(wins)+ for i, value in enumerate(wins):+ used, period, old, reset = reading(row, value)+ top = round(y0 + i * line)+ small = 2 if scale >= 4 else 1+ mid = top + (line - 10) / 2 - 7 * scale / 2+ name = period + (' OLD' if old else '')+ pixel_text(draw, (x0, round(mid + 7 * (scale - small) / 2)), name, scale=small, color=OLD_INK if old else MUTED)+ nx = x0 + (len(name) * 6 + 2) * small+ number = '--' if used is None else f'{round(used)}%'+ pixel_text(draw, (nx, round(mid)), number, scale=scale, color=MUTED if old else TEXT)+ pixel_text(draw, (x1, round(mid + 7 * (scale - small) / 2)), reset.replace(' ', ''), scale=small, color=MUTED,+ align='right')+ step = (x1 - x0) // 10+ horizontal_gauge(draw, (x0, round(top + line - 8)), used, step=step, width=step - 2, height=4 if scale >= 4 else 3)++def render_pixel(snapshot):image = Image.new('RGB', (240, 240), BACKGROUND)draw = ImageDraw.Draw(image)rows = overview_rows(snapshot)- for index, row in enumerate(rows):- y = 8 + index * 78 + row_shift(len(rows), 78)+ for index, (sl, row) in enumerate(zip(slots(len(rows), top=8, pitch=78, height=72), rows)):+ y, at, hero = sl.y, sl.at, sl.count == 1if index:for x in range(14, 227, 4):draw.point((x, y - 6), fill=RULE)- if row['provider'] == 'grok':- disc = Image.new('RGB', (24, 24), BACKGROUND)- ImageDraw.Draw(disc).ellipse((1, 1, 22, 22), fill=ICON_PAPER)- image.paste(disc.resize((48, 48), Image.Resampling.NEAREST), (14, y + 10))- mascot(image, row['provider'], (14, y + 10), pixel=True)+ box = round(48 * sl.icon)+ mx, my = 14, (y + 6 if hero else at(10))+ if row['provider'] == 'grok': # white with dark eyes, as on every full-colour face+ from token_tv.themes import bot_sprite+ half = round(20 * sl.icon)+ art = bot_sprite('grok', half, half, '#f2f4f8', (12, 14, 20))+ art = art.resize((art.width * 2, art.height * 2), Image.Resampling.NEAREST)+ image.paste(art, (mx + (box - art.width) // 2, my + (box - art.height) // 2), art)+ else:+ mascot(image, row['provider'], (mx, my), pixel=True, size=round(40 * sl.icon), box=box)label = row['alias']if not label.startswith(row['provider'].upper() + ' '):label = row['provider'].upper() + ' A'- pixel_text(draw, (68, y + 3), label)- value = primary_window(row)+ wins = shown_windows(row, sl.count) # 5H and WEEK on roomy rows, else the weekly one+ value = wins[0] if wins else Noneused = max(0, min(100, value['used_percent'])) if value else None- old = row['status'] != 'ok'+ old = bool(value) and row['status'] != 'ok'number = '--' if used is None else str(round(used)) + '%'- pixel_text(draw, (68, y + 21), number, scale=3, color=TEXT)- if value:- period = {'WEEK': 'WK', 'BUDGET': 'BUD'}.get(value['label'], value['label'])- pixel_text(draw, (226, y + 3), period + (' OLD' if old else ' USED'), color=MUTED, align='right')- pixel_text(draw, (226, y + 25), time_left(value.get('resets_at')).replace(' ', ''), scale=2, color=MUTED, align='right')- else:- pixel_text(draw, (226, y + 25), STATUS.get(row['status'], 'NO DATA'), color=MUTED, align='right')- horizontal_gauge(draw, (68, y + 52), used)+ tx = mx + box + 6+ n = max(2, round(3 * sl.big))+ r = 3 if hero else 2+ period = quota_period(value) if value else ''+ reset = time_left(value.get('resets_at')).replace(' ', '') if value else STATUS.get(row['status'], 'NO DATA')+ if len(wins) == 2: # room for both windows: 5H above WEEK+ pixel_text(draw, (tx, y + 14 if hero else at(3)), fit_pixel(label, 2, 226 - tx), scale=2)+ body = (14, my + box + 10, 226, y + sl.h - 4) if hero else (tx, at(3) + 20, 226, y + sl.h - 4)+ pixel_window_lines(draw, row, wins, body, 4 if hero else 3)+ continue+ if hero: # one account: the bot and its name on top, a big number below, the reset under it+ pixel_text(draw, (tx, y + 14), fit_pixel(label, 2, 226 - tx), scale=2)+ if value:+ pixel_text(draw, (tx, y + 40), period + (' OLD' if old else ' USED'), color=MUTED)+ top = my + box + 14+ pixel_text(draw, (14, top), number, scale=n, color=TEXT)+ pixel_text(draw, (226, top + 7 * n + 12), reset, scale=r, color=MUTED, align='right')+ horizontal_gauge(draw, (14, y + sl.h - 16), used, step=21, width=19, height=8)+ continue+ note = ('OLD' if old else '') if sl.count == 4 else period + (' OLD' if old else ' USED') if value else ''+ size = 2 if sl.count == 2 else 1+ room = 226 - tx - ((len(note) * 6 - 1) + 6 if note else 0)+ pixel_text(draw, (tx, at(3)), fit_pixel(label, size, room), scale=size)+ pixel_text(draw, (tx, at(21)), number, scale=n, color=TEXT)+ if note:+ pixel_text(draw, (226, at(3)), note, color=OLD_INK if old else MUTED, align='right')+ pixel_text(draw, (226, at(25)), reset, scale=r if value else 1, color=MUTED, align='right')+ step = (226 - tx) // 10+ horizontal_gauge(draw, (tx, at(52)), used, step=step, width=step - 2,+ height=max(3, round(4 * sl.small)))return image-def render_page(snapshot, page=0, style='pixel'):+def render_page(snapshot, page=0, style='pixel', egg=None):# Keep the former second-frame URL usable while publishing only one LCD image.if page not in (0, 1):raise IndexError('Unknown frame')@@ -271,6 +430,9 @@ def render_page(snapshot, page=0, style='pixel'):if style == 'space': # animated: returns GIF bytesfrom token_tv.space import render_spacereturn render_space(snapshot)+ if style == 'arcade': # animated: the mascots act while their account is in use+ from token_tv.arcade import render_arcade+ return render_arcade(snapshot, egg=egg)from token_tv.themes import RENDERERSrenderer = {'pixel': render_pixel, **RENDERERS}[style]image = renderer(snapshot)@@ -363,7 +525,7 @@ const container=document.querySelector('#accounts');container.replaceChildren();for(const provider of ['claude','codex','grok']){const group=el('section',undefined,'group');group.dataset.provider=provider;group.append(el('h2',provider.toUpperCase()));Object.values(data.accounts).filter(a=>a.provider===provider).forEach(a=>{const c=el('article',undefined,'card');const head=el('div',undefined,'cardhead');head.append(el('span',a.alias,'name'),el('span',labels[a.status]||a.status,'status'));c.append(head);a.windows.forEach(w=>{const row=el('div',undefined,'window');const bar=el('div',undefined,'usage-meter');const used=Math.max(0,Math.min(100,w.used_percent));bar.dataset.level=used<50?'low':used<80?'medium':used<90?'high':'critical';bar.setAttribute('role','meter');bar.setAttribute('aria-label','Used quota');bar.setAttribute('aria-valuemin','0');bar.setAttribute('aria-valuemax','100');bar.setAttribute('aria-valuenow',String(used));const fill=el('span',undefined,'usage-fill');fill.style.width=used+'%';bar.append(fill);row.append(el('span',w.label),bar,el('span',Math.round(w.used_percent)+'%'),el('span',reset(w.resets_at)));c.append(row)});-if(a.source==='laptop')c.append(el('div','Laptop link · 5 min refresh','note'));+if(a.source==='laptop')c.append(el('div','Laptop link · 1 min refresh','note'));if(a.fetched_at)c.append(el('div','Checked '+new Date(a.fetched_at*1000).toLocaleTimeString('en-GB'),'note'));if(a.status==='stale'&&a.last_success_at)c.append(el('div','Last success: '+new Date(a.last_success_at*1000).toLocaleString('en-US'),'note'));group.append(c)});container.append(group)}diff --git a/token_tv/events.py b/token_tv/events.pynew file mode 100644index 0000000..ba6b61f--- /dev/null+++ b/token_tv/events.py@@ -0,0 +1,233 @@+"""The one-offs everyone may read about: fireworks when a window resets (or a saved reset is spent),+a flop when one runs out. Not random: the live loop plays one when the store sees it happen, for the+account it happened to. The rarer, hidden one-offs ship only as locked boxes (`lockbox.py`)."""+import math++from token_tv import arcade+from token_tv.arcade import paste, place_clawd+from token_tv.display import pixel_text+++def timeline(f, parts):+ """The (sprite, frame) playing at `f` from a list of (sprite, first, last) clips at 12 fps; after the+ last clip its final pose is held, so the key moment lingers."""+ for name, first, last in parts:+ length = last - first + 1+ if f < length:+ return name, first + f+ f -= length+ name, _, last = parts[-1]+ return name, last+++def clawd_ground(frame, draw, box, f, s):+ x, y, w, h = box+ ground, *_ = arcade.claude_backdrop(frame, draw, box, f, s, False, pit=False)+ return ground, x + round(w * .3)+++def codex_place(box, s):+ x, y, w, h = box+ cw, ch = arcade.codex_art(s).size+ return x + round(w * .5), y + max(2, round(h * .05)) + ch // 2, cw, ch+++SPARKS = ((255, 214, 107), (255, 255, 255), (255, 128, 150), (120, 220, 255), (150, 240, 170))+SWEAT = (140, 200, 255)+++def fireworks(draw, box, f, s, colors=None):+ """Five rockets rise and burst over the scene one after another: a flash, streaks, falling sparks."""+ colors = colors or SPARKS+ x, y, w, h = box+ for n, (start, fx, fy) in enumerate(((2, .22, .24), (20, .72, .18), (38, .48, .3), (58, .82, .26), (78, .3, .16))):+ t = f - start+ cx, cy = x + round(w * fx), y + round(h * fy)+ if 0 <= t < 5: # the rising spark+ draw.rectangle((cx, cy + (5 - t) * 5 * s, cx + s - 1, cy + (5 - t) * 5 * s + 3 * s), fill=colors[0])+ elif t == 5: # the flash+ draw.ellipse((cx - 3 * s, cy - 3 * s, cx + 3 * s, cy + 3 * s), fill=(255, 255, 240))+ elif 5 < t < 24:+ r = (t - 5) * 2.4 * s+ fall = (t - 5) ** 2 * .06 * s+ for k in range(16):+ a = math.radians(k * 22.5 + n * 9)+ color = colors[(k + n) % len(colors)]+ if t > 16:+ color = tuple(c * 2 // 3 for c in color)+ ex, ey = cx + math.cos(a) * r, cy + math.sin(a) * r + fall+ if t < 13: # a streak behind each spark+ bx, by = cx + math.cos(a) * (r - 3 * s), cy + math.sin(a) * (r - 3 * s) + fall+ draw.line((round(bx), round(by), round(ex), round(ey)), fill=color, width=max(1, s // 2))+ d = max(1, s if t < 18 else s // 2)+ draw.rectangle((round(ex), round(ey), round(ex) + d - 1, round(ey) + d - 1), fill=color)+++def sweat(draw, x, y, s, f):+ """A cartoon sweat drop sliding down beside a tired face."""+ dy = (f % 24) * s // 3+ draw.rectangle((x, y + dy, x + s, y + dy + 2 * s), fill=SWEAT)+ draw.rectangle((x + s // 2, y + dy - s, x + s // 2, y + dy - 1), fill=SWEAT)+++def star(draw, x, y, s, colour=(255, 214, 107)):+ """A small four-pointed sparkle centred on (x, y)."""+ draw.rectangle((x - s, y - 3 * s, x, y + 2 * s), fill=colour)+ draw.rectangle((x - 3 * s, y - s, x + 2 * s, y), fill=colour)+++def hop(f, period=12, height=10):+ t = f % period+ half = period / 2+ return 4 * (t / half) * (1 - t / half) * height if t < half else 0+++EGG_SECONDS = 11 # a rare one-off plays the whole ten-second loop once, then the usual face again+++def lerp(a, b, t):+ return a + (b - a) * max(0, min(1, t))+++def ease(t):+ t = max(0, min(1, t))+ return t * t * (3 - 2 * t)+++def anti_event(frame, draw, box, f, happy, points=200, left=None):+ """Anti's reset and full, in the old arcade's terms (`f` at 12 a second). Reset: PLAYER ONE, READY!, its body+ grows back round its eyes, it leaves the house by the door and the pellets come back one by one, up to what is+ really left (`left`, None to leave them out). Full: wide-eyed and blue, flashing, eaten (only the points stay+ a moment), the eyes rush home, and a little star: it used it all."""+ x, y, w, h = box+ hx, hy = x + arcade.ANTI_HOME[0], y + arcade.ANTI_HOME[1] + 2+ art = arcade.anti_art+ if happy:+ refill = 0 if f < 56 else min(4, (f - 56) // 6 + 1)+ shown = None if left is None else min(left, refill / 4)+ arcade.anti_maze(draw, box, f, 1, shown, house=True, door=f < 36, pellets=left is not None)+ if f < 24:+ pixel_text(draw, (x + 60, y + 13), 'PLAYER ONE', scale=1, color=(0, 255, 255), align='center')+ if 6 <= f < 36:+ pixel_text(draw, (x + 60, y + 22), 'READY!', scale=1, color=(255, 255, 0), align='center')+ if f < 12:+ paste(frame, art('eaten', 'none'), hx, hy)+ elif f < 24: # the body comes back round the eyes+ paste(frame, art('normal', 'logo') if f % 4 < 2 else art('eaten', 'none'), hx, hy)+ elif f < 36:+ paste(frame, art('happy', 'logo'), hx, hy)+ elif f < 56: # up through the door+ paste(frame, art('normal', 'logo', (f // 6) % 2, 0, -1), hx, lerp(hy, y + 9, ease((f - 36) / 19)))+ else:+ paste(frame, art('happy' if f < 100 else 'normal', 'logo', (f // 6) % 2),+ hx + 20 * math.sin(2 * math.pi * (f - 56) / 64), y + 9)+ if left is not None and 56 <= f < 56 + 6 * math.ceil(left * 4) and (f - 56) % 6 < 2: # each glints as it comes back+ px_, py_ = arcade.ANTI_PELLETS[3 - min(3, (f - 56) // 6)]+ draw.point((x + px_, y + py_ - 5), fill=(255, 255, 255))+ draw.point((x + px_ + 5, y + py_), fill=(255, 255, 255))+ return+ arcade.anti_maze(draw, box, f, 1, left, house=True, pellets=left is not None)+ if f < 24:+ paste(frame, art('wide_scared', 'scared', (f // 3) % 2), hx, y + 9)+ elif f < 48:+ lit = (f // 4) % 2+ paste(frame, art('wide_flash' if lit else 'wide_scared', 'flash' if lit else 'scared', (f // 3) % 2), hx, y + 9)+ elif f < 62: # eaten: only the points stay a moment+ pixel_text(draw, (x + 60, y + 17), str(points), scale=1, color=(0, 255, 255), align='center')+ elif f < 70: # the eyes rush home, the fastest thing in the scene+ paste(frame, art('eaten', 'none'), hx, lerp(y + 9, hy, (f - 62) / 7))+ else:+ paste(frame, art('eaten', 'none'), hx, hy)+ if f >= 78:+ star(draw, x + 60, y + 28, 1)+++def event_scene(kind, provider, streak=1):+ """The one-off scene for `kind` ('reset' or 'full') starring `provider`; `streak` is how many periods in a row+ it has used its whole limit (Anti's points double with each: 200, 400, 800, 1600)."""+ happy = kind == 'reset'++ def scene(frame, draw, box, f, s, plan=None):+ x, y, w, h = box+ u = s / 2+ if provider == 'claude':+ ground, foot = clawd_ground(frame, draw, box, f, s)+ if happy:+ clips = [('Excited', 2, 21), ('DancingHappy', 4, 38), ('Excited', 2, 21), ('DancingHappy', 4, 38)]+ fireworks(draw, box, f, s)+ place_clawd(frame, *timeline(f, clips), s, foot, ground)+ elif f < 44: # worn out: it staggers, swaying from side to side+ name, index = timeline(f, [('Disappointed', 2, 21), ('Dizzy', 2, 25)])+ place_clawd(frame, name, index, s, foot + round(math.sin(f / 3) * 2 * s), ground)+ else: # then flops flat and lies there breathing hard, with a little star: it did use it all+ t = f - 44+ art = arcade.clawd('Dizzy', 25, s)+ art = art.crop(art.getbbox())+ fall, breath = min(1, t / 6), s if (t // 8) % 2 else 0+ flat = art.resize((round(art.width * (1 + .3 * fall)), max(1, round(art.height * (1 - .5 * fall)) + breath)),+ arcade.Image.Resampling.NEAREST)+ paste(frame, flat, foot - flat.width / 2, ground - flat.height)+ if t >= 8:+ sweat(draw, foot + flat.width // 2, ground - flat.height - 3 * s, max(1, s - 1), f)+ if (t // 6) % 3:+ star(draw, foot - flat.width // 2 - 2 * s, ground - flat.height - 6 * s, s)+ elif provider == 'codex':+ ground = arcade.garden_backdrop(draw, box, f, s)+ cx, mid, cw, ch = codex_place(box, s)+ if happy:+ fireworks(draw, box, f, s)+ lift = round(hop(f, 12, 6 * s))+ cloud = arcade.codex_art(s, 'happy', 'smile', 1 if f % 12 == 0 else 0)+ paste(frame, cloud, cx - cloud.width / 2, mid - cloud.height / 2 - lift)+ else: # out of breath: heaving fast, gasping through an 'o', puffs of breath, sweat+ beat = f % 6+ cloud = arcade.codex_art(s, 'closed', 'open' if beat < 3 else 'long', (1, 2, 1, 0, -1, 0)[beat])+ low = mid + 4 * s+ paste(frame, cloud, cx - cloud.width / 2, low - cloud.height / 2)+ for k in range(2): # each gasp breathes out a little puff that drifts off and fades+ t = (f + k * 3) % 6+ if t < 4:+ arcade.puff(draw, round(cx + cw * .22 + t * 4 * s), round(low + ch * .08 - t * s),+ max(1, round((4 - t) * s * .8)))+ for k, side in enumerate((-1, 1)):+ t = (f + k * 10) % 20+ if t < 11:+ p = t / 10+ arcade.sweat_drop(draw, round(cx + side * (cw * .25 + p * 6 * s)),+ round(low - ch * .45 - 4 * p * (1 - p) * 6 * s + p * p * 4 * s), s)+ elif provider == 'grok':+ u, ground, deck, hr, rx, rest_art, gsize, gx0, sep = arcade.grok_backdrop(draw, box, f, s)+ arcade.draw_stage(frame, draw, rx, deck, hr, u, ('left', 'centre', 'right'), 0, 0, 'empty', 0, 0, 1, 0, f)+ if happy:+ fireworks(draw, box, f, s)+ lift = hop(f, 10, 14 * u)+ art = arcade.grok_pose(gsize, 'open', 2 if f % 10 == 0 else 0)+ paste(frame, art, gx0 - art.width / 2, ground - art.height - lift)+ else: # out of fuel: the rocket only coughs smoke, Grok is dizzy+ if f % 20 < 6:+ arcade.puff(draw, rx, deck - 2 * u, round((2 + f % 20) * u))+ art = arcade.grok_pose(gsize, 'dizzy', 1)+ paste(frame, art, gx0 - art.width / 2, ground - art.height)+ sweat(draw, round(gx0 + gsize * .45), ground - gsize, max(1, s - 1), f)+ elif provider == 'antigravity':+ anti_event(frame, draw, box, f // 2, happy, 200 * 2 ** (min(4, max(1, streak)) - 1), arcade.anti_left(plan))+ else: # copilot+ arcade.copilot_backdrop(draw, box, f, s)+ base_y = y + round(h * .78)+ arcade.cloud(draw, x + round(w * .5), base_y, max(5, round(14 * u)))+ if happy:+ fireworks(draw, box, f, s)+ head = arcade.copilot_pose(max(10, round(arcade.COPILOT_HEAD * s)))+ lift = hop(f, 12, 12 * u)+ paste(frame, head, x + round(w * .5 - head.width / 2), base_y - head.height - round(4 * u) - lift)+ else: # the plane sputters down onto the cloud+ p = min(1, f / 60)+ art = arcade.plane(u, (f // 3) % 2)+ px_ = x + round(w * (.2 + .3 * p) - art.width / 2)+ py_ = round(y + h * .2 + (base_y - art.height - y - h * .2) * p) + (s if f % 6 < 3 and p < 1 else 0)+ if f % 8 < 4:+ arcade.puff(draw, px_ + art.width - round(4 * u), py_ + round(12 * u), round(3 * u))+ head = arcade.copilot_pose(max(8, round(17 * u)), 'shut')+ paste(frame, head, px_ + round(30 * u) - head.width / 2, py_ + round(17 * u) - head.height)+ paste(frame, art, px_, py_)+ return scenediff --git a/token_tv/gif.py b/token_tv/gif.pynew file mode 100644index 0000000..e892c16--- /dev/null+++ b/token_tv/gif.py@@ -0,0 +1,101 @@+"""Small animated GIFs for the clock.++The SD_PRO is an ESP8266: one core plays the GIF and takes uploads, so the animation holds for as long as a send+takes, about 20 ms a kilobyte. Every byte saved is a shorter hold. Three things keep the bytes down, with the+same pixels:+- one palette of just the colours used, and LZW codes only as wide as it needs (5 or 6 bits, not 8);+- each frame after the first holds only the box that changed, its unchanged pixels transparent, which+ compresses to almost nothing;+- rows in order (Pillow interlaces by default, which compresses worse and gains nothing on a clock).+"""+import io+import struct++from PIL import Image, ImageChops, ImageFile+++def indexed(frames, face):+ """The frames on one palette of just the colours they use."""+ colours = set()+ for frame in frames:+ colours.update(c for _, c in frame.getcolors(maxcolors=frame.width * frame.height))+ palette = sorted(colours)+ if len(palette) > 256:+ raise ValueError(f'{face} faces need at most 256 colours')+ reference = Image.new('P', (1, 1))+ reference.putpalette([v for c in palette for v in c])+ return [f.quantize(palette=reference, dither=Image.Dither.NONE) for f in frames]+++def image_data(image, bits):+ """The LZW-coded pixels of one P image, codes starting `bits` wide: Pillow's own GIF writer always starts them+ at 8 bits whatever the palette, which costs about an eighth of the bytes."""+ buffer = io.BytesIO()+ try: # Pillow's GIF encoder, as its own writer drives it, with the width the palette needs+ image.encoderconfig = (bits, False)+ ImageFile._save(image, buffer, [('gif', (0, 0) + image.size, 0, 'P')])+ return bytes([bits]) + buffer.getvalue() + b'\0'+ except (AttributeError, TypeError, ValueError, OSError): # not on this Pillow: its public writer, 8-bit codes+ buffer = io.BytesIO()+ image.save(buffer, format='GIF', optimize=False, interlace=False)+ data = buffer.getvalue()+ at = 13 + (3 << ((data[10] & 7) + 1) if data[10] & 0x80 else 0)+ while data[at] == 0x21: # extensions before the image+ at += 2+ while data[at]:+ at += data[at] + 1+ at += 1+ flags = data[at + 9]+ at += 10 + (3 << ((flags & 7) + 1) if flags & 0x80 else 0)+ end = at + 1+ while data[end]:+ end += data[end] + 1+ return data[at:end + 1]+++def encode(frames, durations):+ """A looping GIF of P frames that share one palette; `durations` in milliseconds. A frame equal to the one+ before only lengthens it."""+ palette = list(frames[0].getpalette()[:768])+ colours = len(palette) // 3+ clear = colours if colours < 256 else None # an index of its own for 'unchanged'+ bits = max(2, (colours + (clear is not None) - 1).bit_length())+ table = palette + [0] * (3 * (1 << bits) - len(palette))+ width, height = frames[0].size+ shown, previous = [], None # [box, pixels, centiseconds]+ for frame, ms in zip(frames, durations):+ if previous is None:+ shown.append([(0, 0, width, height), frame, ms])+ else:+ changed = ImageChops.difference(Image.frombytes('L', frame.size, previous.tobytes()),+ Image.frombytes('L', frame.size, frame.tobytes())).point(lambda v: 255 if v else 0)+ box = changed.getbbox()+ if box is None:+ shown[-1][2] += ms+ continue+ part = frame.crop(box)+ if clear is not None:+ part = Image.composite(part, Image.new('P', part.size, clear), changed.crop(box))+ shown.append([box, part, ms])+ previous = frame+ out = [b'GIF89a', struct.pack('<HHBBB', width, height, 0xF0 | (bits - 1), 0, 0), bytes(table),+ b'\x21\xff\x0bNETSCAPE2.0\x03\x01\x00\x00\x00'] # loop forever+ for n, (box, part, ms) in enumerate(shown):+ part = part.copy()+ part.putpalette(table)+ used = sorted(set(part.tobytes()))+ transparent = n > 0 and clear in used # a box where every pixel changed has none+ index, flags, local, pixels = clear or 0, 0, b'', image_data(part, bits)+ small = max(2, (len(used) - 1).bit_length())+ if small < bits: # a change in a few colours: its own short palette, if that comes out smaller+ mine = part.remap_palette(used)+ own = bytes(table[3 * i + c] for i in used for c in range(3)) + bytes(3 * ((1 << small) - len(used)))+ mine.putpalette(own)+ coded = image_data(mine, small)+ if len(own) + len(coded) < len(pixels):+ index, flags, local, pixels = used.index(clear) if transparent else 0, 0x80 | small - 1, own, coded+ out.append(struct.pack('<BBBBHBB', 0x21, 0xF9, 4, 1 << 2 | transparent, round(ms / 10), index, 0))+ out.append(struct.pack('<BHHHHB', 0x2C, box[0], box[1], box[2] - box[0], box[3] - box[1], flags) + local)+ out.append(pixels)+ out.append(b'\x3b')+ return b''.join(out)diff --git a/token_tv/live.py b/token_tv/live.pyindex ea1e119..dea4739 100644--- a/token_tv/live.py+++ b/token_tv/live.py@@ -1,20 +1,38 @@"""Live account dashboard and stock-firmware image publisher."""import argparse+import dataclassesimport hashlibimport jsonimport osimport threadingimport time+from http.client import HTTPExceptionfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServerfrom pathlib import Pathfrom urllib.parse import parse_qs, urlparsefrom token_tv.device import FILES, BackupMismatch, open_displayfrom token_tv.catalog import payload as theme_payload-from token_tv.display import STYLES, render_page, watch_payload+from token_tv.display import STYLES, overview_rows, render_page, watch_payload+from token_tv.arcade import LOOP_SECONDS, gif_seconds+from token_tv.events import EGG_SECONDS+from token_tv.lockbox import Lockbox++# After a unique one has played its prop stays in the scene for an hour; a legend's, till midnight.+TRACE = {'unique': lambda now: now + 3600,+ 'legend': lambda now: time.mktime(time.localtime(now)[:3] + (23, 59, 59, 0, 0, -1))}from token_tv.web_assets import HTML, ASSETS, assetfrom token_tv.sources import load_config-from token_tv.state import UsageStore+from token_tv.state import MIN_FETCH_SECONDS, UsageStore+++def until_loop_end(shown, now):+ """Seconds until the clock's GIF finishes a loop (it started at 'at' and loops every 'loop' seconds); 0 when+ nothing loops yet."""+ if shown.get('at') is None or not shown.get('loop'):+ return 0+ wait = shown['loop'] - (now - shown['at']) % shown['loop']+ return 0 if wait > shown['loop'] - .1 else wait # right on time is no reason to wait a whole loopdef write_json(path, data):@@ -76,7 +94,7 @@ class DisplayPreferences:self.status = ('queued' if style != self.style else 'ok' if success else 'error')-def handler(store, preferences=None):+def handler(store, preferences=None, locks=None, replays=None, wake=None):class Handler(BaseHTTPRequestHandler):def log_message(self, *args):return@@ -112,6 +130,14 @@ def handler(store, preferences=None):body = json.dumps(watch_payload(snapshot), ensure_ascii=False, separators=(",", ":")).encode()elif path == "/health":body = json.dumps({"status": "ok", "updated_at": snapshot["updated_at"]}).encode()+ elif path == "/collection":+ body = json.dumps(locks.collection() if locks else {'found': [], 'total': 0, 'hidden': 0}).encode()+ elif path.startswith("/collection/") and path.endswith(".gif") and locks:+ box = locks.replay(path[len("/collection/"):-len(".gif")])+ if not box or box.key not in snapshot["accounts"]:+ self.send_error(404)+ return+ body, content_type = render_page(snapshot, 0, 'arcade', egg=box), "image/gif"else:self.send_error(404)return@@ -127,6 +153,9 @@ def handler(store, preferences=None):self.wfile.write(body)def do_POST(self):+ if urlparse(self.path).path == '/collection/replay':+ self.replay_request()+ returnif urlparse(self.path).path != '/display/style':self.send_error(404)return@@ -152,6 +181,32 @@ def handler(store, preferences=None):self.send_error(500, 'Could not save display choice')returnself.reply(200, json.dumps(preferences.snapshot()).encode())++ def replay_request(self):+ """POST {"check": ...}: play a found one-off on the clock again."""+ origin = self.headers.get('Origin')+ if origin and (urlparse(origin).scheme not in ('http', 'https') or urlparse(origin).netloc != self.headers.get('Host')):+ self.send_error(403, 'Origin mismatch')+ return+ try:+ length = int(self.headers.get('Content-Length', '0'))+ if not 0 < length <= 256 or self.headers.get('Content-Type', '').split(';')[0] != 'application/json':+ raise ValueError('Invalid JSON request')+ data = json.loads(self.rfile.read(length))+ check = data.get('check') if isinstance(data, dict) else None+ found = {item['check'] for item in locks.collection()['found']} if locks else set()+ if check not in found or replays is None:+ raise ValueError('Not in the collection')+ except (ValueError, UnicodeError):+ self.send_error(400, 'Choose a scene you have found')+ return+ if preferences is not None and preferences.snapshot().get('style') != 'arcade':+ self.send_error(409, 'Scenes play on the Arcade face: switch the clock to Arcade first')+ return+ replays.append(check)+ if wake:+ wake.set()+ self.reply(200, json.dumps({'queued': check}).encode())return Handler@@ -182,19 +237,44 @@ def main():device.restore(original)print("Original display selection restored.")return- store = UsageStore(config["accounts"])+ store = UsageStore(config["accounts"], min_fetch_seconds=MIN_FETCH_SECONDS)+ try: # when each account last worked, from the last run+ store.restore(json.loads((state_dir / "snapshot.json").read_text()))+ except (OSError, ValueError):+ passpreferences = DisplayPreferences(args.config, config)- interval = max(60, int(config.get("poll_seconds", 300)))+ interval = max(60, int(config.get("poll_seconds", 60)))stopping = threading.Event()original = None- active_file = Nonelast_upload = None- def cycle(refresh=True):- nonlocal original, active_file, last_upload+ locks = Lockbox(state_dir / "history.json") # the hidden one-offs, and what they remember+ replays = [] # collection-book replays waiting for the clock+ seen_events, started = {}, time.time() # events from before this start are not replayed+ pending = [] # events waiting their turn, one per poll, so two at once are both shown++ traces = {} # account key -> (tier, until, prop): what a unique or legend leaves after it has played+ streaks = {} # account key -> full periods in a row, at its last 'full'++ shown = {'at': None, 'loop': None} # when the clock's GIF started, and its loop++ def cycle(refresh=True, egg=None):+ """Read (if `refresh`), draw and upload; True once the clock has the picture. A new picture for a looping+ face lands as the one on the clock finishes its loop, so the animation never jumps back mid-move; a+ one-off's first picture goes at once."""+ nonlocal original, last_upload+ delivered = Falseif refresh:store.refresh()snapshot = store.snapshot()+ for key, count in streaks.items():+ if key in snapshot['accounts']:+ snapshot['accounts'][key]['full_streak'] = count+ for key, (tier, until, prop) in list(traces.items()):+ if time.time() < until and key in snapshot['accounts']:+ snapshot['accounts'][key].update(trace=tier, trace_prop=prop)+ else:+ traces.pop(key, None)style = preferences.snapshot()['style']if not args.once and device:receipts = []@@ -203,20 +283,34 @@ def main():if original is None:original = load_original(device, backup_path)phase = "upload"- image = render_page(snapshot, 0, style)+ image = render_page(snapshot, 0, style, egg=egg)name = FILES[1] if image[:4] == b"GIF8" else FILES[0]digest = hashlib.sha256(image).hexdigest()if (name, digest) != last_upload: # identical frames are not rewritten to flash(state_dir / name).write_bytes(image)- receipts.append(dict(device.upload(name, image), sha256=digest))+ # The clock plays and answers on one core: while it takes a picture the animation holds. So+ # the send and the switch go together as the loop ends: the loop plays out whole, holds a+ # moment, and the new one starts. An event or a box goes at once.+ if not (egg is not None and getattr(egg, 'intro', True)):+ stopping.wait(until_loop_end(shown, time.monotonic()))+ started = time.monotonic()+ try:+ slot, sent = device.put(name, image, digest)+ receipts.extend(sent)+ phase = "activate"+ device.select(original, slot)+ except Exception:+ if shown['at'] is not None: # the old loop held while the clock tried: it ends that much later+ shown['at'] += time.monotonic() - started+ last_upload = None # what the clock shows is unknown: the next picture goes in full, even this one+ raise+ shown['at'] = time.monotonic()+ shown['loop'] = gif_seconds(image) if name == FILES[1] else Nonelast_upload = (name, digest)- if active_file != name:- phase = "activate"- device.activate(original, name)- active_file = namewrite_json(state_dir / "display-receipt.json", {"at": int(time.time()), "style": style, "uploads": receipts})preferences.delivered(style, True)- except (OSError, ValueError, KeyError) as error:+ delivered = True+ except (OSError, ValueError, KeyError, HTTPException) as error:if isinstance(error, BackupMismatch):print(mismatch_message(error, backup_path), flush=True)write_json(state_dir / "display-receipt.json", {"at": int(time.time()), "style": style, "status": "error", "phase": phase,@@ -226,6 +320,7 @@ def main():write_json(state_dir / "snapshot.json", snapshot)if args.output:write_json(args.output, snapshot)+ return deliveredif args.once:cycle()@@ -233,6 +328,26 @@ def main():print(json.dumps(store.snapshot(), ensure_ascii=False, separators=(",", ":")))return+ def play(egg, mark=True):+ """One one-off on the clock: the event, then for a unique or legend its quiet aftermath, then the usual face."""+ try:+ if not cycle(False, egg):+ if mark and not isinstance(egg, str):+ locks.forget() # never shown, so not seen: it may come again+ return+ if mark and getattr(egg, 'tier', None) in TRACE and getattr(egg, 'prop', ''): # in case it was missed+ traces[egg.key] = (egg.tier, TRACE[egg.tier](time.time()), egg.prop)+ # One loop of the event: the next picture is timed by cycle() to land as it ends, so its start never+ # plays again. A unique or legend then keeps its quiet loop for the rest of its time.+ seconds = getattr(egg, 'seconds', EGG_SECONDS)+ if getattr(egg, 'after', ()):+ cycle(False, dataclasses.replace(egg, frames=egg.after, after=(), intro=False))+ if stopping.wait(max(0, seconds - LOOP_SECONDS - (shown['loop'] or 0))): # its last loop lands it+ return+ cycle(False)+ except Exception:+ print("TokenTV easter egg skipped.", flush=True)+def poll():next_refresh = 0while not stopping.is_set():@@ -243,14 +358,48 @@ def main():except Exception:# Never serialize exception text, which may include auth material.print("TokenTV poll failed; retained previous snapshot.", flush=True)+ arcade_on = preferences.snapshot()['style'] == 'arcade'+ if not arcade_on:+ pending.clear() # another face now (even for a moment): what was waiting is not played laterif refresh:next_refresh = time.monotonic() + interval+ if device:+ # A one-off: a window that just reset or ran out, else a hidden box whose moment has+ # come. It plays once on the clock, then the usual face comes back. Events are noted+ # under any face, but played only on Arcade, never saved up for later.+ snap = store.snapshot()+ rows = [dict(row, key=key) for key, row in snap['accounts'].items()]+ fresh = sorted((row['event_at'], row['key'], row['event']) for row in rows+ if row.get('event') and row.get('event_at', 0) > seen_events.get(row['key'], started))+ for at, key, kind in fresh:+ seen_events[key] = at+ if not arcade_on:+ continue+ if kind == 'full': # how many periods in a row now, for the scenes that count them+ try:+ locks.history.observe(snap, time.time())+ streaks[key] = max(locks.history.full_streak(key, time.time()),+ locks.history.five_hour_run(key))+ except (OSError, ValueError):+ streaks[key] = 1 # history out of reach: the event still plays+ pending.append(f"{kind}@{key}")+ try:+ egg = (pending.pop(0) if pending else locks.pick(snap)) if arcade_on else None+ except (OSError, ValueError):+ egg = None+ print("TokenTV hidden one-offs skipped.", flush=True)+ if egg:+ play(egg)+ while device and replays: # asked for from the collection book: play it again now+ egg = locks.replay(replays.pop(0))+ if egg:+ play(egg, mark=False)preferences.changed.wait(max(0, next_refresh - time.monotonic()))thread = threading.Thread(target=poll, daemon=True)thread.start()try:- with ThreadingHTTPServer((args.host, args.port), handler(store, preferences)) as server:+ with ThreadingHTTPServer((args.host, args.port), handler(store, preferences, locks, replays, preferences.changed)) as server:print(f"TokenTV live listening at http://{args.host}:{args.port}", flush=True)server.serve_forever()except KeyboardInterrupt:diff --git a/token_tv/lockbox.py b/token_tv/lockbox.pynew file mode 100644index 0000000..d7d9e4c--- /dev/null+++ b/token_tv/lockbox.py@@ -0,0 +1,402 @@+"""Hidden one-offs, shipped locked.++The rarer Arcade scenes are not in this source tree. A release bundles them pre-rendered and+encrypted (`assets/eggs.bin`), each box sealed with the situation that opens it: a few facts such as+`weekday=tue` or `claude:idle`. The bundle keeps only a salted hash of each situation, and the key to a+box comes from the same facts, so a box opens when its situation happens on your clock. It is a spoiler+guard, not a secret: the clock itself must try the facts every minute, so anyone patient enough to try+them all can open every box; reading this file alone tells you what kinds of facts exist, not which+ones open anything, nor what plays.++Every minute the live loop lists the facts true right now for each account, hashes every set of up+to `MAX_FACTS` of them and looks for a box with that hash. Like a game's rare drops, a box rolls once+each time its situation comes about (not every minute it lasts). The odds are set for the clock as a+whole: each rare or unique tier aims at one opening every `PACE` days, shared by the boxes of that tier+whose situations come about on this clock, so a box whose situation comes daily gets small odds and one+that comes weekly gets large ones, and a box that comes less often than its share opens every time (doubled+until first seen; sure once a box is twice its share overdue).+A win waits a random moment while the situation holds; a cooldown keeps one scene from repeating soon,+two of a tier keep `SPACING` apart, and two hidden one-offs keep `GAP` apart unless the second is a legend.+"""+import base64+import copy+import hashlib+import io+import itertools+import json+import os+import random+import time+import zlib+from dataclasses import dataclass+from datetime import date, timedelta+from pathlib import Path++from PIL import Image++from token_tv.display import ASSETS, shown_windows+from token_tv.state import ACTIVE_SECONDS, NEWS_SECONDS++BUNDLE = ASSETS / 'eggs.bin'+MAX_FACTS = 4+GAP = 30 * 60 # seconds between two hidden one-offs, unless the second is a legend+RECENT = NEWS_SECONDS # how long a reading's news (a jump, a crossing) counts as now+PROVIDERS = ('claude', 'codex', 'grok', 'copilot')+WEEKDAYS = ('mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun')+TIERS = ('common', 'rare', 'unique', 'legend')+# A limit's period, and a step back to the one before: weeks for a weekly window, months for the rest.+PERIOD = {'WEEK': lambda day: '%d-W%02d' % day.isocalendar()[:2], 'MONTH': lambda day: day.strftime('%Y-%m'),+ 'BUDGET': lambda day: day.strftime('%Y-%m')}+BACK = {'WEEK': lambda day: day - timedelta(days=7), 'MONTH': lambda day: day.replace(day=1) - timedelta(days=1),+ 'BUDGET': lambda day: day.replace(day=1) - timedelta(days=1)}+PACE = {'rare': 3, 'unique': 8} # days between two openings of a tier on the clock as a whole+SPACING = {'rare': 86400, 'unique': 3 * 86400} # at least this between two of a tier, so they do not clump+MET_DAYS = 28 # a box shares its tier's pace while its situation has come about this recently+DELAY = 3 * 60 # a won box plays at a random moment within this, if its situation still holds (a legend at once)+NEW_AFTER = 60 * 60 # a situation that has not held for an hour is a new occurrence when it comes back+++def per_day(count, days):+ """How often a situation comes about: `count` times in `days` days, counted over a week at least so a box new+ to the clock is not over-trusted."""+ return count / max(7, days)+++def shares(rates, pace):+ """Days between openings for each box of a tier, so that together they open about once every `pace` days: a+ box whose situation comes about less often than its share opens every time, and the rest split what is left."""+ budget, rest = 1 / pace, sorted(rates)+ while rest:+ each = budget / len(rest)+ if rest[0] >= each:+ return 1 / each+ budget -= rest.pop(0)+ return 0 # every box of the tier comes about less often than the pace: each opens every time+++def odds(count, days, share, first):+ """The chance for one occurrence of a box that should open about once every `share` days, when its situation+ came about `count` times in `days` days on this clock (a week at least, so a new box is not over-trusted);+ doubled until the box is first seen."""+ return min(1.0, (2 if first else 1) / max(share * per_day(count, days), 1e-9))+++def daypart(hour):+ """midnight 0–1, night 2–4, dawn 5, morning 6–11, afternoon 12–17, evening 18–21, late 22–23."""+ for end, name in ((2, 'midnight'), (5, 'night'), (6, 'dawn'), (12, 'morning'), (18, 'afternoon'),+ (22, 'evening'), (24, 'late')):+ if hour < end:+ return name+++def same_day(a, b):+ return time.localtime(a)[:3] == time.localtime(b)[:3]+++class History:+ """What the hidden one-offs need to remember between runs, in the state folder: the first run, each+ account's peak per period of its limits, and each box's last opening, how often its situation came about,+ and its pending win."""++ def __init__(self, path):+ self.path = Path(path)+ try:+ self.data = json.loads(self.path.read_text())+ except (OSError, ValueError):+ self.data = {}+ self.data.setdefault('fired', {})++ def save(self):+ """Write through a temporary file, so a crash mid-write keeps the old history."""+ spare = self.path.with_suffix('.tmp')+ spare.write_text(json.dumps(self.data))+ os.replace(spare, self.path)++ def observe(self, snapshot, now):+ """Note the first run and, for every account, this period's peak of its main limit: the week for a+ weekly window, the month for a monthly one or a budget."""+ self.data.setdefault('first_run', time.strftime('%Y-%m-%d', time.localtime(now)))+ peaks = self.data.setdefault('peaks', {})+ for row in snapshot.get('accounts', {}).values():+ for w in row.get('windows', []):+ if row.get('status') != 'ok' or w.get('used_percent') is None or w.get('label') not in PERIOD:+ continue+ periods = peaks.setdefault(row['key'], {}).setdefault(w['label'], {})+ here = PERIOD[w['label']](date.fromtimestamp(now))+ periods[here] = max(periods.get(here, 0), w['used_percent'])+ for old in sorted(periods)[:-8]: # eight periods back is plenty+ del periods[old]+ for w in row.get('windows', []): # 5-hour windows have no calendar: each is known by when it resets+ if row.get('status') == 'ok' and w.get('label') == '5H' and w.get('resets_at') and w.get('used_percent') is not None:+ runs = self.data.setdefault('five', {}).setdefault(row['key'], {})+ here = str(round(w['resets_at'] / 600)) # to ten minutes, as a reset time can wobble+ runs[here] = max(runs.get(here, 0), w['used_percent'])+ for old in sorted(runs, key=int)[:-8]:+ del runs[old]+ self.save()++ def five_hour_run(self, key):+ """How many of the account's latest 5-hour windows in a row it used up."""+ count = 0+ for here in sorted(self.data.get('five', {}).get(key, {}), key=int, reverse=True):+ if self.data['five'][key][here] < 100:+ break+ count += 1+ return count++ def full_streak(self, key, now):+ """Periods in a row, up to this one, in which the account used its whole limit (the longest of its+ limits); counted by the calendar, so a clock change cannot double a week."""+ best = 0+ for label, periods in self.data.get('peaks', {}).get(key, {}).items():+ count, day = 0, date.fromtimestamp(now)+ while periods.get(PERIOD[label](day), 0) >= 100:+ count, day = count + 1, BACK[label](day)+ best = max(best, count)+ return best++ def anniversary(self, now):+ first = self.data.get('first_run')+ today = time.strftime('%Y-%m-%d', time.localtime(now))+ return bool(first) and today[5:] == first[5:] and today[:4] > first[:4]+++def facts(snapshot, history, now):+ """{account key: the facts true now for it}: the shared ones (time, all four at once) and its own."""+ t = time.localtime(now)+ shared = {f'hour={t.tm_hour}', f'minute={t.tm_min}', f'weekday={WEEKDAYS[t.tm_wday]}',+ 'weekend=' + ('yes' if t.tm_wday >= 5 else 'no'), f'daypart={daypart(t.tm_hour)}',+ f'date={t.tm_mon:02d}-{t.tm_mday:02d}'}+ rows = list(snapshot.get('accounts', {}).values())+ worked = lambda row: bool(row.get('rose_at')) and same_day(row['rose_at'], now)+ fresh = lambda row: row.get('status') == 'ok' # working or idle is known only from a good reading+ if all(any(r['provider'] == p and fresh(r) and r.get('active') for r in rows) for p in PROVIDERS):+ shared.add('all_active')+ if all(any(r['provider'] == p and worked(r) for r in rows) for p in PROVIDERS):+ shared.add('all_used_today')+ if any(fresh(r) and r.get('active') for r in rows):+ shared.add('someone_active')+ if history.anniversary(now):+ shared.add('anniversary')+ found, shared_news = {}, set()+ for row in rows:+ p, own = row['provider'], set()+ since = row.get('active_since')+ main = shown_windows(row, 3) if row.get('windows') else []+ main_label = main[0]['label'] if main else None+ main_used = main[0].get('used_percent') if main else None+ if fresh(row):+ own.add(f'{p}:active' if row.get('active') else f'{p}:idle')+ if row.get('active') and since:+ own.update(f'{p}:active_{h}h' for h in (1, 2) if now - since >= h * 3600)+ for item in row.get('news') or ():+ if now - item.get('at', 0) >= RECENT:+ continue+ kind, value = item.get('kind'), item.get('value')+ if kind == 'jump' and value >= 10:+ own.add(f'{p}:jump_10')+ elif kind == 'crossed':+ own.add(f'{p}:crossed_{value}')+ if item.get('label') == main_label and main_used is not None and value <= main_used < 100:+ own.add(f'{p}:main_crossed_{value}') # the pet's picture's window, and still where it crossed+ elif kind == 'first_today':+ own.add(f'{p}:first_today')+ shared_news.add('day_start')+ elif kind == 'back':+ own.add(f'{p}:back')+ elif kind == 'ticket_spent':+ own.add(f'{p}:ticket_spent')+ if value < 1:+ own.add(f'{p}:ticket_spent_last_day')+ if worked(row):+ own.add(f'{p}:worked_today')+ if history.full_streak(row['key'], now) >= 4:+ own.add(f'{p}:full_4')+ found[row['key']] = own+ return {key: shared | shared_news | own for key, own in found.items()} # the first use of the day counts for all+++# --- Sealing and opening ----------------------------------------------------------------------++def situation(fact_set):+ return '&'.join(sorted(fact_set)).encode()+++def digest(*parts):+ return hashlib.sha256(b'|'.join(parts)).hexdigest()+++def keystream(key, length):+ blocks = (hashlib.sha256(key + n.to_bytes(8, 'big')).digest() for n in itertools.count())+ return b''.join(itertools.islice(blocks, (length + 31) // 32))[:length]+++def xor(data, key):+ return bytes(a ^ b for a, b in zip(data, keystream(key, len(data))))+++def seal(salt, fact_set, content, chance=1.0, cooldown_days=7):+ """One locked box: `content` (a dict) opens only with exactly the facts in `fact_set`."""+ nonce = os.urandom(16)+ key = hashlib.sha256(b'key|' + salt + b'|' + nonce + b'|' + situation(fact_set)).digest()+ data = xor(zlib.compress(json.dumps(content).encode()), key)+ return {'check': digest(b'check', salt, situation(fact_set)), 'nonce': nonce.hex(), 'chance': chance,+ 'cooldown_days': cooldown_days, 'data': base64.b64encode(data).decode()}+++def open_box(salt, record, fact_set):+ key = hashlib.sha256(b'key|' + salt + b'|' + bytes.fromhex(record['nonce']) + b'|' + situation(fact_set)).digest()+ return json.loads(zlib.decompress(xor(base64.b64decode(record['data']), key)))+++@dataclass(frozen=True)+class Box:+ """An opened one-off: the stage frames to play once (one per clock frame) for account `key`, and the quiet+ loop that stays for the rest of its `seconds`."""+ name: str+ tier: str+ key: str+ frames: tuple+ seconds: int+ after: tuple = ()+ intro: bool = True # the cut-in at the start; off for the quiet loop that follows+ prop: str = '' # what it leaves in the scene once played (a base64 PNG), if anything+++def frames_of(strip, height):+ """The frames of a box, stacked top to bottom in one PNG."""+ image = Image.open(io.BytesIO(base64.b64decode(strip))).convert('RGB')+ return tuple(image.crop((0, y, image.width, y + height)) for y in range(0, image.height, height))+++class Lockbox:+ def __init__(self, history_path, bundle=BUNDLE, roll=random.random):+ self.history = History(history_path)+ self.roll = roll+ self.undo = None # what the last pick changed, until it is known to have played+ try:+ loaded = json.loads(Path(bundle).read_text())+ self.salt, self.boxes = bytes.fromhex(loaded['salt']), {b['check']: b for b in loaded['boxes']}+ except (OSError, ValueError, KeyError):+ self.salt, self.boxes = b'', {}++ @staticmethod+ def box_of(content, key, variant=0):+ """The box to play; a box with several `strips` plays the next one each time it is found."""+ strips = content.get('strips') or [content['strip']]+ after = frames_of(content['after'], content['height']) if content.get('after') else ()+ return Box(content['name'], content['tier'], key, frames_of(strips[variant % len(strips)], content['height']),+ content['seconds'], after, prop=content.get('prop', ''))++ def collection(self):+ """The collection book: every box opened so far on this clock (newest first) and how many are still+ hidden. Nothing about the hidden ones is known until they open."""+ found = [dict(check=check, **{k: v for k, v in seen.items() if k not in ('combo', 'key')})+ for check, seen in self.history.data.get('found', {}).items() if check in self.boxes]+ found.sort(key=lambda item: -item['last'])+ return {'found': found, 'total': len(self.boxes), 'hidden': len(self.boxes) - len(found)}++ def replay(self, check):+ """A box already found, opened again with the situation that opened it, to play once more; or None."""+ seen = self.history.data.get('found', {}).get(check)+ record = self.boxes.get(check)+ if not seen or not record:+ return None+ content = self.opened(record, tuple(seen['combo']))+ return self.box_of(content, seen['key'], seen['count'] - 1) if content else None++ def opened(self, record, combo):+ try:+ return open_box(self.salt, record, combo)+ except (ValueError, zlib.error):+ return None++ def pick(self, snapshot, now=None):+ """The hidden one-off to play now, or None."""+ now = time.time() if now is None else now+ self.history.observe(snapshot, now)+ if not self.boxes:+ return None+ data = self.history.data+ fired, met, spaced = data['fired'], data.setdefault('met', {}), data.setdefault('spaced', {})+ armed, held = data.setdefault('armed', {}), data.setdefault('held', {})+ matched = self.matches(facts(snapshot, self.history, now))+ for check, (record, combo, key) in matched.items(): # one roll each time a situation comes about+ new = now - held.get(check, float('-inf')) > NEW_AFTER+ held[check] = now+ if not new or check in armed or now - fired.get(check, 0) < record['cooldown_days'] * 86400:+ continue+ content = self.opened(record, combo)+ if not content:+ continue+ tier = content['tier']+ seen = met.setdefault(check, {'first': now, 'count': 0})+ seen.update(count=seen['count'] + 1, tier=tier)+ if now - spaced.get(tier, 0) < SPACING.get(tier, 0):+ continue # one of its tier played lately+ if self.roll() < self.odds_now(record, check, tier, now):+ armed[check] = now + (0 if tier == 'legend' else self.roll() * DELAY) # a legend's moment can be a minute+ due = []+ for check, at in list(armed.items()):+ if now - at > 2 * 86400: # a win whose situation never came back+ del armed[check]+ elif at <= now and check in matched:+ record, combo, key = matched[check]+ content = self.opened(record, combo)+ if content:+ due.append(((TIERS.index(content['tier']), len(combo)), check, content, key))+ chosen, self.undo = None, None+ # the rarer tier first, and within a tier the more particular situation (more facts)+ for _, check, content, key in sorted(due, key=lambda item: (-item[0][0], -item[0][1])):+ if content['tier'] != 'legend' and now - data.get('last_at', 0) < GAP:+ continue+ if now - spaced.get(content['tier'], 0) < SPACING.get(content['tier'], 0):+ continue # won alongside another of its tier: it waits its turn (or lapses with its win)+ self.undo = copy.deepcopy({k: data.get(k) for k in ('fired', 'armed', 'spaced', 'found', 'last_at')})+ fired[check], data['last_at'], spaced[content['tier']] = now, now, now+ del armed[check]+ seen = data.setdefault('found', {}).setdefault(check, {+ 'name': content['name'], 'title': content.get('title', content['name']), 'tier': content['tier'],+ 'first': now, 'count': 0})+ seen.update(last=now, count=seen['count'] + 1, combo=list(matched[check][1]), key=key)+ chosen = self.box_of(content, key, seen['count'] - 1)+ break+ self.history.save()+ return chosen++ def matches(self, found):+ """{check: (record, facts, account key)} for every box whose situation holds in `found` (facts by account)."""+ matched = {}+ for key, fact_set in found.items():+ ordered = sorted(fact_set)+ for size in range(1, MAX_FACTS + 1):+ for combo in itertools.combinations(ordered, size):+ record = self.boxes.get(digest(b'check', self.salt, situation(combo)))+ if record:+ matched.setdefault(record['check'], (record, combo, key))+ return matched++ def odds_now(self, record, check, tier, now):+ """This occurrence's chance: sure for a box sealed sure and for the tiers without a pace, else the box's+ share of its tier's pace, sure once twice its share has passed since it last opened (or was first met)."""+ if record.get('chance', 1) >= 1 or tier not in PACE:+ return 1.0+ data = self.history.data+ met, held, fired = data['met'], data['held'], data['fired']+ rates = [per_day(m['count'], (now - m['first']) / 86400) for c, m in met.items()+ if m.get('tier') == tier and now - held.get(c, 0) < MET_DAYS * 86400]+ share, seen = shares(rates, PACE[tier]), met[check]+ if now - fired.get(check, seen['first']) >= 2 * share * 86400:+ return 1.0+ return odds(seen['count'], (now - seen['first']) / 86400, share, check not in fired)++ def forget(self):+ """The last pick never reached the screen: take it back, so it is neither seen nor resting."""+ if self.undo:+ for name, value in self.undo.items():+ if value is None:+ self.history.data.pop(name, None)+ else:+ self.history.data[name] = value+ self.undo = None+ self.history.save()diff --git a/token_tv/readout.py b/token_tv/readout.pynew file mode 100644index 0000000..bc38993--- /dev/null+++ b/token_tv/readout.py@@ -0,0 +1,371 @@+"""The Arcade face's readout: the used %, the time to reset and the usage bar under the scene.++Four looks share one layout (the number on the left, the reset time on the right, the bar under them): 'lcd',+seven-segment digits drawn on the 2 px grid over their faint unlit strokes, with a bar from LCD_BARS (the owner's+pick, 2026-10-29); 'score', a tall arcade score font with a soft shadow and a rounded bar lit along its top;+'chips', a squared modern font and twenty 5% chips; 'pixel', the 5 x 7 pixel font and ten cells. Text from a font+is drawn without smoothing at half size and doubled, so it sits on the clock's 2 px grid like the rest.+"""+import functools+from pathlib import Path++from PIL import Image, ImageDraw, ImageFont++from token_tv.display import pixel_text++STYLE = 'lcd' # the look in use: 'lcd', 'score', 'chips' or 'pixel'+WEB = Path(__file__).with_name('web')+TEXT, MUTED, PANEL, TRACK = (226, 230, 238), (128, 138, 160), (11, 13, 19), (40, 46, 62)+BANDS = ((76, 201, 140), (140, 214, 92), (255, 160, 64), (255, 84, 96)) # below 50, 50–79, 80–89, 90++LOOKS = { # font, digits (size of one, of two lines), small text, the bar and its height (one, two lines), shadow, unlit+ 'score': dict(font='jersey-10.woff2', big=30, mid=20, small=18, bar='capsule', bar_h=(10, 6), shadow=(44, 50, 70)),+ 'chips': dict(font='chakra-petch-700.woff2', big=24, mid=14, small=14, bar='chips', bar_h=(8, 6)),+}+++def band(used):+ return BANDS[0 if used < 50 else 1 if used < 80 else 2 if used < 90 else 3]+++def shade(colour, k):+ return tuple(max(0, min(255, round(v * k))) for v in colour)++[email protected]_cache(maxsize=256)+def crisp(text, font_file, size, colour):+ """`text` in a bundled font, unsmoothed at half size and doubled, on a transparent ground."""+ font = ImageFont.truetype(str(WEB / font_file), size)+ left, top, right, bottom = font.getbbox(text)+ mask = Image.new('L', (right - left + 2, bottom - top + 2))+ draw = ImageDraw.Draw(mask)+ draw.fontmode = '1'+ draw.text((1 - left, 1 - top), text, font=font, fill=255)+ mask = mask.crop(mask.getbbox() or (0, 0, 1, 1))+ mask = mask.resize((mask.width * 2, mask.height * 2), Image.Resampling.NEAREST).point(lambda v: 255 if v > 127 else 0)+ art = Image.new('RGBA', mask.size, colour + (0,))+ art.putalpha(mask)+ return art+++def put(frame, art, x, y, align='left', shadow=None):+ """Paste `art` with its left (or right) edge at x; returns its right edge."""+ x = x - art.width if align == 'right' else x+ if shadow:+ under = Image.new('RGBA', art.size, shadow + (0,))+ under.putalpha(art.getchannel('A'))+ frame.paste(under, (x + 2, y + 2), under)+ frame.paste(art, (x, y), art)+ return x + art.width+++# --- the bars ------------------------------------------------------------------------------------++def bar_capsule(draw, x, y, w, h, used, old):+ draw.rounded_rectangle((x, y, x + w - 1, y + h - 1), radius=h // 2, fill=TRACK)+ if used:+ fill = max(h, round(w * min(100, used) / 100))+ colour = MUTED if old else band(used)+ draw.rounded_rectangle((x, y, x + fill - 1, y + h - 1), radius=h // 2, fill=colour)+ if fill > h:+ draw.line((x + h // 2, y, x + fill - 1 - h // 2, y), fill=shade(colour, 1.25))+ draw.line((x + h // 2, y + h - 1, x + fill - 1 - h // 2, y + h - 1), fill=shade(colour, .7))+ for q in (.25, .5, .75):+ mx = x + round(w * q)+ draw.line((mx, y + 2, mx, y + h - 3), fill=PANEL)+++def bar_chips(draw, x, y, w, h, used, old):+ n, gap = 20, 2+ pitch = (w - gap * (n - 1)) / n+ colour = MUTED if old else band(used or 0)+ for i in range(n):+ left, right = round(x + i * (pitch + gap)), round(x + i * (pitch + gap) + pitch) - 1+ part = 0 if not used else max(0, min(1, used / 5 - i))+ draw.rectangle((left, y, right, y + h - 1), fill=colour if part >= 1 else shade(colour, .55) if part > 0 else TRACK)+ for cx, cy in ((left, y), (right, y), (left, y + h - 1), (right, y + h - 1)):+ draw.point((cx, cy), fill=PANEL)+++BARS = {'capsule': bar_capsule, 'chips': bar_chips}+++def pixel_bar(draw, x, y, width, height, used, old):+ """The first look's ten cells."""+ step = width / 10+ for cell in range(10):+ left, right = round(x + cell * step), round(x + (cell + 1) * step) - 2+ draw.rectangle((left, y, right, y + height - 1), fill=TRACK)+ if used is not None and used > cell * 10:+ fill = min(1, used / 10 - cell)+ draw.rectangle((left, y, left + max(1, round((right - left + 1) * fill)) - 1, y + height - 1),+ fill=MUTED if old else band(used))+++# --- the readout -------------------------------------------------------------------------------++def number(frame, look, value, x, bottom, size, old):+ """The used % with its digits standing on `bottom` and a smaller % at their top right."""+ ink = MUTED if old else TEXT+ digits = crisp(value, look['font'], size, ink)+ if look.get('unlit') and value != '--':+ unlit = crisp('8' * len(value), look['font'], size, look['unlit'])+ put(frame, unlit, x, bottom - unlit.height)+ right = put(frame, digits, x, bottom - digits.height, shadow=look.get('shadow'))+ if value != '--':+ sign = crisp('%', look.get('words', look['font']), size // 2 + 2, MUTED)+ put(frame, sign, right + 4, bottom - digits.height)+++def draw_readout(frame, draw, windows, style=None):+ """Draw the readout for one window [(label, used, left, old)] or two (5H above the week)."""+ style = style or STYLE+ if style == 'lcd':+ draw_lcd(frame, draw, windows)+ return+ if style not in LOOKS: # the first look: the 5 x 7 pixel font+ if len(windows) == 1:+ _, used, left, old = windows[0]+ pixel_text(draw, (10, 184), '--' if used is None else f'{round(used)}%', scale=5, color=MUTED if old else TEXT)+ pixel_text(draw, (230, 186), 'RESET', scale=1, color=MUTED, align='right')+ pixel_text(draw, (230, 198), left, scale=3, color=TEXT, align='right')+ pixel_bar(draw, 10, 226, 222, 7, used, old)+ return+ for i, (label, used, left, old) in enumerate(windows):+ top = 180 + i * 31+ pixel_text(draw, (10, top + 4), label, color=MUTED)+ pixel_text(draw, (30, top), '--' if used is None else f'{round(used)}%', scale=3, color=MUTED if old else TEXT)+ pixel_text(draw, (230, top + 4), left, scale=2, color=TEXT, align='right')+ pixel_bar(draw, 10, top + 24, 222, 4, used, old)+ return+ look = LOOKS[style]+ words = look.get('words', look['font'])+ bar = BARS[look['bar']]+ if len(windows) == 1:+ _, used, left, old = windows[0]+ base = 216 # the baseline the number and the reset time stand on+ number(frame, look, '--' if used is None else str(round(used)), 10, base, look['big'], old)+ when = crisp(left, words, look['small'], TEXT)+ put(frame, when, 230, base - when.height, align='right')+ pixel_text(draw, (230, base - when.height - 11), 'RESET', scale=1, color=MUTED, align='right')+ bar(draw, 10, 224, 220, look['bar_h'][0], used, old)+ return+ for i, (label, used, left, old) in enumerate(windows):+ base = 194 + i * 33+ pixel_text(draw, (10, base - 7), label, color=MUTED)+ number(frame, look, '--' if used is None else str(round(used)), 30, base, look['mid'], old)+ when = crisp(left, words, look['mid'], TEXT)+ put(frame, when, 230, base - when.height, align='right')+ bar(draw, 10, base + 4, 220, look['bar_h'][1], used, old)+++# --- 'lcd': seven-segment digits drawn on the 2 px grid -------------------------------------------+# Each digit is seven strokes on the 2 px grid, the unlit ones faint as on a real LCD, stopping short of the+# corners with the small gaps of a real display. The reset time's unit (D, H, M) stands small beside its digits.+SEGMENTS = {'0': 'abcdef', '1': 'bc', '2': 'abged', '3': 'abgcd', '4': 'fgbc', '5': 'afgcd', '6': 'afgedc',+ '7': 'abc', '8': 'abcdefg', '9': 'abcdfg', '-': 'g'}+UNLIT = (21, 24, 33) # just above the panel: there if you look, quiet if you glance+SEVEN = {'big': (10, 19, 2), 'mid': (8, 13, 1), 'small': (7, 11, 1)} # cells wide, high, stroke (cells of 2 px)+++def seven(draw, x, y, char, size, ink, unlit=UNLIT):+ """One seven-segment character with its top left at (x, y) in px; returns its width in px."""+ w, h, t = SEVEN[size]+ lit = SEGMENTS.get(char, '')+ mid = (h - t) // 2+ strokes = {'a': (t, 0, w - 2 * t, t), 'g': (t, mid, w - 2 * t, t), 'd': (t, h - t, w - 2 * t, t),+ 'f': (0, t, t, mid - t), 'b': (w - t, t, t, mid - t),+ 'e': (0, mid + t, t, h - mid - 2 * t), 'c': (w - t, mid + t, t, h - mid - 2 * t)}+ for name, (cx, cy, cw, ch) in strokes.items(): # the strokes stop short of the corners, as on a display+ draw.rectangle((x + 2 * cx, y + 2 * cy, x + 2 * (cx + cw) - 1, y + 2 * (cy + ch) - 1),+ fill=ink if name in lit else unlit)+ return 2 * w+++def seven_text(draw, x, y, text, size, ink, gap=None):+ """A row of seven-segment characters from (x, y); returns the right edge."""+ w, h, t = SEVEN[size]+ gap = 2 * t if gap is None else gap+ for n, char in enumerate(text):+ x += seven(draw, x, y, char, size, ink) + (gap if n < len(text) - 1 else 0)+ return x+++def seven_width(text, size, gap=None):+ w, h, t = SEVEN[size]+ gap = 2 * t if gap is None else gap+ return len(text) * 2 * w + (len(text) - 1) * gap+++def reset_parts(left):+ """'4D' -> ('4', 'D'); '--' -> ('--', '')."""+ digits = ''.join(c for c in left if c.isdigit() or c == '-')+ return digits or '--', ''.join(c for c in left if c.isalpha())+++# --- bars for the lcd look ------------------------------------------------------------------------++def bar_cells(draw, x, y, w, h, used, old):+ """Twenty-two narrow cells, lit to the level and faint beyond, like an LCD's level meter."""+ n, gap = 22, 2+ cell = (w - gap * (n - 1)) / n+ colour = MUTED if old else band(used or 0)+ for i in range(n):+ left, right = round(x + i * (cell + gap)), round(x + i * (cell + gap) + cell) - 1+ on = used is not None and used >= (i + .5) * 100 / n+ draw.rectangle((left, y, right, y + h - 1), fill=colour if on else UNLIT)+++def bar_ticks(draw, x, y, w, h, used, old):+ """A solid bar under a scale: a mark every 10%, longer at 50% and 100%, and a pointer at the level."""+ for k in range(11):+ mx = x + round((w - 2) * k / 10)+ draw.rectangle((mx, y, mx + 1, y + (3 if k % 5 == 0 else 1)), fill=(58, 64, 84))+ top = y + 6+ draw.rectangle((x, top, x + w - 1, top + h - 1), fill=TRACK)+ if used:+ fill = round(w * min(100, used) / 100)+ colour = MUTED if old else band(used)+ draw.rectangle((x, top, x + fill - 1, top + h - 1), fill=colour)+ draw.polygon(((x + fill - 4, y), (x + fill + 3, y), (x + fill - 1, y + 4)), fill=colour)+++def bar_dots(draw, x, y, w, h, used, old):+ """A row of dots, lit to the level, with a bigger dot where it stands."""+ n = w // 4+ colour = MUTED if old else band(used or 0)+ lit = 0 if used is None else round(n * min(100, used) / 100)+ mid = y + h // 2+ for i in range(n):+ dx = x + i * 4+ draw.rectangle((dx, mid - 1, dx + 1, mid), fill=colour if i < lit else TRACK)+ if lit:+ hx = x + (lit - 1) * 4+ draw.rectangle((hx - 1, mid - 3, hx + 2, mid + 2), fill=colour)+++def bar_zones(draw, x, y, w, h, used, old):+ """The track coloured faintly by zone (under 50, to 80, to 90, the last 10%), filled bright in each zone's+ colour up to the level, so the warning thresholds sit where the eye expects them."""+ edges = ((0, 50), (50, 80), (80, 90), (90, 100))+ for k, (a, b) in enumerate(edges):+ left, right = x + round(w * a / 100), x + round(w * b / 100) - 1 - (2 if b < 100 else 0)+ draw.rectangle((left, y, right, y + h - 1), fill=shade(BANDS[k], .22))+ if used and used > a:+ end = min(right, x + round(w * min(used, b) / 100) - 1)+ draw.rectangle((left, y, end, y + h - 1), fill=MUTED if old else BANDS[k])+++LCD_BARS = {'cells': bar_cells, 'ticks': bar_ticks, 'dots': bar_dots, 'zones': bar_zones}+LCD_BAR = 'capsule' # the bar under the lcd digits (the owner's pick: the rounded one from the table)+++def draw_lcd(frame, draw, windows, bar_style=None):+ """The 'lcd' look: seven-segment digits with their faint unlit strokes, a small % and the reset time's unit."""+ bar = LCD_BARS[bar_style or LCD_BAR]+ if len(windows) == 1:+ _, used, left, old = windows[0]+ ink = MUTED if old else TEXT+ number = '--' if used is None else str(round(used))+ top = 178+ right = seven_text(draw, 10, top, number, 'big', ink)+ if used is not None:+ pixel_text(draw, (right + 6, top), '%', scale=2, color=MUTED)+ digits, unit = reset_parts(left)+ unit_w = (len(unit) * 6 - 1) * 2 if unit else 0+ dx = 230 - unit_w - (4 if unit else 0) - seven_width(digits, 'small')+ seven_text(draw, dx, 196, digits, 'small', TEXT)+ if unit:+ pixel_text(draw, (230, 202), unit, scale=2, color=MUTED, align='right')+ pixel_text(draw, (230, 183), 'RESET', scale=1, color=MUTED, align='right')+ bar(draw, 10, 224, 220, 4 if bar is bar_ticks else 10 if (bar_style or LCD_BAR).startswith('capsule') else 8, used, old)+ return+ for i, (label, used, left, old) in enumerate(windows):+ top = 172 + i * 33+ pixel_text(draw, (10, top + 15), label, color=MUTED)+ ink = MUTED if old else TEXT+ number = '--' if used is None else str(round(used))+ right = seven_text(draw, 30, top, number, 'mid', ink)+ if used is not None:+ pixel_text(draw, (right + 4, top), '%', scale=1, color=MUTED)+ digits, unit = reset_parts(left)+ unit_w = (len(unit) * 6 - 1) * 2 if unit else 0+ seven_text(draw, 230 - unit_w - (4 if unit else 0) - seven_width(digits, 'mid'), top, digits, 'mid', TEXT)+ if unit:+ pixel_text(draw, (230, top + 8), unit, scale=2, color=MUTED, align='right')+ if bar is bar_ticks:+ bar(draw, 10, top + 23, 220, 3, used, old)+ else:+ bar(draw, 10, top + 25, 220, 6 if (bar_style or LCD_BAR).startswith('capsule') else 5, used, old)+++# --- the rounded bar from the table, plain or with a little gradient ---------------------------------++def mix(a, b, t):+ return tuple(round(x + (y - x) * t) for x, y in zip(a, b))+++def capsule_fill(draw, x, y, w, h, used, old, colour_at):+ """The rounded track and a fill to the level, each column coloured by colour_at(column 0..1, row 0..1),+ with marks at the quarters; corners rounded on the 2 px grid."""+ draw.rounded_rectangle((x, y, x + w - 1, y + h - 1), radius=h // 2, fill=TRACK)+ if used:+ fill = max(h, round(w * min(100, used) / 100))+ mask = Image.new('L', (fill, h))+ ImageDraw.Draw(mask).rounded_rectangle((0, 0, fill - 1, h - 1), radius=h // 2, fill=255)+ for cx in range(0, fill, 2):+ for cy in range(0, h, 2):+ if mask.getpixel((cx, cy)):+ colour = MUTED if old else colour_at(cx / max(1, w - 1), cy / max(1, h - 1), used)+ draw.rectangle((x + cx, y + cy, x + min(fill - 1, cx + 1), y + min(h - 1, cy + 1)), fill=colour)+ for q in (.25, .5, .75):+ mx = x + round(w * q)+ draw.line((mx, y + 2, mx, y + h - 3), fill=PANEL)+++def plain(px, py, used):+ colour = band(used)+ return shade(colour, 1.25) if py == 0 else shade(colour, .72) if py >= .99 else colour+++def along(px, py, used): # a little darker where the bar starts, full colour at its head+ colour = band(used)+ t = min(1, px / max(.01, used / 100))+ step = round(t * 5) / 5 # five steps, as pixel art would+ base = mix(shade(colour, .7), colour, step)+ return shade(base, 1.22) if py == 0 else shade(base, .75) if py >= .99 else base+++def lit(px, py, used): # lit from above: a soft top-to-bottom ramp+ colour = band(used)+ k = (1.3, 1.12, 1.0, 1.0, .9, .78)[min(5, int(py * 6))]+ return shade(colour, k)+++def heat(px, py, used): # the colour of where it is: green, then yellow-green, amber and red along the bar+ stops = ((0, BANDS[0]), (.5, BANDS[0]), (.65, BANDS[1]), (.85, BANDS[2]), (1, BANDS[3]))+ for (a, ca), (b, cb) in zip(stops, stops[1:]):+ if px <= b:+ t = 0 if b == a else (px - a) / (b - a)+ base = mix(ca, cb, round(t * 4) / 4)+ break+ return shade(base, 1.22) if py == 0 else shade(base, .75) if py >= .99 else base+++def bar_capsule_plain(draw, x, y, w, h, used, old):+ capsule_fill(draw, x, y, w, h, used, old, plain)+++def bar_capsule_along(draw, x, y, w, h, used, old):+ capsule_fill(draw, x, y, w, h, used, old, along)+++def bar_capsule_lit(draw, x, y, w, h, used, old):+ capsule_fill(draw, x, y, w, h, used, old, lit)+++def bar_capsule_heat(draw, x, y, w, h, used, old):+ capsule_fill(draw, x, y, w, h, used, old, heat)+++LCD_BARS.update({'capsule': bar_capsule_plain, 'capsule_along': bar_capsule_along, 'capsule_lit': bar_capsule_lit,+ 'capsule_heat': bar_capsule_heat})diff --git a/token_tv/sample.py b/token_tv/sample.pyindex 2973e27..72fb997 100644--- a/token_tv/sample.py+++ b/token_tv/sample.py@@ -20,6 +20,6 @@ def snapshot(now=None, sample=SAMPLE):if now is not None:row['fetched_at'] = row['last_success_at'] = nowfor window in row['windows']:- window['resets_at'] = now + window['resets_in']+ window['resets_at'] = None if window['resets_in'] is None else now + window['resets_in']accounts[key] = rowreturn {'schema': 1, 'updated_at': now or 0, 'accounts': accounts}diff --git a/token_tv/sources.py b/token_tv/sources.pyindex b7a71ce..7292986 100644--- a/token_tv/sources.py+++ b/token_tv/sources.py@@ -17,7 +17,8 @@ from urllib.error import HTTPErrorfrom urllib.parse import parse_qs, urlparsefrom urllib.request import Request, urlopen-from token_tv.usage import normalize_claude, normalize_codex, normalize_codexbar, normalize_grok, timestamp, window+from token_tv.usage import (normalize_claude, normalize_codex, normalize_codexbar, normalize_grok, reset_credits, timestamp,+ window)from token_tv.display import STYLESCODEXBAR_SOURCES = {"auto", "web", "cli", "oauth", "api"}@@ -118,12 +119,17 @@ def load_config(path):raise ValueError('Unknown display style')seen = set()allowed = {"key", "alias", "provider", "source_home", "email", "snapshot_file", "fallback_snapshot_file", "refresh_with_cli",- "codexbar_command", "codexbar_url", "codexbar_source"}+ "codexbar_command", "codexbar_url", "codexbar_source", "codexbar_provider"}for account in data.get("accounts", []):if set(account) - allowed:raise ValueError("Only credential-free account metadata is allowed")- if account.get("provider") not in ("claude", "codex", "grok"):+ if account.get("provider") == "gemini": # one Google pet now, Anti; an old Gemini account still reads Gemini+ account["provider"] = "antigravity"+ account.setdefault("codexbar_provider", "gemini")+ if account.get("provider") not in ("claude", "codex", "grok", "copilot", "antigravity"):raise ValueError("Unknown provider")+ if account["provider"] in CODEXBAR_ONLY and not (uses_codexbar(account) or account.get("snapshot_file")):+ raise ValueError(f"{account['provider'].title()} is read through CodexBar: set codexbar_command or codexbar_url")check_codexbar(account)key = account.get("key", "")if not re.fullmatch(r"[a-z0-9_-]{1,48}", key) or key in seen:@@ -148,8 +154,11 @@ def check_codexbar(account):if not fields:returncommand, url = account.get("codexbar_command"), account.get("codexbar_url")- if account["provider"] not in ("claude", "codex"):- raise ValueError("CodexBar input is checked for claude and codex accounts only")+ if account["provider"] not in ("claude", "codex", "copilot", "antigravity"):+ raise ValueError("CodexBar input is checked for claude, codex, copilot and antigravity accounts only")+ if account.get("codexbar_provider") and (account["provider"] != "antigravity"+ or account["codexbar_provider"] not in ("gemini", "antigravity")):+ raise ValueError("codexbar_provider picks antigravity or gemini for an Antigravity account")if bool(command) == bool(url) or account.get("snapshot_file"):raise ValueError("Use one of codexbar_command or codexbar_url, without snapshot_file")if command is not None and not (isinstance(command, str) and command.strip()):@@ -267,15 +276,25 @@ def grok_payload(account):rpc.close()+# Services TokenTV reads only through CodexBar, which owns their logins. An Antigravity account reads CodexBar's+# antigravity entry, or its gemini one with `codexbar_provider` (CodexBar reads Gemini's quota through Antigravity).+CODEXBAR_ONLY = ("copilot", "antigravity")+++def codexbar_name(account):+ return account.get("codexbar_provider") or account["provider"]++def codexbar_payload(account):"""CodexBar's usage JSON. CodexBar owns the login; TokenTV only reads what it prints or serves."""if account.get("codexbar_url"):return json_get(account["codexbar_url"])command = [exe(os.path.expanduser(account["codexbar_command"])), "usage",- "--provider", account["provider"], "--format", "json"]+ "--provider", codexbar_name(account), "--format", "json"]if account.get("codexbar_source"):command += ["--source", account["codexbar_source"]]- env = scoped_env(account["provider"], Path(account["source_home"]).expanduser()) if account.get("source_home") else None+ env = (scoped_env(account["provider"], Path(account["source_home"]).expanduser())+ if account.get("source_home") and account["provider"] not in CODEXBAR_ONLY else None)try:result = subprocess.run(command, env=env, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,stderr=subprocess.DEVNULL, text=True, timeout=60)@@ -300,7 +319,7 @@ def codexbar_entry(data, account):"""This account's entry and whether CodexBar reported its email. Every reported email must match."""if not isinstance(data, list):raise SourceError("invalid_codexbar_output")- entries = [entry for entry in data if isinstance(entry, dict) and entry.get("provider") == account["provider"]]+ entries = [entry for entry in data if isinstance(entry, dict) and entry.get("provider") == codexbar_name(account)]if not entries:raise SourceError("codexbar_provider_missing")for entry in entries:@@ -369,7 +388,8 @@ def grok_identity(account):def imported_row(account):data = json.loads(Path(account["snapshot_file"]).expanduser().read_text())row = data["accounts"][account["key"]]- if row.get("provider") != account["provider"] or row.get("alias") != account["alias"]:+ provider = "antigravity" if row.get("provider") == "gemini" else row.get("provider") # from before Anti+ if provider != account["provider"] or row.get("alias") != account["alias"]:raise SourceError("identity_mismatch")fetched = timestamp(row.get("fetched_at"))if fetched is None or fetched > time.time() + 60:@@ -384,12 +404,15 @@ def imported_row(account):if last_success and last_success <= fetched:clean["last_success_at"] = last_successfor value in row.get("windows", []):- if value.get("label") not in {"5H", "WEEK", "WINDOW", "BUDGET"}:+ if str(value.get("label", "")).rstrip("2") not in {"5H", "WEEK", "WINDOW", "BUDGET", "MONTH", "CHAT", "DAY"}:continueitem = window(value["label"], value.get("used_percent"), value.get("resets_at"),value.get("duration_minutes"))if item:clean["windows"].append(item)+ credits = row.get("reset_credits") # saved limit resets come across too+ if isinstance(credits, dict) and isinstance(credits.get("count"), int) and not isinstance(credits["count"], bool):+ clean["reset_credits"] = {"count": max(0, credits["count"]), "expires_at": timestamp(credits.get("expires_at"))}if time.time() - fetched > 900:clean["status"] = "stale"clean["error_code"] = "laptop_offline"@@ -419,7 +442,11 @@ def fetch_account(account):row["windows"] = normalize_claude(data)row["identity_verified"] = Trueelif account["provider"] == "codex":- row["windows"] = normalize_codex(codex_payload(account))+ data = codex_payload(account)+ row["windows"] = normalize_codex(data)+ credits = reset_credits(data)+ if credits:+ row["reset_credits"] = creditsrow["identity_verified"] = Trueelse:if not identity_matches(account["email"], grok_identity(account)):diff --git a/token_tv/space.py b/token_tv/space.pyindex 0b15d71..ee205ed 100644--- a/token_tv/space.py+++ b/token_tv/space.py@@ -8,14 +8,14 @@ readings give identical bytes (no re-upload) while the choreography still change"""import functoolsimport hashlib-import ioimport mathimport randomimport timefrom PIL import Image, ImageDraw-from token_tv.display import ASSETS, overview_rows, pixel_text, primary_window+from token_tv import gif+from token_tv.display import ASSETS, overview_rows, pixel_text, shown_windowsSIZE = 240FPS = 10@@ -29,7 +29,6 @@ DIM = (128, 140, 178)EMPTY = (38, 48, 90)SPARK = (255, 216, 107)MOON = (233, 226, 200)-GROK_GLASS = (64, 78, 140)STARS = ((92, 104, 150), (170, 182, 220), (255, 255, 255))# Used-quota bands (below 50, 50–79, 80–89, 90–100): start and tip of each cell ramp.BANDS = (((42, 168, 74), (94, 224, 106)), ((143, 201, 58), (211, 232, 74)),@@ -50,6 +49,9 @@ def sprite(provider):flat = flat.quantize(colors=8, method=Image.Quantize.MEDIANCUT, dither=Image.Dither.NONE).convert('RGB')out = Image.new('RGBA', image.size, (0, 0, 0, 0))out.paste(flat, mask=alpha)+ if provider == 'grok': # white with dark eyes, as on every full-colour face+ from token_tv.themes import bot_sprite+ return bot_sprite('grok', image.width, image.height, '#f2f4f8', (12, 14, 20))return out@@ -79,7 +81,8 @@ def backdrop():def readings(snapshot):rows = []for row in overview_rows(snapshot):- value = primary_window(row)+ wins = shown_windows(row, 3) # one number per bubble: the weekly window where there is one+ value = wins[0] if wins else Noneused = max(0, min(100, value['used_percent'])) if value else Nonerows.append((row['provider'], used, bool(value) and row['status'] != 'ok'))return rows@@ -148,8 +151,7 @@ def positions(t, paths, events):def bubble(frame, draw, provider, x, y, mirrored):- # The black Grok bot needs lighter glass to stay visible on the night sky.- draw.ellipse((x - RADIUS, y - RADIUS, x + RADIUS, y + RADIUS), fill=GROK_GLASS if provider == 'grok' else GLASS, outline=RIM)+ draw.ellipse((x - RADIUS, y - RADIUS, x + RADIUS, y + RADIUS), fill=GLASS, outline=RIM)art = sprite(provider)if mirrored:art = art.transpose(Image.Transpose.FLIP_LEFT_RIGHT)@@ -178,7 +180,7 @@ def render_frames(snapshot, now=None):rnd = random.Random(seed_for(rows, now))paths = [(rnd.uniform(60, 82), rnd.uniform(24, 40), rnd.choice((1, 2)), 1,rnd.uniform(0, 6.3), rnd.uniform(0, 6.3), 120, cy)- for cy in {1: (106,), 2: (76, 136)}.get(len(rows), (54, 110, 160))]+ for cy in {1: (106,), 2: (76, 136), 4: (46, 90, 134, 178)}.get(len(rows), (54, 110, 160))]events = schedule(rnd, len(rows))sky, twinkles = backdrop()frames = []@@ -223,16 +225,4 @@ def render_space(snapshot, now=None, scale=1):frames = render_frames(snapshot, now)if scale != 1: # crisp enlargements for README and postsframes = [f.resize((SIZE * scale, SIZE * scale), Image.Resampling.NEAREST) for f in frames]- colours = set()- for frame in frames:- colours.update(c for _, c in frame.getcolors(maxcolors=frame.width * frame.height))- palette = sorted(colours)- if len(palette) > 256:- raise ValueError('Space face needs at most 256 colours')- reference = Image.new('P', (1, 1))- reference.putpalette([v for c in palette for v in c] + [0] * (768 - 3 * len(palette)))- indexed = [f.quantize(palette=reference, dither=Image.Dither.NONE) for f in frames]- buffer = io.BytesIO()- indexed[0].save(buffer, format='GIF', save_all=True, append_images=indexed[1:],- duration=1000 // FPS, loop=0, disposal=1, optimize=False)- return buffer.getvalue()+ return gif.encode(gif.indexed(frames, 'Space'), [1000 // FPS] * len(frames))diff --git a/token_tv/state.py b/token_tv/state.pyindex ccd9e30..73d5ca7 100644--- a/token_tv/state.py+++ b/token_tv/state.py@@ -6,11 +6,115 @@ from concurrent.futures import ThreadPoolExecutorfrom token_tv.sources import fetch_account+# An account counts as working for this long after its used % last went up. It outlasts the slowest+# fetch below, so a steady worker keeps running between readings.+ACTIVE_SECONDS = 600+# Claude's usage endpoint answers frequent callers with 429s, so its accounts are read at most every+# five minutes even when the clock refreshes every minute.+MIN_FETCH_SECONDS = {"claude": 300}+++def comparable(previous, row):+ """Two readings can be compared window by window only when they name the same windows: a reading where a+ window went missing (or a second one took its name) says nothing about work or resets."""+ return {w["label"] for w in previous.get("windows", [])} == {w["label"] for w in row.get("windows", [])}+++def rose(previous, row):+ """True when any window's used % is higher than the previous reading of the same window."""+ if row["status"] != "ok" or not comparable(previous, row):+ return False+ before = {w["label"]: w.get("used_percent") for w in previous.get("windows", [])}+ return any(w.get("used_percent") is not None and before.get(w["label"]) is not None+ and w["used_percent"] > before[w["label"]] for w in row["windows"])+++def ticket_spent(previous, row):+ """A saved reset was used: one fewer than before, and the one going first had not simply run out."""+ held, now_held = previous.get("reset_credits") or {}, row.get("reset_credits") or {}+ if held.get("count", 0) <= now_held.get("count", 0):+ return False+ expires = held.get("expires_at")+ return not expires or expires > row.get("fetched_at", 0)+++def event_of(previous, row):+ """'full' when a window reaches 100%, 'reset' when one falls back near zero or a saved reset is+ spent, else None."""+ if row["status"] != "ok":+ return None+ spent = ticket_spent(previous, row)+ before = {w["label"]: w.get("used_percent") for w in previous.get("windows", [])} if comparable(previous, row) else {}+ event = None+ resets = {w["label"]: w.get("resets_at") for w in previous.get("windows", [])}+ for w in row["windows"]:+ old, new = before.get(w["label"]), w.get("used_percent")+ if old is None or new is None:+ continue+ if old < 100 <= new:+ return "full"+ was, now_at = resets.get(w["label"]), w.get("resets_at")+ # a minute's leeway for the provider's clock against ours+ due = not was or was <= row["fetched_at"] + 60 or (now_at and now_at - was > 3600)+ if old - new >= 20 and new <= 10 and due: # a drop before its reset time is a correction, not a reset+ event = "reset"+ return event or ("reset" if spent and row.get("reset_credits") else None)+++NEWS_SECONDS = 600 # what a reading brought (a jump, a crossing, a spent reset) stays news this long+++RATE_SECONDS = 600 # a jump is the rise in used % over ten minutes+++def trail_of(row):+ """The good readings behind `row` for rates, oldest first: [(measured at, {label: used %})], the ones in the+ ten minutes before it and its own (a stale row keeps the windows and the time they were measured)."""+ since = row.get("last_success_at") or row.get("fetched_at")+ own = [(since, {w["label"]: w.get("used_percent") for w in row.get("windows", [])})] if since else []+ return [tuple(point) for point in row.get("trail") or ()] + own+++def news_of(previous, row):+ """What this reading brought, for the hidden one-offs (`lockbox.py`): the sharpest rise in used % (per ten+ minutes, so a reading after a long gap is not a sudden jump), the thresholds crossed, the account's first rise+ of the day, its return after an hour or more without a rise, and a spent saved reset with the days it still had.+ Each item is {'kind', 'value', 'at'}."""+ at, out = row["fetched_at"], []+ if row["status"] != "ok":+ return out+ before = {w["label"]: w.get("used_percent") for w in previous.get("windows", [])} if comparable(previous, row) else {}+ jumps, crossed = [0], set()+ for w in row["windows"]:+ old, new = before.get(w["label"]), w.get("used_percent")+ if old is None or new is None:+ continue+ for then, used in trail_of(previous): # the rise over the last ten minutes, or its pace over a longer gap+ was = used.get(w["label"])+ if was is not None and at > then:+ jumps.append((new - was) * RATE_SECONDS / max(RATE_SECONDS, at - then))+ crossed.update((t, w["label"]) for t in (70, 80, 90, 95, 100) if old < t <= new)+ if max(jumps) > 0:+ out.append({"kind": "jump", "value": max(jumps), "at": at})+ out += [{"kind": "crossed", "value": t, "label": label, "at": at} for t, label in sorted(crossed)]+ last = previous.get("rose_at")+ if rose(previous, row) and (not last or time.localtime(last)[:3] != time.localtime(at)[:3]):+ out.append({"kind": "first_today", "value": True, "at": at})+ if rose(previous, row) and last and at - last >= 3600: # back at work after a break of an hour or more+ out.append({"kind": "back", "value": round((at - last) / 3600, 1), "at": at})+ held, now_held = previous.get("reset_credits") or {}, row.get("reset_credits")+ if now_held and ticket_spent(previous, row):+ expires = held.get("expires_at")+ out.append({"kind": "ticket_spent", "value": (expires - at) / 86400 if expires else 99, "at": at})+ return out+class UsageStore:- def __init__(self, accounts, fetch=fetch_account):+ def __init__(self, accounts, fetch=fetch_account, min_fetch_seconds=None):self.accounts = accountsself.fetch = fetch+ self.min_fetch_seconds = min_fetch_seconds or {}+ self.fetched = {} # account key -> monotonic time of its last fetchself.lock = threading.Lock()self.updated_at = 0self.rows = {a["key"]: {"key": a["key"], "alias": a["alias"], "provider": a["provider"],@@ -18,18 +122,52 @@ class UsageStore:"identity_verified": False, "source": "mini"}for a in accounts}+ def restore(self, snapshot):+ """Carry over when each account last rose (and its run's start) from the snapshot the last run wrote,+ so a restart does not make a second 'first use of the day' or forget a break."""+ for key, old in (snapshot or {}).get("accounts", {}).items():+ if key in self.rows and isinstance(old, dict):+ for field in ("rose_at", "active_since"):+ if isinstance(old.get(field), (int, float)) and not isinstance(old.get(field), bool):+ self.rows[key][field] = old[field]+def refresh(self):- with ThreadPoolExecutor(max_workers=min(4, len(self.accounts))) as executor:- rows = list(executor.map(self.fetch, self.accounts))+ started = time.monotonic()+ # A few seconds of slack so a five-minute account is not pushed to the next one-minute tick.+ due = [a for a in self.accounts if a["key"] not in self.fetched+ or started - self.fetched[a["key"]] + 15 >= self.min_fetch_seconds.get(a["provider"], 0)]+ if not due:+ return+ with ThreadPoolExecutor(max_workers=min(4, len(due))) as executor:+ rows = list(executor.map(self.fetch, due))with self.lock:+ for account in due:+ self.fetched[account["key"]] = startedfor row in rows:previous = self.rows[row["key"]]+ row["rose_at"] = row["fetched_at"] if rose(previous, row) else previous.get("rose_at")+ if rose(previous, row): # the start of this run of work, kept while it goes on+ going = previous.get("rose_at") and row["fetched_at"] - previous["rose_at"] < ACTIVE_SECONDS+ row["active_since"] = previous.get("active_since") if going else row["fetched_at"]+ else:+ row["active_since"] = previous.get("active_since")+ row["news"] = [item for item in previous.get("news", [])+ if row["fetched_at"] - item["at"] < NEWS_SECONDS] + news_of(previous, row)+ row["trail"] = [point for point in trail_of(previous) if row["fetched_at"] - point[0] < RATE_SECONDS] \+ if row["status"] == "ok" else previous.get("trail", [])+ peak = max((w.get("used_percent") or 0 for w in row.get("windows", [])), default=0)+ row["worry"] = (peak >= 90 or (bool(previous.get("worry")) and peak >= 85) # on at 90, off below 85+ if row["status"] == "ok" else previous.get("worry")) # an outage changes nothing+ event = event_of(previous, row) # a one-off for the animated faces: fireworks or a flop+ row["event"], row["event_at"] = (event, row["fetched_at"]) if event else (previous.get("event"), previous.get("event_at"))if row["status"] in ("ok", "quota_unavailable"):row["last_success_at"] = row["fetched_at"]elif row["status"] != "identity_mismatch" and previous.get("windows") and previous.get("last_success_at"):row["error_code"] = row.get("error_code", row["status"])row["status"] = "stale"row["windows"] = previous["windows"]+ if previous.get("reset_credits"):+ row["reset_credits"] = previous["reset_credits"]row["last_success_at"] = previous["last_success_at"]row["identity_verified"] = previous.get("identity_verified", False)self.rows[row["key"]] = row@@ -44,6 +182,7 @@ class UsageStore:if row["status"] == "ok" and now - row.get("last_success_at", row["fetched_at"]) > 900:row["status"] = "stale"row.setdefault("error_code", "snapshot_old")+ row["active"] = bool(row.get("rose_at")) and now - row["rose_at"] < ACTIVE_SECONDSby_label = {w["label"]: w for w in row["windows"]}for prefix, label in (("session", "5H"), ("weekly", "WEEK")):value = by_label.get(label, {})diff --git a/token_tv/themes.py b/token_tv/themes.pyindex 92717b5..3e7717f 100644--- a/token_tv/themes.py+++ b/token_tv/themes.py@@ -12,7 +12,8 @@ from pathlib import Pathfrom PIL import Image, ImageDraw, ImageFilter, ImageFontfrom token_tv.display import (- PROVIDER_INK, account_label, mascot, overview_rows, quota_period, reading, row_shift, time_left,+ PROVIDER_INK, account_label, fit_text, mascot, overview_rows, quota_period, reading, row_shift, shown_windows,+ slots, time_left,)WEB = Path(__file__).with_name('web')@@ -29,9 +30,12 @@ BANDS = {'hud': (('#14a874', '#35e0a0'), ('#1a7dff', '#3cc4ff'), ('#ff7a1a', '#ffb23f'), ('#e01e3c', '#ff4d6a')),}ACCENT = {- 'neon': {'claude': ('#ff8a2b', '#ffd23f'), 'codex': ('#7a9dff', '#b1a7ff'), 'grok': ('#e8eaf0', '#ffffff')},- 'retro': {'claude': ('#ff9f43', '#ffcf6b'), 'codex': ('#3ee68b', '#9bffc8'), 'grok': ('#b388ff', '#e0d0ff')},- 'hud': {'claude': ('#ff8a3d', '#ffb47a'), 'codex': ('#7a9dff', '#b1a7ff'), 'grok': ('#dfe3ea', '#ffffff')},+ 'neon': {'claude': ('#ff8a2b', '#ffd23f'), 'codex': ('#7a9dff', '#b1a7ff'), 'grok': ('#e8eaf0', '#ffffff'),+ 'copilot': ('#22c7e0', '#5fe8cf'), 'antigravity': ('#78b6ee', '#e77345')},+ 'retro': {'claude': ('#ff9f43', '#ffcf6b'), 'codex': ('#3ee68b', '#9bffc8'), 'grok': ('#b388ff', '#e0d0ff'),+ 'copilot': ('#2fd0c0', '#8ff0e4'), 'antigravity': ('#78b6ee', '#94c45f')},+ 'hud': {'claude': ('#ff8a3d', '#ffb47a'), 'codex': ('#7a9dff', '#b1a7ff'), 'grok': ('#dfe3ea', '#ffffff'),+ 'copilot': ('#2fb8e8', '#7fe3f0'), 'antigravity': ('#78b6ee', '#e89646')},}@@ -129,6 +133,14 @@ def glyph(provider, size, color, stroke=None):draw.line([(x * k, y * k) for x, y in hexagon], fill=color, width=width, joint='curve')for end in ((7.5, 14.5), (40.5, 14.5), (24, 43)):draw.line((24 * k, 24 * k, end[0] * k, end[1] * k), fill=color, width=width)+ elif provider == 'copilot': # its goggles+ r = s * 0.2+ for cx in (c - s * 0.22, c + s * 0.22):+ draw.ellipse((cx - r, c - r, cx + r, c + r), outline=color, width=width)+ elif provider == 'antigravity': # its arch+ draw.arc((s * .14, s * .18, s * .86, s * 1.5), 180, 360, fill=color, width=round(width * 1.6))+ for side in (s * .14, s * .86 - width * 1.6):+ draw.rectangle((side, s * .84, side + width * 1.6, s * .9), fill=color)else:r = s * 0.27draw.ellipse((c - r, c - r, c + r, c + r), outline=color, width=width)@@ -295,6 +307,35 @@ def number_text(used):return '--' if used is None else str(round(used))+def window_lines(cv, row, wins, box, skin):+ """Both windows (5H above WEEK) in a roomy row: each a name, a number, its reset and a gauge."""+ x0, y0, x1, y1 = box+ line = (y1 - y0) / len(wins)+ for i, value in enumerate(wins):+ used, period, old, reset = reading(row, value)+ top = y0 + i * line+ gh = max(4, round(line * .11))+ band_h = line - gh - 6+ nsize = max(12, min(skin['num_max'], round(band_h * .78)))+ lsize = max(7, round(nsize * .45))+ mid = top + band_h / 2 + 1+ label_font, num_font = skin['label'](lsize), skin['num'](nsize)+ cv.text((x0, round(mid - lsize / 2)), period + (' OLD' if old else ''), label_font,+ skin['old'] if old else skin['dim'], **skin.get('label_args', {}))+ nx = x0 + cv.draw.textlength(period + (' OLD' if old else ''), font=label_font) + max(4, lsize // 2)+ number = number_text(used)+ cv.text((round(nx), round(mid - nsize / 2)), number, num_font, skin['ink'], **skin.get('num_args', {}))+ if used is not None:+ px = nx + cv.draw.textlength(number, font=num_font) + 2+ cv.text((round(px), round(mid + nsize / 2 - lsize)), '%', skin['label'](lsize), skin['ink'])+ shown = skin.get('reset_fmt', lambda r: r)(reset)+ cv.text((x1, round(mid - skin.get('reset_size', lsize) / 2)), shown, skin.get('reset_font', skin['label'])(skin.get('reset_size', lsize)),+ skin.get('reset_ink', skin['ink']), anchor='ra', **skin.get('reset_args', {}))+ gy = round(top + line - gh - 3)+ style = dict(skin['gauge'](used, old))+ gauge(cv, (x0, gy, x1, gy + gh), used, style.pop('colors'), **style)++def render_digital(snapshot):mint, dim, line, amber, unlit = '#7dffd0', '#4dbb92', '#22694f', '#ffcf5a', '#0d3326'cv = Canvas('#020906')@@ -302,31 +343,53 @@ def render_digital(snapshot):cv.back.line((0, y, SIZE, y), fill='#04130d')vt, seg = (lambda s: face('vt323.woff2', s)), (lambda s: face('dseg7-classic-bold.woff2', s))rows = overview_rows(snapshot)- for index, row in enumerate(rows):- y = ROWS[index] + row_shift(len(rows), ROWS[1] - ROWS[0])- used, period, old, reset = reading(row)- cv.back.rectangle((4, y, 235, y + ROW_H - 1), fill='#03100b', outline=line)- cv.back.line((5, y + 25, 234, y + 25), fill='#0f3a2c')+ for sl, row in zip(slots(len(rows)), rows):+ y, at, hero = sl.y, sl.at, sl.count == 1+ wins = shown_windows(row, sl.count)+ used, period, old, reset = reading(row, wins[0] if wins else None)+ cv.back.rectangle((4, y, 235, y + sl.h - 1), fill='#03100b', outline=line)+ bw, bh = round(24 * sl.icon), round(17 * sl.icon)+ head = y + bh + 8 if hero else at(25)+ cv.back.line((5, head, 234, head), fill='#0f3a2c')# LCD: the bot lit in the same mint phosphor as the text, dark eyes, soft glow; no brand colours.- place_bot(cv.ink, bot_sprite(row['provider'], 24, 17, mint, '#03100b'), (9, y + 4, 24, 17))- place_bot(cv.bloom, bot_sprite(row['provider'], 24, 17, (61, 252, 176), '#03100b'), (9, y + 4, 24, 17))- cv.text((38, y + 3), account_label(row) + ' >', vt(22), mint, glow=(61, 252, 176, 90))- cv.text((229, y + 4), period + (' OLD' if old else ''), vt(20), amber if old else dim, anchor='ra')+ bot = (9, y + 4 if hero else at(4), bw, bh)+ place_bot(cv.ink, bot_sprite(row['provider'], bw, bh, mint, '#03100b'), bot)+ place_bot(cv.bloom, bot_sprite(row['provider'], bw, bh, (61, 252, 176), '#03100b'), bot)+ note = '' if len(wins) == 2 else ('OLD' if old else '') if sl.count == 4 else period + (' OLD' if old else '')+ room = 229 - (bw + 14) - (cv.draw.textlength(note, font=vt(sl.txt(20))) + 10 if note else 0)+ name = fit_text(cv.draw, account_label(row), vt(sl.txt(22)), room - cv.draw.textlength(' >', font=vt(sl.txt(22))))+ cv.text((bw + 14, bot[1] - 1), name + ' >', vt(sl.txt(22)), mint, glow=(61, 252, 176, 90))+ if len(wins) == 2: # room for both windows: 5H above WEEK+ window_lines(cv, row, wins, (11, head + 4, 229, y + sl.h - 4), {+ 'label': vt, 'num': seg, 'num_max': 40, 'ink': mint, 'dim': dim, 'old': amber,+ 'num_args': {'glow': (61, 252, 176, 120)}, 'reset_font': seg, 'reset_fmt': segment_time,+ 'reset_ink': amber, 'reset_args': {'glow': (255, 190, 70, 120)},+ 'gauge': lambda u, o: {'colors': band('digital', u or 0), 'gap': 3, 'track': '#0b2a1f',+ 'empty': '#2a6b52', 'stale': o, 'split': '#03100b', 'glow': True}})+ continue+ cv.text((229, bot[1]), note, vt(sl.txt(20)), amber if old else dim, anchor='ra')+ top = head + 12 if hero else at(32)if used is None:- cv.text((11, y + 31), '-- NO DATA', vt(26), dim)+ cv.text((11, top - 1), '-- NO DATA', vt(sl.num(26)), dim)else:number = number_text(used)- cv.text((11, y + 32), ghost(number), seg(25), unlit)- cv.text((11, y + 32), number, seg(25), mint, glow=(61, 252, 176, 120))- x = 11 + cv.draw.textlength(number, font=seg(25)) + 3- cv.text((x, y + 38), '%', vt(24), mint)+ cv.text((11, top), ghost(number), seg(sl.num(25)), unlit)+ cv.text((11, top), number, seg(sl.num(25)), mint, glow=(61, 252, 176, 120))+ x = 11 + cv.draw.textlength(number, font=seg(sl.num(25))) + 3+ cv.text((x, top + round(6 * sl.big)), '%', vt(sl.num(24)), mint)if reset != '--':clock = segment_time(reset)- cv.text((229, y + 28), 'RESETS IN', vt(16), dim, anchor='ra')- cv.text((229, y + 43), ghost(clock), seg(14), '#2a2108', anchor='ra')- cv.text((229, y + 43), clock, seg(14), amber, glow=(255, 190, 70, 120), anchor='ra')- gauge(cv, (11, y + 61, 229, y + 70), used, band('digital', used or 0), gap=3, track='#0b2a1f',- empty='#2a6b52', stale=old, split='#03100b', glow=True)+ ry = top + sl.num(25) + 16 if hero else at(28)+ if sl.count < 4:+ cv.text((229, ry), 'RESETS IN', vt(sl.txt(16)), dim, anchor='ra')+ cy = ry + sl.txt(15)+ else: # four rows: just the time, clear of the gauge+ cy = at(30)+ cv.text((229, cy), ghost(clock), seg(sl.txt(14)), '#2a2108', anchor='ra')+ cv.text((229, cy), clock, seg(sl.txt(14)), amber, glow=(255, 190, 70, 120), anchor='ra')+ gy = y + sl.h - 15 if hero else at(61)+ gauge(cv, (11, gy, 229, gy + max(6, round(9 * min(sl.k, 1.3)))), used, band('digital', used or 0), gap=3,+ track='#0b2a1f', empty='#2a6b52', stale=old, split='#03100b', glow=True)return cv.finish(blur=2)@@ -338,47 +401,76 @@ def render_neon(snapshot):cv.back.point((x, y), fill='#0e0b1c')orb, ox = (lambda s, w=700: face('orbitron.ttf', s, w)), (lambda s, w=800: face('oxanium.woff2', s, w))rows = overview_rows(snapshot)- for index, row in enumerate(rows):- y = ROWS[index] + row_shift(len(rows), ROWS[1] - ROWS[0])+ for sl, row in zip(slots(len(rows)), rows):+ y, at, hero = sl.y, sl.at, sl.count == 1a, a2 = ACCENT['neon'][row['provider']]- used, period, old, reset = reading(row)- box = (5, y + 1, 234, y + ROW_H - 2)+ wins = shown_windows(row, sl.count)+ used, period, old, reset = reading(row, wins[0] if wins else None)+ box = (5, y + 1, 234, y + sl.h - 2)cv.back.rounded_rectangle(box, radius=12, fill=mix('#06050e', a, .05))cv.glow.rounded_rectangle(box, radius=12, outline=rgb(a) + (255,), width=3)cv.draw.rounded_rectangle(box, radius=12, outline=mix(a, '#ffffff', .45), width=1)# Neon: each row is already lit in its provider colour, so the bot takes that same colour with a halo.- place_bot(cv.ink, bot_sprite(row['provider'], 26, 26, mix(a, '#ffffff', .35)), (12, y + 9, 26, 26))- place_bot(cv.bloom, bot_sprite(row['provider'], 26, 26, a), (12, y + 9, 26, 26))- cv.text((46, y + 9), account_label(row), orb(11), '#ffffff')- cv.text((228, y + 9), period + (' OLD' if old else ''), orb(10), '#ff5d8f' if old else mix(a, '#ffffff', .2),+ bs = round(26 * sl.icon)+ bot = (12, y + 10 if hero else at(9), bs, bs)+ place_bot(cv.ink, bot_sprite(row['provider'], bs, bs, mix(a, '#ffffff', .35)), bot)+ place_bot(cv.bloom, bot_sprite(row['provider'], bs, bs, a), bot)+ note = '' if len(wins) == 2 else ('OLD' if old else '') if sl.count == 4 else period + (' OLD' if old else '')+ room = 228 - (bs + 20) - (cv.draw.textlength(note, font=orb(sl.txt(10))) + 8 if note else 0)+ cv.text((bs + 20, bot[1]), fit_text(cv.draw, account_label(row), orb(sl.txt(11)), room), orb(sl.txt(11)), '#ffffff')+ if len(wins) == 2: # room for both windows: 5H above WEEK+ body = (16, bot[1] + bs + 4, 226, y + sl.h - 6) if hero else (bs + 20, bot[1] + sl.txt(11) + 6, 226, y + sl.h - 6)+ window_lines(cv, row, wins, body, {+ 'label': lambda z: orb(z, 700), 'num': ox, 'num_max': 44, 'ink': '#ffffff',+ 'dim': mix(a, '#ffffff', .2), 'old': '#ff5d8f', 'num_args': {'glow': rgb(a) + (150,)},+ 'reset_font': lambda z: ox(z, 700), 'reset_args': {'glow': rgb(a) + (170,)},+ 'gauge': lambda u, o: {'colors': band('neon', u or 0), 'gap': 3, 'shape': 'round', 'radius': 3,+ 'track': '#15122a', 'empty': '#4a4170', 'stale': o, 'glow': True}})+ continue+ cv.text((228, bot[1]), note, orb(sl.txt(10)), '#ff5d8f' if old else mix(a, '#ffffff', .2),glow=rgb(a) + (160,), anchor='ra')number = number_text(used)- cv.text((45, y + 22), number, ox(33), '#ffffff')- cv.glow.text((45, y + 22), number, font=ox(33), fill=rgb(a) + (255,), stroke_width=2, stroke_fill=rgb(a) + (255,))+ nx, ny = (16, bot[1] + bs + 10) if hero else (bs + 19, at(22))+ cv.text((nx, ny), number, ox(sl.num(33)), '#ffffff')+ cv.glow.text((nx, ny), number, font=ox(sl.num(33)), fill=rgb(a) + (255,), stroke_width=2, stroke_fill=rgb(a) + (255,))if used is not None:- x = 45 + cv.draw.textlength(number, font=ox(33)) + 2- cv.text((x, y + 36), '%', ox(16, 700), mix(a, '#ffffff', .6))- cv.text((228, y + 31), reset, ox(17, 700), '#ffffff', glow=rgb(a) + (170,), anchor='ra')- ring = 228 - cv.draw.textlength(reset, font=ox(17, 700)) - 12- clock_mark(cv, (ring, y + 40), 7, mix(a, '#ffffff', .3), 1)- cv.glow.ellipse((ring - 8, y + 32, ring + 8, y + 48), outline=rgb(a) + (220,), width=2)- gauge(cv, (14, y + 59, 226, y + 66), used, band('neon', used or 0), gap=3, shape='round', radius=3,- track='#15122a', empty='#4a4170', stale=old, glow=True)+ x = nx + cv.draw.textlength(number, font=ox(sl.num(33))) + 2+ cv.text((x, ny + round(14 * sl.big)), '%', ox(sl.num(16), 700), mix(a, '#ffffff', .6))+ ry = ny + sl.num(33) + 14 if hero else at(31)+ cv.text((228, ry), reset, ox(sl.txt(17), 700), '#ffffff', glow=rgb(a) + (170,), anchor='ra')+ ring = 228 - cv.draw.textlength(reset, font=ox(sl.txt(17), 700)) - round(12 * sl.small)+ cr, cy = round(7 * sl.small), ry + round(9 * sl.small)+ clock_mark(cv, (ring, cy), cr, mix(a, '#ffffff', .3), 1)+ cv.glow.ellipse((ring - cr - 1, cy - cr - 1, ring + cr + 1, cy + cr + 1), outline=rgb(a) + (220,), width=2)+ gy = y + sl.h - 17 if hero else at(59)+ gauge(cv, (14, gy, 226, gy + max(5, round(7 * min(sl.k, 1.4)))), used, band('neon', used or 0), gap=3,+ shape='round', radius=3, track='#15122a', empty='#4a4170', stale=old, glow=True)return cv.finish(blur=3)-def pixel_scene(cv, provider, top):- """A 2-px pixel landscape behind each Pixel Retro row (sunset / forest city / space)."""- rnd = random.Random({'claude': 11, 'codex': 23, 'grok': 37}[provider])+def pixel_scene(cv, provider, top, height=ROW_H):+ """A 2-px pixel landscape behind each Pixel Retro row (sunset / forest city / space).++ Sky things keep to the top and the ground to the bottom, so the scene fits any row height.+ """+ rnd = random.Random({'claude': 11, 'codex': 23, 'grok': 37, 'copilot': 41, 'antigravity': 53}[provider])sky = {'claude': ('#2a1330', '#3a1834', '#4d1f36', '#652836', '#7f3335', '#9a4133'),'codex': ('#06171d', '#082027', '#0b2a2e', '#0e3434', '#113f39', '#15493e'),- 'grok': ('#0d0a28', '#120d33', '#170f3e', '#1c1349', '#211654', '#271a5f')}[provider]+ 'grok': ('#0d0a28', '#120d33', '#170f3e', '#1c1349', '#211654', '#271a5f'),+ 'copilot': ('#062033', '#072a40', '#08344d', '#0a3f5b', '#0c4a68', '#0f5676'),+ 'antigravity': ('#020208', '#03030c', '#040410', '#050514', '#060618', '#07071c')}[provider]d = cv.back+ band = (height - 4) / 6for i, color in enumerate(sky):- d.rectangle((6, top + 2 + i * 12, 233, top + 2 + (i + 1) * 12), fill=color)+ d.rectangle((6, top + 2 + round(i * band), 233, top + 2 + round((i + 1) * band)), fill=color)+ drop = (height - ROW_H) // 2 # ground rows move with the bottom edge- def px(x, y, color, w=1, h=1):- d.rectangle((x * 2, top + y * 2, x * 2 + w * 2 - 1, top + y * 2 + h * 2 - 1), fill=color)+ def px(x, y, color, w=1, h=1, ground=False):+ y0 = top + (y + (drop if ground else 0)) * 2+ y1 = min(top + height - 3, y0 + h * 2 - 1)+ if y0 < top + 2 or y0 > y1:+ return+ d.rectangle((x * 2, y0, x * 2 + w * 2 - 1, y1), fill=color)def disc(cx, cy, r, color):for dy in range(-r, r + 1):@@ -391,9 +483,9 @@ def pixel_scene(cv, provider, top):px(59, yy, sky[2], 15)heights = [30 - round(5 * max(0, math.sin((x - 20) / 9)) + 2 * math.sin(x / 3)) for x in range(3, 117)]for x, h in zip(range(3, 117), heights):- px(x, h, '#5a2236', 1, 37 - h)+ px(x, h, '#5a2236', 1, 37 - h + max(0, -drop), True)for x in range(3, 117):- px(x, 33 - round(math.sin(x / 4)), '#371428', 1, 5)+ px(x, 33 - round(math.sin(x / 4)), '#371428', 1, 5, True)elif provider == 'codex':for _ in range(14):px(rnd.randrange(20, 116), rnd.randrange(1, 12), '#9bffd2')@@ -401,21 +493,36 @@ def pixel_scene(cv, provider, top):x = 40while x < 116:w, h = rnd.randrange(3, 6), rnd.randrange(6, 13)- px(x, 32 - h, '#0b3530', w, h + 5)+ px(x, 32 - h, '#0b3530', w, h + 5, True)for wy in range(33 - h, 31, 2):if rnd.random() > .5:- px(x + 1, wy, '#7dffb9')+ px(x + 1, wy, '#7dffb9', ground=True)x += w + 1for p in range(3, 117, 3):- px(p, 33, '#05201a', 2, 5)+ px(p, 33, '#05201a', 2, 5, True)+ elif provider == 'copilot': # a teal-to-blue sky over a floor of clouds+ for _ in range(12):+ px(rnd.randrange(20, 116), rnd.randrange(1, 10), '#9fe8ff')+ for cx, cy, r in ((72, 9, 3), (76, 8, 4), (81, 9, 3)):+ disc(cx, cy, r, '#bfefff')+ for x in range(3, 117):+ px(x, 31 - round(1.5 * abs(math.sin(x / 5))), '#2b86b8', 1, 7, True)+ px(x, 33 - round(abs(math.sin(x / 3))), '#1b5f88', 1, 5, True)+ elif provider == 'antigravity': # a dark maze: two walls, a row of dots between them, a power pellet+ for x in range(40, 117):+ px(x, 3, '#2121de')+ px(x, 30, '#2121de', 1, 1, True)+ for x in range(44, 114, 4):+ px(x, 16, '#ffb8ae')+ disc(52, 9, 2, '#ffb8ae')else:for _ in range(40):- px(rnd.randrange(3, 116), rnd.randrange(1, 30), rnd.choice(('#efe6ff', '#b9a6ff')))+ px(rnd.randrange(3, 116), round(rnd.randrange(1, 30) * (height - 16) / (ROW_H - 16)), rnd.choice(('#efe6ff', '#b9a6ff')))disc(66, 10, 5, '#8f6cf2'); disc(65, 9, 3, '#a98bff')for i in range(-9, 10):px(66 + i, 11 - round(i * .28), '#e2d6ff' if abs(i) < 5 else '#bca8ff')for x in range(3, 117):- px(x, 33 - round(2 * abs(math.sin(x / 7))), '#120c33', 1, 6)+ px(x, 33 - round(2 * abs(math.sin(x / 7))), '#120c33', 1, 6, True)def render_retro(snapshot):@@ -427,29 +534,61 @@ def render_retro(snapshot):cv.back.point((x, y), fill=rnd.choice(('#ffffff', '#b9c8ff', '#ffe9a8')))title = lambda s: face('press-start-2p.ttf', s)rows = overview_rows(snapshot)- for index, row in enumerate(rows):- y = ROWS[index] + row_shift(len(rows), ROWS[1] - ROWS[0])+ for sl, row in zip(slots(len(rows)), rows):+ y, at, hero, h = sl.y, sl.at, sl.count == 1, sl.ha, a2 = ACCENT['retro'][row['provider']]- used, period, old, reset = reading(row)- pixel_scene(cv, row['provider'], y)- cv.back.rectangle((4, y, 235, y + ROW_H - 1), outline=outline_ink, width=2)- cv.back.rectangle((6, y + 2, 233, y + ROW_H - 3), outline=a, width=2)- for cx, cy in ((4, y), (234, y), (4, y + ROW_H - 2), (234, y + ROW_H - 2)):+ wins = shown_windows(row, sl.count)+ used, period, old, reset = reading(row, wins[0] if wins else None)+ pixel_scene(cv, row['provider'], y, h)+ cv.back.rectangle((4, y, 235, y + h - 1), outline=outline_ink, width=2)+ cv.back.rectangle((6, y + 2, 233, y + h - 3), outline=a, width=2)+ for cx, cy in ((4, y), (234, y), (4, y + h - 2), (234, y + h - 2)):cv.back.rectangle((cx, cy, cx + 1, cy + 1), fill='#0a0f2c')- cv.draw.rectangle((11, y + 8, 50, y + 47), fill=outline_ink, outline=a, width=2)- if row['provider'] == 'grok':- cv.draw.rectangle((16, y + 13, 45, y + 42), fill='#d9ccff')- mascot(cv.ink, row['provider'], (7, y + 4), pixel=True, size=32)- cv.text((57, y + 9), account_label(row), title(8), cream, stroke_width=1, stroke_fill=outline_ink)- cv.text((57, y + 22), number_text(used) + ('%' if used is not None else ''), title(16), cream,- stroke_width=2, stroke_fill=outline_ink)- cv.text((57, y + 41), period + (' OLD' if old else ''), title(8), '#ff9a9a' if old else '#b9d2ff', stroke_width=1, stroke_fill=outline_ink)- cv.draw.rectangle((153, y + 9, 228, y + 40), fill=outline_ink, outline=a, width=2)- cv.text((159, y + 14), 'RESET IN', title(8), '#a9bdf0')- cv.text((159, y + 27), reset.upper(), title(8), cream)- cv.draw.rectangle((10, y + 51, 229, y + 66), fill=outline_ink)- cv.draw.rectangle((12, y + 53, 227, y + 64), outline='#3a4fb0')- gauge(cv, (14, y + 55, 225, y + 62), used, band('retro', used or 0), gap=2, track='#19235f',+ tile = round(40 * sl.icon)+ tx, ty = 11, (y + 8 if hero else at(8))+ cv.draw.rectangle((tx, ty, tx + tile - 1, ty + tile - 1), fill=outline_ink, outline=a, width=2)+ inner = tile - 10+ if row['provider'] == 'grok': # white on the dark tile+ art = bot_sprite('grok', inner // 2, inner // 2, '#f2f4f8')+ place_bot(cv.ink, art.resize((art.width * 2, art.height * 2), Image.Resampling.NEAREST),+ (tx + 5, ty + 5, inner, inner))+ else:+ mascot(cv.ink, row["provider"], (tx - 4, ty - 4), pixel=True,+ size=round(32 * sl.icon), box=tile + 8)+ lx = tx + tile + 6+ room = (225 - lx) if hero or len(wins) == 2 else (147 - lx) # clear of the reset box+ cv.text((lx, ty + 1), fit_text(cv.draw, account_label(row), title(sl.txt(8)), room), title(sl.txt(8)), cream,+ stroke_width=1, stroke_fill=outline_ink)+ if len(wins) == 2: # room for both windows: 5H above WEEK, on a dark plate over the scene+ body = (14, ty + tile + 8, 225, y + h - 8) if hero else (lx, ty + sl.txt(8) + 8, 225, y + h - 8)+ cv.draw.rectangle((body[0] - 4, body[1] - 3, body[2] + 4, body[3] + 3), fill=outline_ink, outline=a, width=2)+ window_lines(cv, row, wins, body, {+ 'label': title, 'num': title, 'num_max': 22, 'ink': cream, 'dim': '#b9d2ff', 'old': '#ff9a9a',+ 'gauge': lambda u, o: {'colors': band('retro', u or 0), 'gap': 2, 'track': '#19235f', 'empty': '#3a4ea8',+ 'stale': o, 'shade': True, 'stepped': True}})+ continue+ text = number_text(used) + ('%' if used is not None else '')+ nx, ny = (14, ty + tile + 10) if hero else (lx, at(22))+ cv.text((nx, ny), text, title(sl.num(16)), cream, stroke_width=2, stroke_fill=outline_ink)+ py = ty + sl.txt(8) + 12 if hero else at(41)+ cv.text((lx, py), period + (' OLD' if old else ''), title(sl.txt(8)), '#ff9a9a' if old else '#b9d2ff',+ stroke_width=1, stroke_fill=outline_ink)+ end = nx + cv.draw.textlength(text, font=title(sl.num(16))) + 8+ bx0 = max(153, round(end)) if not hero else 128+ by0, by1 = (ny, ny + 31) if hero else (at(9), at(40))+ if hero and end > 120: # a long number pushes the reset box under it+ by0, by1 = ny + sl.num(16) + 10, ny + sl.num(16) + 41+ cv.draw.rectangle((bx0, by0, 228, by1), fill=outline_ink, outline=a, width=2)+ if sl.count == 4: # a short row: just the time, centred in its box+ cv.text((bx0 + 6, (by0 + by1) // 2 - 4), reset.upper(), title(8), cream)+ else:+ cv.text((bx0 + 6, by0 + 5), 'RESET IN', title(sl.txt(8) if bx0 < 160 else 8), '#a9bdf0')+ cv.text((bx0 + 6, by0 + 18), reset.upper(), title(sl.txt(8) if bx0 < 160 else 8), cream)+ gy = y + h - 25 if hero else at(51)+ gh = max(12, round(15 * min(sl.k, 1.3)))+ cv.draw.rectangle((10, gy, 229, gy + gh), fill=outline_ink)+ cv.draw.rectangle((12, gy + 2, 227, gy + gh - 2), outline='#3a4fb0')+ gauge(cv, (14, gy + 4, 225, gy + gh - 4), used, band('retro', used or 0), gap=2, track='#19235f',empty='#3a4ea8', stale=old, shade=True, stepped=True)return cv.finish()@@ -465,7 +604,7 @@ def retro_dual_windows(row):def render_retro_dual(snapshot):"""Pixel Retro cards with both the 5-hour and the weekly window per account, not just the more used one."""outline_ink, cream, dim, old_ink = '#0a0d26', '#fff3d6', '#b9d2ff', '#ff9a9a'- ground = {'claude': '#371428', 'codex': '#05201a', 'grok': '#120c33'}+ ground = {'claude': '#371428', 'codex': '#05201a', 'grok': '#120c33', 'copilot': '#0a3f5b', 'antigravity': '#050514'}cv = Canvas('#0a0f2c')rnd = random.Random(5)for _ in range(70):@@ -527,34 +666,53 @@ def render_hud(snapshot):cv.back.line((0, g, SIZE, g), fill=color)chakra = lambda s, bold=True: face('chakra-petch-700.woff2' if bold else 'chakra-petch-500.woff2', s)rows = overview_rows(snapshot)- for index, row in enumerate(rows):- y = ROWS[index] + row_shift(len(rows), ROWS[1] - ROWS[0])+ for sl, row in zip(slots(len(rows)), rows):+ y, at, hero, h = sl.y, sl.at, sl.count == 1, sl.ha, a2 = ACCENT['hud'][row['provider']]- used, period, old, reset = reading(row)+ wins = shown_windows(row, sl.count)+ used, period, old, reset = reading(row, wins[0] if wins else None)cut = 10- frame = [(4, y), (235 - cut, y), (235, y + cut), (235, y + ROW_H - 1), (4 + cut, y + ROW_H - 1), (4, y + ROW_H - 1 - cut)]+ frame = [(4, y), (235 - cut, y), (235, y + cut), (235, y + h - 1), (4 + cut, y + h - 1), (4, y + h - 1 - cut)]cv.back.polygon(frame, fill=mix('#06101a', a, .05))cv.draw.polygon(frame, outline=mix(a, '#1b3b58', .45))cv.glow.line(frame + [frame[0]], fill=rgb(a) + (150,), width=2)cv.draw.line((8, y + 4, 8, y + 12), fill=a, width=2)cv.draw.line((8, y + 4, 16, y + 4), fill=a, width=2)- cv.draw.line((231, y + ROW_H - 5, 231, y + ROW_H - 13), fill=a, width=2)- cv.draw.line((231, y + ROW_H - 5, 223, y + ROW_H - 5), fill=a, width=2)+ cv.draw.line((231, y + h - 5, 231, y + h - 13), fill=a, width=2)+ cv.draw.line((231, y + h - 5, 223, y + h - 5), fill=a, width=2)# HUD: the row's accent colour as a hologram: solid bot with every other line dimmed.- place_bot(cv.ink, scanlined(bot_sprite(row['provider'], 21, 19, a)), (11, y + 8, 21, 19))- place_bot(cv.bloom, bot_sprite(row['provider'], 21, 19, a), (11, y + 8, 21, 19))- cv.text((38, y + 8), account_label(row), chakra(14), '#ffffff')- cv.text((228, y + 9), period + (' OLD' if old else ''), chakra(10, False), '#ff4d6a' if old else '#8fadc6', anchor='ra')+ bw, bh = round(21 * sl.icon), round(19 * sl.icon)+ bot = (11, y + 10 if hero else at(8), bw, bh)+ place_bot(cv.ink, scanlined(bot_sprite(row['provider'], bw, bh, a)), bot)+ place_bot(cv.bloom, bot_sprite(row['provider'], bw, bh, a), bot)+ note = '' if len(wins) == 2 else ('OLD' if old else '') if sl.count == 4 else period + (' OLD' if old else '')+ room = 228 - (bw + 17) - (cv.draw.textlength(note, font=chakra(sl.txt(10), False)) + 8 if note else 0)+ cv.text((bw + 17, bot[1]), fit_text(cv.draw, account_label(row), chakra(sl.txt(14)), room), chakra(sl.txt(14)), '#ffffff')+ if len(wins) == 2: # room for both windows: 5H above WEEK+ body = (12, bot[1] + bh + 4, 228, y + h - 8) if hero else (bw + 17, bot[1] + sl.txt(14) + 6, 228, y + h - 8)+ window_lines(cv, row, wins, body, {+ 'label': lambda z: chakra(z, False), 'num': chakra, 'num_max': 42, 'ink': '#ffffff', 'dim': '#8fadc6',+ 'old': '#ff4d6a', 'num_args': {'glow': rgb(a) + (110,)},+ 'gauge': lambda u, o: {'colors': band('hud', u or 0), 'gap': 3, 'shape': 'skew', 'skew': 4,+ 'track': '#0c1c2b', 'empty': '#22476a', 'stale': o, 'glow': True}})+ continue+ cv.text((228, bot[1] + 1), note, chakra(sl.txt(10), False), '#ff4d6a' if old else '#8fadc6', anchor='ra')number = number_text(used)- cv.text((12, y + 25), number, chakra(30), '#ffffff', glow=rgb(a) + (110,))+ ny = bot[1] + bh + 14 if hero else at(25)+ cv.text((12, ny), number, chakra(sl.num(30)), '#ffffff', glow=rgb(a) + (110,))if used is not None:- x = 12 + cv.draw.textlength(number, font=chakra(30)) + 2- cv.text((x, y + 37), '%', chakra(16), a, glow=rgb(a) + (200,))- cv.draw.line((150, y + 30, 150, y + 52), fill='#22476a')- cv.spaced((228, y + 30), 'RESETS IN', chakra(7, False), '#6c8aa5', 1.4, anchor='ra')- cv.text((228, y + 40), reset, chakra(17), '#ffffff', anchor='ra')- gauge(cv, (12, y + 60, 228, y + 68), used, band('hud', used or 0), gap=3, shape='skew', skew=4,- track='#0c1c2b', empty='#22476a', stale=old, glow=True)+ x = 12 + cv.draw.textlength(number, font=chakra(sl.num(30))) + 2+ cv.text((x, ny + round(12 * sl.big)), '%', chakra(sl.num(16)), a, glow=rgb(a) + (200,))+ mid = ny + round(5 * sl.big)+ cv.draw.line((150, mid, 150, mid + round(22 * sl.big)), fill='#22476a')+ if sl.count < 4:+ cv.spaced((228, mid), 'RESETS IN', chakra(sl.txt(7), False), '#6c8aa5', 1.4, anchor='ra')+ cv.text((228, mid + sl.txt(10)), reset, chakra(sl.txt(17)), '#ffffff', anchor='ra')+ else: # four rows: just the time, clear of the gauge+ cv.text((228, mid - 2), reset, chakra(sl.txt(17)), '#ffffff', anchor='ra')+ gy = y + h - 20 if hero else at(60)+ gauge(cv, (12, gy, 228, gy + max(6, round(8 * min(sl.k, 1.4)))), used, band('hud', used or 0), gap=3,+ shape='skew', skew=4, track='#0c1c2b', empty='#22476a', stale=old, glow=True)return cv.finish(blur=2)@@ -574,23 +732,39 @@ def render_gameboy(data):cv = Canvas(GB_LIGHTEST)pixel = lambda size: face('press-start-2p.ttf', size)rows = overview_rows(data)- pitch = 79- for index, row in enumerate(rows):- y = 3 + index * pitch + row_shift(len(rows), pitch)- used, period, old, reset = reading(row) # used is None when nothing was reported- cv.draw.rectangle((4, y, 235, y + 74), outline=GB_DARKEST, width=2)- cv.draw.rectangle((7, y + 3, 232, y + 71), outline=GB_DARK, width=1)- place_bot(cv.ink, bot_sprite(row['provider'], 22, 18, GB_DARKEST, GB_LIGHTEST), (11, y + 7, 22, 18))- cv.text((38, y + 11), account_label(row), pixel(8), GB_DARKEST)- cv.text((229, y + 11), ('OLD ' if old else '') + period, pixel(8), GB_DARK, anchor='ra')- cv.text((12, y + 31), number_text(used), pixel(20), GB_DARKEST) # a dash, never a fake 0+ for sl, row in zip(slots(len(rows), top=3, pitch=79, height=75), rows):+ y, at, hero, h = sl.y, sl.at, sl.count == 1, sl.h+ wins = shown_windows(row, sl.count)+ used, period, old, reset = reading(row, wins[0] if wins else None) # used is None when nothing was reported+ cv.draw.rectangle((4, y, 235, y + h - 1), outline=GB_DARKEST, width=2)+ cv.draw.rectangle((7, y + 3, 232, y + h - 4), outline=GB_DARK, width=1)+ bw, bh = round(22 * sl.icon), round(18 * sl.icon)+ bot = (11, y + 8 if hero else at(7), bw, bh)+ place_bot(cv.ink, bot_sprite(row['provider'], bw, bh, GB_DARKEST, GB_LIGHTEST), bot)+ note = '' if len(wins) == 2 else ('OLD' if old else '') if sl.count == 4 else ('OLD ' if old else '') + period+ room = 229 - (bw + 16) - (cv.draw.textlength(note, font=pixel(sl.txt(8))) + 8 if note else 0)+ cv.text((bw + 16, bot[1] + 4), fit_text(cv.draw, account_label(row), pixel(sl.txt(8)), room), pixel(sl.txt(8)), GB_DARKEST)+ if len(wins) == 2: # room for both windows: 5H above WEEK+ body = (12, bot[1] + bh + 6, 227, y + h - 7) if hero else (bw + 16, bot[1] + sl.txt(8) + 10, 227, y + h - 7)+ window_lines(cv, row, wins, body, {+ 'label': pixel, 'num': pixel, 'num_max': 24, 'ink': GB_DARKEST, 'dim': GB_DARK, 'old': GB_DARK,+ 'gauge': lambda u, o: {'colors': (GB_DARKEST, GB_DARK), 'gap': 2, 'track': GB_LIGHT, 'empty': GB_DARK,+ 'stale': o}})+ continue+ cv.text((229, bot[1] + 4), note, pixel(sl.txt(8)), GB_DARK, anchor='ra')+ ny = bot[1] + bh + 16 if hero else at(31)+ cv.text((12, ny), number_text(used), pixel(sl.num(20)), GB_DARKEST) # a dash, never a fake 0if used is not None:- cv.text((12 + cv.draw.textlength(number_text(used), font=pixel(20)) + 2, y + 39), '%', pixel(10), GB_DARKEST)- cv.text((229, y + 34), 'RESET', pixel(7), GB_DARK, anchor='ra')- cv.text((229, y + 45), reset, pixel(8), GB_DARKEST, anchor='ra')- gauge(cv, (12, y + 58, 227, y + 66), used, (GB_DARKEST, GB_DARK), gap=2, track=GB_LIGHT, empty=GB_DARK, stale=old)+ cv.text((12 + cv.draw.textlength(number_text(used), font=pixel(sl.num(20))) + 2, ny + round(8 * sl.big)), '%',+ pixel(sl.num(10)), GB_DARKEST)+ ry = ny + sl.num(20) + 12 if hero else at(34)+ cv.text((229, ry), 'RESET', pixel(sl.txt(7)), GB_DARK, anchor='ra')+ cv.text((229, ry + sl.txt(11)), reset, pixel(sl.txt(8)), GB_DARKEST, anchor='ra')+ gy = y + h - 17 if hero else at(58)+ gauge(cv, (12, gy, 227, gy + max(6, round(8 * min(sl.k, 1.4)))), used, (GB_DARKEST, GB_DARK), gap=2,+ track=GB_LIGHT, empty=GB_DARK, stale=old)return to_four_shades(cv.finish())--RENDERERS = {'digital': render_digital, 'neon': render_neon, 'retro': render_retro, 'hud': render_hud, 'gameboy': render_gameboy, 'retro-dual': render_retro_dual}+RENDERERS = {'digital': render_digital, 'neon': render_neon, 'retro': render_retro, 'hud': render_hud, 'gameboy': render_gameboy,+ 'retro-dual': render_retro_dual}diff --git a/token_tv/usage.py b/token_tv/usage.pyindex dd51902..180f578 100644--- a/token_tv/usage.py+++ b/token_tv/usage.py@@ -51,12 +51,27 @@ def normalize_codex(data):return result+def reset_credits(data):+ """Codex's saved limit resets: {'count', 'expires_at'} with the soonest expiry of those still+ available, or None when the reply has no such record."""+ record = data.get("rateLimitResetCredits") if isinstance(data, dict) else None+ count = record.get("availableCount") if isinstance(record, dict) else None+ if not isinstance(count, int) or isinstance(count, bool) or count < 0:+ return None+ expiry = [timestamp(item.get("expiresAt")) for item in record.get("credits") or []+ if isinstance(item, dict) and str(item.get("status", "")).lower() == "available"]+ expiry = [at for at in expiry if at]+ return {"count": count, "expires_at": min(expiry) if expiry else None}++def normalize_codexbar(entry):"""One provider entry of CodexBar's usage JSON (`codexbar usage --format json`, `serve` GET /usage).Only the primary and secondary slots: tertiary and extra windows are model-scoped and wouldoverwrite the weekly reading if they shared its label."""- result = []+ result, labels = [], []usage = entry.get("usage")+ # Copilot's slots carry no length: the primary is the monthly premium-request allowance, the secondary chat.+ unnamed = {"primary": "MONTH", "secondary": "CHAT"} if entry.get("provider") == "copilot" else {}for key in ("primary", "secondary"):value = usage.get(key) if isinstance(usage, dict) else Noneif not isinstance(value, dict):@@ -64,7 +79,12 @@ def normalize_codexbar(entry):duration = value.get("windowMinutes")if not isinstance(duration, int) or isinstance(duration, bool) or duration <= 0:duration = None- label = {300: "5H", 10080: "WEEK"}.get(duration, "WINDOW")+ label = {300: "5H", 1440: "DAY", 10080: "WEEK"}.get(duration) or unnamed.get(key, "WINDOW")+ # Readings are compared window by window, so a window keeps one name: an unnamed second window is always+ # WINDOW2, and a second window as long as the first gets a 2.+ if label in labels or (key == "secondary" and label == "WINDOW"):+ label += "2"+ labels.append(label)item = window(label, value.get("usedPercent"), value.get("resetsAt"), duration)if item:result.append(item)diff --git a/token_tv/web/app.js b/token_tv/web/app.jsindex 44042f6..01126b8 100644--- a/token_tv/web/app.js+++ b/token_tv/web/app.js@@ -7,8 +7,8 @@ const THEMES = [{id:'hud', name:'Sci-Fi HUD', eyebrow:'', title:'AI PROVIDER USAGE', note:'Real-time usage monitor'}];const STATUS = {ok:'Connected', loading:'Loading', auth_required:'Login needed', identity_mismatch:'Check identity', quota_unavailable:'Quota unavailable', stale:'OLD · Previous value', rate_limited:'Retry later', error:'Fetch failed'};-const PROVIDERS = ['claude', 'codex', 'grok'];-const COMPANIES = {claude:'ANTHROPIC', codex:'OPENAI', grok:'XAI'};+const PROVIDERS = ['claude', 'codex', 'grok', 'copilot', 'antigravity'];+const COMPANIES = {claude:'ANTHROPIC', codex:'OPENAI', grok:'XAI', copilot:'GITHUB', antigravity:'GOOGLE'};const svgNS = 'http://www.w3.org/2000/svg';const $ = s => document.querySelector(s);const readPreference = (k, f) => {try {return JSON.parse(localStorage.getItem(k)) ?? f} catch {return f}};@@ -35,6 +35,12 @@ function icon(provider) {} else if (provider === 'codex') {s.append(svgNode('path', {d:'M24 5 40.5 14.5V33.5L24 43 7.5 33.5V14.5Z', 'stroke-width':3.2}));s.append(svgNode('path', {d:'M7.5 14.5 24 24 40.5 14.5M24 24V43', 'stroke-width':3.2}));+ } else if (provider === 'copilot') {+ s.append(svgNode('rect', {x:6, y:16, width:16, height:13, rx:4, 'stroke-width':3.2}));+ s.append(svgNode('rect', {x:26, y:16, width:16, height:13, rx:4, 'stroke-width':3.2}));+ s.append(svgNode('path', {d:'M22 22.5H26M18 37C21 39.5 27 39.5 30 37', 'stroke-width':3.2}));+ } else if (provider === 'antigravity') { // its arch+ s.append(svgNode('path', {d:'M7 42C9 24 15 9 24 9S39 24 41 42', 'stroke-width':6}));} else {s.append(svgNode('circle', {cx:24, cy:24, r:12.5, 'stroke-width':3.4}));s.append(svgNode('path', {d:'M5 43C17 33 31 19 43 5 34 19 21 32 5 43Z', fill:'currentColor', stroke:'currentColor', 'stroke-width':1.6}));@@ -54,7 +60,7 @@ function clockGlyph() {/* Pixel Retro scenery on a 200×62 logical grid, anchored bottom-right. Sky objects sit* near x≈138 so they fall between the title row and the score column. */function scene(provider) {- const W = 200, H = 62, rnd = seeded({claude:11, codex:23, grok:37}[provider]);+ const W = 200, H = 62, rnd = seeded({claude:11, codex:23, grok:37, copilot:41, antigravity:53}[provider]);const s = svgNode('svg', {viewBox:`0 0 ${W} ${H}`, preserveAspectRatio:'xMaxYMax slice', 'shape-rendering':'crispEdges', class:'scene', 'aria-hidden':'true'});const rect = (x, y, w, h, fill, cls) => {const r = svgNode('rect', {x, y, width:w, height:h, fill}); if (cls) r.setAttribute('class', cls); s.append(r)};const bands = colors => colors.forEach((c, i) => rect(0, Math.floor(i * H / colors.length), W, Math.ceil(H / colors.length) + 1, c));@@ -78,6 +84,18 @@ function scene(provider) {while (x < W) {const w = 6 + Math.floor(rnd() * 7), h = 10 + Math.floor(rnd() * 13); rect(x, 52 - h, w, h + 10, '#0b3530'); for (let wy = 54 - h; wy < 50; wy += 3) for (let wx = x + 1; wx < x + w - 1; wx += 2) if (rnd() > .55) rect(wx, wy, 1, 1, rnd() > .7 ? '#e8ffa6' : '#7dffb9'); x += w + 2}for (let p = 0; p < W; p += 5) pine(p + 2, 58, 6 + Math.floor(rnd() * 5), '#05201a');for (let i = 0; i < 9; i++) rect(60 + Math.floor(rnd() * 138), 38 + Math.floor(rnd() * 12), 1, 1, '#c8ff8a', 'twinkle');+ } else if (provider === 'copilot') {+ bands(['#062033', '#072a40', '#08344d', '#0a3f5b', '#0c4a68', '#0f5676', '#126283', '#166e90']);+ stars(24, 40, 22, ['#9fe8ff', '#e6faff']);+ for (const [cx, cy, r] of [[132, 14, 4], [137, 12, 5], [143, 14, 4]]) disc(cx, cy, r, '#bfefff');+ ridge(x => 48 - 3 * Math.abs(Math.sin(x / 9)), '#2b86b8');+ ridge(x => 54 - 2 * Math.abs(Math.sin(x / 6 + 1)), '#1b5f88');+ } else if (provider === 'antigravity') { // a dark maze: walls, a row of dots, a power pellet+ bands(['#020208', '#03030c', '#040410', '#050514', '#060618', '#07071c', '#080820', '#090924']);+ for (const [x, y, w, h] of [[100, 8, 96, 1], [100, 8, 1, 40], [195, 8, 1, 40], [100, 47, 96, 1], [124, 24, 48, 1], [124, 31, 48, 1], [124, 24, 1, 8], [171, 24, 1, 8]]) rect(x, y, w, h, '#2121de');+ for (let x = 106; x < 192; x += 6) rect(x, 15, 1, 1, '#ffb8ae');+ for (let x = 106; x < 192; x += 6) rect(x, 40, 1, 1, '#ffb8ae');+ disc(110, 28, 2, '#ffb8ae');} else {bands(['#0d0a28', '#120d33', '#170f3e', '#1c1349', '#211654', '#271a5f', '#2d1e6a', '#33226f']);stars(80, 0, 46, ['#efe6ff', '#b9a6ff', '#ffffff']);@@ -290,3 +308,27 @@ $('#frame').onerror = () => {$('#display-state').textContent = 'Clock preview un$('#mascot').append(retroMascot()); buildStarfield(); tick();update(); refreshDisplay(); loadThemes(); setInterval(update, 30000); setInterval(tick, 1000); setInterval(() => {if (!$('#clock-panel').hidden) refreshDisplay()}, 5000);++// The collection book: scenes found so far, in their tier colours, each playable again on the clock.+const TIER_NAMES = {rare:'Rare', unique:'Unique', legend:'Legend'};+async function paintCollection() {+ if (DEMO) return;+ let data;+ try {const r = await fetch('/collection', {cache:'no-store'}); if (!r.ok) throw Error(); data = await r.json()} catch {return}+ const box = $('#collection'); box.hidden = !data.total; if (!data.total) return;+ $('#collection-count').textContent = `${data.found.length} of ${data.total} found`;+ const list = $('#collection-list'); list.replaceChildren();+ for (const item of data.found) {+ const li = el('li', undefined, 'collection-card'); li.dataset.tier = item.tier;+ const img = el('img'); img.src = `/collection/${item.check}.gif`; img.alt = item.title; img.width = 240; img.height = 240; img.loading = 'lazy';+ const when = new Date(item.first * 1000).toLocaleDateString();+ const play = el('button', 'Replay on clock', 'control'); play.type = 'button';+ play.onclick = async () => {play.disabled = true; try {const r = await fetch('/collection/replay', {method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify({check:item.check})}); play.textContent = r.ok ? 'Playing on the clock' : r.status === 409 ? 'Switch the clock to Arcade first' : 'Could not play'} catch {play.textContent = 'Could not play'} setTimeout(() => {play.disabled = false; play.textContent = 'Replay on clock'}, 8000)};+ li.append(el('span', TIER_NAMES[item.tier] || item.tier, 'tier-badge'), img, el('strong', item.title), el('span', `First seen ${when} · seen ${item.count}×`, 'quiet'), play);+ list.append(li);+ }+ for (let i = 0; i < data.hidden; i++) {const li = el('li', undefined, 'collection-card locked'); li.append(el('span', '???', 'locked-mark'), el('span', 'Not found yet', 'quiet')); list.append(li)}+}+paintCollection();+setInterval(paintCollection, 5 * 60 * 1000);+diff --git a/token_tv/web/index.html b/token_tv/web/index.htmlindex 976b6b2..b978730 100644--- a/token_tv/web/index.html+++ b/token_tv/web/index.html@@ -73,6 +73,11 @@<p class="gallery-links"><a href="https://github.com/click6067-ship-it/token-tv/blob/main/docs/clock-faces.md">Make a face</a> · <a href="https://github.com/click6067-ship-it/token-tv/issues/new?template=share_a_face.md">Share a face</a></p><p class="quiet">No clock needed to make one: it renders from sample data. With a clock, your own face shows up here as Local and can be applied.</p></section>+ <section class="collection" id="collection" aria-labelledby="collection-title" hidden>+ <div class="themes-head"><h2 id="collection-title">Collection</h2><p class="quiet" id="collection-count"></p></div>+ <p class="quiet">Hidden scenes your clock has caught. The rest stay locked until their moment comes; missed one? Play it again on the clock.</p>+ <ul id="collection-list" class="collection-list"></ul>+ </section><details class="help"><summary>How to read this display</summary><p>Percentages show <strong>used quota</strong>. The main gauge shows the selected account’s highest reported window; other windows open below it. Timers belong to that same window. A previous value is marked OLD and is not a current reading.</p><p>Grok CLI budget is a billing limit, not the Grok web conversation limit. If a provider does not report quota, it stays unknown. Laptop-linked accounts need the laptop online.</p></details></div></body>diff --git a/token_tv/web/style.css b/token_tv/web/style.cssindex 85858aa..4b88d34 100644--- a/token_tv/web/style.css+++ b/token_tv/web/style.css@@ -1,7 +1,6 @@@import url('/assets/tokens.css');/* TokenTV web. Shared rules hold structure and data semantics; each theme block- * below re-composes the same nodes after its reference image- * (docs/plans/2026-10-03-web-theme-redesign.md). */+ * below re-composes the same nodes after its reference image. */@font-face{font-family:'Manrope';src:url('/assets/manrope.ttf') format('truetype');font-weight:200 800;font-display:swap}@font-face{font-family:'VT323';src:url('/assets/vt323.woff2') format('woff2');font-display:swap}@@ -97,6 +96,8 @@ h1{margin:0;font:600 48px/1.04 var(--font-display);letter-spacing:-.03em;color:v.card-shell,.provider-card{--accent:var(--claude);--accent-2:var(--claude-2)}.card-shell[data-provider=codex],.provider-card[data-provider=codex]{--accent:var(--codex);--accent-2:var(--codex-2)}.card-shell[data-provider=grok],.provider-card[data-provider=grok]{--accent:var(--grok);--accent-2:var(--grok-2)}+.card-shell[data-provider=copilot],.provider-card[data-provider=copilot]{--accent:var(--copilot);--accent-2:var(--copilot-2)}+.card-shell[data-provider=antigravity],.provider-card[data-provider=antigravity]{--accent:var(--antigravity);--accent-2:var(--antigravity-2)}.provider-card{position:relative;isolation:isolate;overflow:hidden;display:grid;grid-template-columns:minmax(0,1fr) auto;grid-template-areas:"head head" "reading timer" "gauge gauge" "more more" "foot foot";align-items:center;column-gap:28px;padding:24px 28px 0;border:1px solid var(--line);border-radius:var(--radius-card);background:var(--panel)}.card-art{position:absolute;inset:0;z-index:-1;display:none;pointer-events:none}.card-art .scene{display:none;position:absolute;inset:0;width:100%;height:100%}@@ -715,3 +716,14 @@ h1{margin:0;font:600 48px/1.04 var(--font-display);letter-spacing:-.03em;color:v.theme-actions .control{min-height:28px;padding:4px 12px;font-size:12px}.theme-actions a{color:var(--ink-2)}.theme-update{color:var(--ink-3)}[data-demo] #apply{display:none}++/* The collection book */+.collection{margin:28px 0}+.collection-list{display:grid;grid-template-columns:repeat(auto-fill,minmax(180px,1fr));gap:14px;margin:12px 0 0;padding:0;list-style:none}+.collection-card{--tier:#aab2c0;display:flex;flex-direction:column;gap:6px;padding:12px;border:1px solid color-mix(in srgb,var(--tier) 55%,transparent);border-radius:12px;background:color-mix(in srgb,var(--tier) 8%,transparent)}+.collection-card[data-tier=rare]{--tier:#4aa3ff}.collection-card[data-tier=unique]{--tier:#b07cff}.collection-card[data-tier=legend]{--tier:#ffc54a}+.collection-card img{width:100%;height:auto;image-rendering:pixelated;border-radius:8px}+.collection-card .tier-badge{align-self:flex-start;padding:0 8px;border:1px solid var(--tier);border-radius:999px;color:var(--tier);font-size:12px;font-weight:700}+.collection-card.locked{align-items:center;justify-content:center;min-height:84px;border-style:dashed;opacity:.55}+.collection-card .locked-mark{font-size:28px;font-weight:800;letter-spacing:.1em}+diff --git a/token_tv/web/tokens.css b/token_tv/web/tokens.cssindex c13298f..1ea6803 100644--- a/token_tv/web/tokens.css+++ b/token_tv/web/tokens.css@@ -13,6 +13,8 @@--claude: #f4a07a; --claude-2: #f4a07a;--codex: #6ea8ff; --codex-2: #6ea8ff;--grok: #5ee0b5; --grok-2: #5ee0b5;+ --copilot: #3fb6e8; --copilot-2: #36d8b4;+ --antigravity: #78b6ee; --antigravity-2: #e77345;--lvl-low: #6ee7b7; --lvl-medium: #79c0ff; --lvl-high: #f6c453; --lvl-critical: #f7768e;--lvl-low-2: #22c4a6; --lvl-medium-2: #2f8cff; --lvl-high-2: #f08a24; --lvl-critical-2: #e8455f;--radius-card: 22px; --radius-control: 10px;@@ -27,7 +29,7 @@--ink: #7dffd0; --ink-2: #4dbb92; --ink-3: #3a9a77;--line: #164a37; --line-2: #22694f; --track: #0a2a1e; --focus: #c8ffe9;--amber: #ffcf5a;- --claude: #7dffd0; --codex: #7dffd0; --grok: #7dffd0;+ --claude: #7dffd0; --codex: #7dffd0; --grok: #7dffd0; --copilot: #7dffd0; --antigravity: #7dffd0;--lvl-low: #3dfcb0; --lvl-medium: #c3f562; --lvl-high: #ff9d45; --lvl-critical: #ff5a6a;--lvl-low-2: #13b884; --lvl-medium-2: #6fd13a; --lvl-high-2: #ff6a2b; --lvl-critical-2: #e8243f;--radius-card: 0; --radius-control: 0;@@ -43,6 +45,8 @@--claude: #ff8a2b; --claude-2: #ffd23f;--codex: #22d3ee; --codex-2: #4f7bff;--grok: #d946ef; --grok-2: #8b5cf6;+ --copilot: #22c7e0; --copilot-2: #5fe8cf;+ --antigravity: #78b6ee; --antigravity-2: #e77345;--lvl-low: #2cf5b0; --lvl-medium: #38d6ff; --lvl-high: #ffc23d; --lvl-critical: #ff3d81;--lvl-low-2: #00b894; --lvl-medium-2: #1f7bff; --lvl-high-2: #ff8a1f; --lvl-critical-2: #ff2a4a;--radius-card: 26px; --radius-control: 999px;@@ -59,6 +63,8 @@--claude: #ff9f43; --claude-2: #ffcf6b;--codex: #3ee68b; --codex-2: #9bffc8;--grok: #b388ff; --grok-2: #e0d0ff;+ --copilot: #2fd0c0; --copilot-2: #8ff0e4;+ --antigravity: #78b6ee; --antigravity-2: #e77345;--lvl-low: #5ee06a; --lvl-medium: #d3e84a; --lvl-high: #ffab3d; --lvl-critical: #ff5a5f;--lvl-low-2: #2aa84a; --lvl-medium-2: #8fc93a; --lvl-high-2: #ff7a1f; --lvl-critical-2: #d62b3c;--radius-card: 0; --radius-control: 0;@@ -73,6 +79,8 @@--claude: #ff8a3d; --claude-2: #ffb47a;--codex: #2fd4ff; --codex-2: #8be9ff;--grok: #3ef29b; --grok-2: #9dffcb;+ --copilot: #2fb8e8; --copilot-2: #7fe3f0;+ --antigravity: #78b6ee; --antigravity-2: #e77345;--lvl-low: #35e0a0; --lvl-medium: #3cc4ff; --lvl-high: #ffb23f; --lvl-critical: #ff4d6a;--lvl-low-2: #14a874; --lvl-medium-2: #1a7dff; --lvl-high-2: #ff7a1a; --lvl-critical-2: #e01e3c;--radius-card: 0; --radius-control: 0;diff --git a/token_tv/web_assets.py b/token_tv/web_assets.pyindex d2bd3b1..bbf8d64 100644--- a/token_tv/web_assets.py+++ b/token_tv/web_assets.py@@ -20,6 +20,8 @@ ASSETS = {'/assets/claude-pixel.png': (ROOT / 'assets' / 'claude-pixel.png', 'image/png'),'/assets/codex-pixel.png': (ROOT / 'assets' / 'codex-pixel.png', 'image/png'),'/assets/grok-pixel.png': (ROOT / 'assets' / 'grok-pixel.png', 'image/png'),+ '/assets/copilot-pixel.png': (ROOT / 'assets' / 'copilot-pixel.png', 'image/png'),+ '/assets/antigravity-pixel.png': (ROOT / 'assets' / 'antigravity-pixel.png', 'image/png'),}