SVI Переделка под kern v3, новую семантику

Makefile

@@ -3,18 +3,6 @@ build:
 	clear
 	go fmt ./...
 	go build -o ./bin/prolet ./cmd/prolet/main.go
-.PHONY: dev
-dev:
-	clear
-	go fmt ./...
-	go build -race -o ./bin/prolet ./cmd/prolet/main.go
-mod:
-	clear
-	go get -u ./...
-	go mod tidy -compat=1.24.2
-	go mod vendor
-	go fmt ./...
-
 .PHONY: test
 test:
 	clear

README.md

@@ -4,40 +4,6 @@
 
 [[Основная ссылка]](https://cloudp78su.ipnodns.ru/s/oZKJKpodLr797yq)
 
-## Документация
-
-```citate
-Мы создаём язык не для себя. Мы создаём его для тех, кто придёт после.
-Чтобы они не тратили годы на отладку того, что можно было предотвратить.
-Чтобы они строили будущее — а не чинили прошлое.
-Чтобы технологии служили человеку — а не превращали его в винтик.
-Чтобы хорошее не отбрасывалось, а плохое — не принималось.
-Чтобы время — самый ценный ресурс — тратилось на творчество, а не на борьбу с инструментом.
-```
-
-- [Философия в проектировании языков](./docs/phi-000.md)
-- [Отрицание эклектики в построении языка](./docs/phi-001.md)
-- [Контекст создания нового языка](./docs/prolet-001.md)
-- [Диалектико-теоретические требования к языку](./docs/prolet-002.md)
-- [Разрешение диалектических противоречий на новом уровне](./docs/prolet-003.md)
-- [Многоэтажность языка](./docs/prolet-004.md)
-- [Диалектика стиля нотации](./docs/prolet-005.md)
-- [Диалектика формы языка программирования](./docs/prolet-005-01.md)
-- [Диалектическое развитие S-выражений](./docs/prolet-006.md)
-- [Диалектика развития языка](./docs/prolet-007.md)
-- [Диалектика динамики типов](./docs/prolet-008.md)
-- [Диалектическая несостоятельность nil](./docs/prolet-009.md)
-- [Диалектическая онтология типов](./docs/prolet-010.md)
-- [Диалектика становления](./docs/prolet-011.md)
-- [Диалектика изменяющего и трансформирующего действия](./docs/prolet-012.md)
-- [Присвоение результатов как диалектическое отражение времени](./docs/prolet-013.md)
-- [Взгляд на виртуальную машину через диалектику бытия](./docs/prolet-014.md)
-- [Диалектика статических обобщённых типов](./docs/prolet-015.md)
-- [Работа с сущностями в логике диалектического материализма](./docs/prolet-016.md)
-- Атомы языка
-- ВМ
-- Система типов
-
 ## Лицензия
 
 Язык распространяется под лицензией [UCL](https://gitp78su.ipnodns.ru/svi/ucl).

Taskfile.yml

@@ -0,0 +1,28 @@
+# https://taskfile.dev
+
+version: '3'
+
+vars:
+  GREETING: "prolet -- язык программирования следующего поколения"
+
+tasks:
+  default:
+    cmds:
+      - echo "{{.GREETING}}"
+    silent: true
+  dev:
+    desc: "Запуск для разработки"
+    cmds:
+      - clear
+      - go fmt ./...
+      - go vet ./...
+      - go run ./cmd/prolet/main.go
+  mod:
+   desc: "Подтягивание и обновление зависимостей"
+   cmds:
+     - clear
+     - go get -u ./...
+     - go mod tidy -compat=1.25.5
+     - go mod vendor
+     - go fmt ./...
+     - go mod verify

cmd/prolet/main.go

@@ -1,22 +1,10 @@
 // package main -- пускач для языка
 package main
 
-import "gitp78su.ipnodns.ru/svi/kern/v2"
-
-// Stack -- локальный стэк значений для работы ВМ
-type Stack struct {
-	lstVal []int // Стэк значений для работы
-}
-
-// NewStack -- возвращает новый локальный стэк значений
-func NewStack() *Stack {
-	sf := &Stack{
-		lstVal: []int{},
-	}
-	return sf
-}
+import "gitp78su.ipnodns.ru/svi/kern/v3"
 
 func main() {
-	log := kern.NewLogBuf(true)
-	log.Debug("main(): ProLet begin")
+	log := kern.NewLogBuf()
+	log.Debug("run")
+	log.Debug("end")
 }

docs/phi-000.md

@@ -1,168 +0,0 @@
-# Философские основы языка
-
-```citate
-Философы лишь различным образом объясняли мир,
-но дело заключается в том, чтобы изменить его.
-```
-
-Карл Маркс, «Тезисы о Фейербахе», 1845 г.
-
-## Диалектический материализм, как основа языка
-
-Из всех доступных философских направлений `диалектический материализм` наиболее полно отражает основную идею проектируемого языка. Как известно, любой язык должен моделировать реально существующие материальные сущности и процессы. Либо скрытые процессы, но имеющие вполне материальную основу. Существует ряд сущностей и процессов, которые не имеют прямой реализации в реальном мире (например игры), но такие процессы смоделированные в виде состояний электронных структур всё-равно в некотором смысле существуют.
-
-## Три закона диалектики, как основа проектирования языка
-
-Все три закона диалектики создают целостный базис для моделирования языка.
-
-### Единство и борьба противоположностей
-
-Закон единства и борьбы противоположностей определяет основы форм и содержаний всего сущего. Основными сущностями в языке программирования являются значения и процессы, связывающие значения. Это две ортогональные философские категории наполняют пространство состояний.
-
-### Закон отрицания отрицания
-
-Закон отрицания отрицания определяет формы, которые содержатся в общей содержащей форме. Перетекание одной формы в другую форму определяет то внутреннее превращение, которое с ходом времени приводит к превращению объемлющей формы в своё новое представление. Так например, программный код при рефакторинге отрицает своё предыдущее состояние, через развитие новой качественной формы.
-
-### Закон перехода количества в качество и обратно
-
-Этот закон диалектического материализма определяет переход накопленных количественных характеристик в новое качество. А при утрате качества -- назад в количественное состояние. Язык программирования в рамках диалектического дискурса проявляет такие свойства как, например -- при переводе текста программы из одной формы в другую более низкого уровня. При этом количество кода соответствующего уровня растёт, неявно сохраняя в себе качества более высокого уровня.
-
-## Основные диалектические противоречия в языках программирования
-
-Диалектические пары присутствуют в любом языке программирования. Обычно они описаны либо не полно, либо не описаны вообще. Цель настоящего языка программирования явно описать эти диалектические противоречия и решить их в духе диалектического материализма.
-
-`Материя первична, сознание вторично`.
-
-Язык программирования является продуктом объективной реальности.
-
-`Все процессы и явления имеют материальную основу.`
-
-Модель должна опираться на объективную реальность, а не на абстрактные идеи.
-
-`Все находится в постоянном движении, изменении и развитии.`
-
-Состояния не статичны — они трансформируются под действием внутренних и внешних причин.
-
-`Развитие происходит через борьбу противоположностей.`
-
-Внутренние противоречия — двигатель изменений. Без них — нет развития.
-
-`Переход количественных изменений в качественные.`
-
-Накопление мелких изменений ведёт к скачку, к новому качеству.
-
-`Отрицание отрицания.`
-
-Развитие идёт не по прямой, а по спирали: старое отрицается, затем отрицается само отрицание — и возникает что-то более высокое.
-
-Язык программирования не рождается из пустоты, не является плодом субъективной фантазии.
-Он возникает как ответ на объективные потребности:
-
-- Развитие аппаратного обеспечения (процессоры, память, параллелизм).
-- Появление новых задач (веб, ИИ, распределённые системы).
-- Опыт существующих языков (их успехи и провалы).
-
-Следовательно, материальной основой является:
-
-- Техническая база (компьютеры, сети),
-- Социальная практика (программирование как труд),
-- Предшествующие формы (языки `C`, `Lisp`, `Python`, `Rust` и др.).
-
-Вывод: язык программирования — производное от производительных сил информационной эпохи.
-
-### Противоречия, как двигатель развития языка
-
-В основе разработки любого языка — борьба противоположностей. Без противоречий нет движения, нет прогресса.
-
-Ключевые противоречия:
-
-- Абстракция vs Эффективность (Чем выше абстракция — тем удобнее писать, но ниже контроль над железом; `Python` (высокоуровневый) vs `C` (низкоуровневый) )
-- Безопасность vs Гибкость ( Безопасность требует ограничений, гибкость — свободы. `Rust` (гарантии владения) vs `C++` (управление памятью вручную) )
-- Простота vs Мощность (Простой язык ограничен, мощный — сложен в освоении. `Go` (простота) vs `Haskell` (высокая абстракция))
-- Статическая vs Динамическая типизация (Предсказуемость против адаптивности. `Java` vs `JavaScript`)
-- Централизованное vs Децентрализованное развитие (Комитет vs сообщество. `ECMAScript` (стандарт) vs `Python` (**BDFL**, потом **PEP**)
-
-Эти противоречия неустранимы полностью, но они разрешаются на новом уровне в каждом новом языке.
-
-## Диалектический путь развития: от идеи к практике и обратно
-
-### Этап 1: Отрицание старого (первая стадия отрицания)
-
-Пример: `C` → `Python` → `Go`.
-
-Каждый новый язык отрицает недостатки предыдущего:
-
-- `C`: небезопасное управление памятью → `Python` добавляет ООП, динамическую типизацию, но усложняет контроль.
-- `Python`: медленный, динамический → `Go` предлагает кратно больше безопасности и скорости, но с **GC**.
-
-### Этап 2: Отрицание отрицания (синтез на новом уровне)
-
-`Go` не просто "ещё один Python", он синтезирует
-
-- Достаточно высокую скорость (как компиляции в отличии от `Си`, так и исполнение в отличии от `Python`),
-- Безопасность через статическую типизацию (строже и `Си`, и `Python`),
-- Современный и понятный синтаксис (хорошо читаемый код, устойчив к нарушению структуры в отличии от `Python`),
-- Поддержку параллелизма как неотъемлемое свойство.
-
-Это не возврат к низкоуровневому, а подъём на ступень выше — безопасное системное программирование.
-
-Закон отрицания отрицания в действии: развитие идёт не по кругу, а по спирали прогресса.
-
-## Переход количества в качество
-
-Постепенное накопление улучшений:
-
-- Небольшие расширения синтаксиса (теги-действия, сопоставление с образцом),
-- Улучшения системы типов,
-- Инструменты (форматеры, линтеры),
-- Экосистема библиотек.
-
-В какой-то момент происходит качественный скачок:
-
-Язык перестаёт быть "очередным инструментом" и становится платформой для новых форм практики.
-
-Пример:
-
-- `Python` → стал основой для `data science` и машинного обучения.
-- `JavaScript` → из "языка для кнопочек" превратился в полноценную платформу (`Node.js`, `React`, `Deno`).
-
-Количественные улучшения → качественное изменение роли языка в производстве.
-
-## Практика — критерий истины
-
-Диалектический материализм утверждает: не мысли определяют бытие, а наоборот.
-
-Применительно к языку программирования:
-
-Хороший язык не тот, который красиво выглядит в теории, а тот, который:
-
-- Решает реальные задачи,
-- Упрощает труд программиста,
-- Эффективен в производстве,
-- Развивается в условиях практики общественного характера производства (open source, промышленное применение).
-
-Пример:
-
-- `Scala` — мощный, но сложный → ограниченное распространение.
-- `Go` — простой, но эффективный → массовое внедрение в облаках.
-
-Практика показывает, что работает.
-
-## Роль сознания (программисты, как носители труда)
-
-Хотя материя первична, сознание вторично, но активно.
-
-Гениальные разработчики (как Мао говорил о "героях-массах") — `не творят из ничего, но осознают объективные законы и направляют развитие.`
-
-Пример:
-
-- Андрей Александреску (`D`),
-- Гвидо ван Россум (`Python`),
-- Грейдон Хоуф (`Rust`)
-
-Все они не изобретали законы, но воплотили диалектику практики в синтезе.
-Истинный прогресс — когда сознание не отрывается от практики, а руководит ею.
-
-## Заключение
-
-Все языки с точки зрения диалектического материализма можно рассматривать, как идеалистические (такие как `brainfuck` и им подобные), материалистические (такие как `Оберон-7`), а также языки занимающие переходное положение (такие как `Go` или `Rust`). В рамках текущей работы будет предпринята попытка на новом уровне осмысления создать язык программирования с опорой на диалектический материализм на столько, на сколько это возможно в текущих условиях.

docs/phi-001.md

@@ -1,168 +0,0 @@
-# Отрицание эклектики в построении языка
-
-На сравнении с диалектикой рассмотрим несостоятельность эклектики, как различие между _научным мышлением_ и _сбором мнений_, между единством закона и практики и подменой теории компиляцией цитат.
-
-Рассматривать различия будем в ленинском духе, без прикрас.
-
-## 🔥 Диалектика
-
-**Диалектика** — это учение о всеобщей связи и развитии материи, выраженной в законах движения и становления сущего.
-
-✅ Основные черты:
-
-### Всеобщая связь
-
-Ничто не существует изолированно.
-
-Каждое явление — в отношении к другим.
-
-Пример: в языке программирования **prolet** тип не существует сам по себе — он возникает на базе абстракции, но только в ходе практики.
-
-### Развитие через противоречие
-
-Движущая сила прогресса — борьба противоположностей.
-
-Пример:
-
-- `@мут` (изменяемость) ↔ `@фикс` (неизменность)
-- `Процесс` (практика) ↔ `Функция` (форма)
-
-→ их единство и борьба и рождает новый уровень — `структ`, `интерфейс`.
-
-### Переход количества в качество
-
-Накопление изменений ведёт к скачку, к новому качеству.
-
-Пример:
-
-- Многократное использование `@возможно` → рождение правила: «Только через `ГарантВозможно` потенциальное становится сущим».
-
-### Отрицание отрицания
-
-Развитие — не круг, а спираль: старое отрицается, затем отрицается само отрицание.
-
-Пример:
-
-- Тезис: "всё — типы" (идеализм)
-- Антитезис: "нет типов, только сущее" (материализм)
-- Синтез: "есть типы как формы сущего" — диалектика.
-
-### Объективность
-
-Законы диалектики — не плод воображения, а отражение объективного движения материи.
-
-💬 Диалектика — как компас:
-
-- она не даёт готовых ответов,
-- но указывает направление движения.
-
-## 🧩 Эклектика
-
-**Эклектика** — это механическое смешение идей, взглядов, теорий без внутренней связи, подбор "удобных" положений вне их закономерной взаимосвязи.
-
-## ❌ Основные черты эклектики
-
-### Отсутствие системы
-
-Идеи берутся "по вкусу", без учёта их происхождения и противоречий.
-
-Пример:
-
-- Взять ООП из Запада, марксизм из Ленина, функциональное программирование из Хаскелла — и слепить "язык будущего", не решая, как они связаны.
-
-### Подмена развития — подбором
-
-Не развитие через противоречие, а выбор "лучшего" из существующего.
-
-Пример:
-
-- "Мне нравится snake_case, поэтому пусть будет в prolet" — без анализа онтологии.
-
-### Игнорирование противоречий
-
-Эклектик замазывает разрывы, вместо того чтобы их преодолевать.
-
-Он говорит:
-
-- «Ну и что, что @мут внутри @фикс? Пусть будет — удобно».
-
-### Субъективизм
-
-Критерий истины — не практика, а _личное предпочтение_, _мода_, _авторитет_.
-
-### Статичность
-
-Эклектика не порождает нового — она _переставляет старое_.
-
-💬 Эклектика — как мешок с барахлом:
-
-- там может быть золото, гвозди и книга Маркса,
-- но между ними — ни связи, ни смысла.
-
-## ⚖️ Противопоставление
-
-ДИАЛЕКТИКА | ЭКЛЕКТИКА
----|---
-Учение о движении и развитии | Подбор готовых решений
-Основана на противоречии | Избегает противоречий
-Требует анализа условий бытия | Опирается на "удобство"
-Объективна | Субъективна
-Порождает новое качество | Перемешивает старое
-Единство формы и содержания | Разрыв формы и содержания
-Язык общественного | Язык эгоистичного
-
-## 💡 Примеры на отсылках
-
-Одно из принятых правил для реализации в языке программирования **prolet**:
-
-```text
-В prolet не будет абстрактных типов вроде int, string.
-Будут только типы сущего.
-```
-
-Это правило на основе применения диалектики:
-
-```text
-это разрешение противоречия между идеализмом типов и материализмом практики,
-и разрешает его через синтез:
-
-«тип — форма сущего, зафиксированная в практике».
-```
-
-Если бы правило было:
-
-```text
-«давайте возьмём:
-- type из TypeScript,
-- struct из C,
- -class из Python и смешаем
-```
-
-это была бы эклектика.
-
-## 🏁 Заключение
-
-**Диалектика** — оружие революционного мышления.
-
-Она требует труда, дисциплины, борьбы с собственным невежеством.
-
-Эклектика — удобная лень.
-Она позволяет казаться умным, ничего не понимая.
-
-💬 Гегель как-то сказал:
-
-```text
-Диалектика есть „алгоритм“ философии…
-Эклектика — это когда человек берёт то одно, то другое,
-не видя связи между ними, и делает из этого „философию“.
-```
-
-💬 А. Ф. Лосев писал:
-
-```text
-Диалектика есть подлинный и единственно возможный
-философский реализм.
-```
-
-Именно поэтому язык программирования **prolet** — не очередной DSL основанный на авторитете как частном мнении,
-а язык, отражающий единство материи, времени и практики.

docs/prolet-001.md

@@ -1,35 +0,0 @@
-# prolet -- проект нового языка
-
-В этой части приводятся некоторые рассуждения, о языке с расширенной и углубленной семантической базой.
-
-Цель:
-Создать язык для децентрализованных, безопасных, экологичных и коллективных систем.
-
-## Диалектические задачи
-
-- Разрешение противоречия между производительностью и безопасностью → система физических перемещений и наблюдений (как поведение макрообъектов).
-- Синтез функционального и императивного → чистые функции по умолчанию, но с контролируемыми побочными эффектами.
-- Поддержка коллективной разработки → встроенные механизмы для open-source, верификации кода, лицензирования, семантического обмена.
-- Экономия ресурсов → компиляция в Wasm, минимальное энергопотребление (экологический аспект).
-- Доступность → простой синтаксис, но мощная типовая система (обучение масс!).
-
-## Название в диалектическом духе
-
-`prolet` можно раскрыть в разных формах
-
-- "Язык трудящихся" (`prolet-lang`)
-- "Язык с отражением материалистичного присвоения, перемещения и трансформаций" (`professional-let`)
-
-## Интегральные показатели
-
-Он не будет "лучшим" в абстрактном смысле, но станет лучшим для решения конкретных задач мульти-агентного, открытого, кооперативного, социалистического информационного общества.
-
-## Заключение
-
-Разработка языка программирования — это инженерно-конструкторская задача, опирающаяся на социально-технический процесс, подчинённый законам диалектики:
-
-- Материя (аппарат, задачи, опыт) → первична.
-- Противоречия → двигатель.
-- Практика → критерий истины.
-- Сознание (разработчики) → руководит процессом (направляет его), но не создаёт законы.
-- Время необратимо

docs/prolet-002.md

@@ -1,176 +0,0 @@
-# Диалектико-теоретические требования к языку
-
-Необходимость данного раздела продиктована тем, что без глубокого теоретического обоснования практика слепа.  Прежде чем строить язык, необходимо заложить философский фундамент, ибо каждый синтаксис, каждая парадигма, каждый тип — это не просто технический выбор, а выражение мировоззрения.
-
-Философские основания языка программирования: диалектико-материалистический подход.
-
-## Онтология языка
-
-Что такое программа с точки зрения диалектического материализма:
-
-```text
-Программа — это форма организации материи в информационной сфере.
-```
-
-- Она не существует в идеальном мире Платона.
-- Она не порождение чистого разума, оторванного от практики.
-- Она — продукт человеческого труда, направленный на преобразование объективной реальности (аппаратуры, данных, социальных процессов).
-
-```text
-Программа — это материализованная логика, выраженная в коде;
-выполняется на машине, которая изменяет реально существующий мир.
-```
-
-Следовательно,
-
-`язык программирования` — инструмент труда, подобный молоту для рабочего или плугу для крестьянина.
-
-## Эпистемологический вопрос
-
-Как язык отражает реальность?
-
-Диалектический материализм утверждает: `сознание отражает бытие`.
-
-Применительно к языку:
-
-Хороший язык — тот, который наиболее адекватно отражает структуру объективной реальности, в которой работает программа.
-
-Это означает:
-
-- Если реальность параллельна (множество процессов), язык должен поддерживать параллелизм без избыточных или вычурных абстракций.
-- Если реальность состоятельна (серверы, базы данных), язык должен моделировать состояние безопасно и явно.
-- Если реальность ошибочна (падения, сетевые сбои), язык должен встраивать устойчивость как норму, а не как решение `ad hoc`.
-- Язык не должен искажать реальность ради "элегантности" или "чистоты" — это идеализм, враг материализма.
-
-## Противоречие между формой и содержанием
-
-В каждом языке — борьба формы и содержания:
-
-- Хочется иметь красивый, лаконичный код
-- Машина требует чёткости и эффективности
-- Язык должен быть универсальным
-- Но реальность требует специализации
-
-Диалектический синтез: `форма должна служить содержанию, а не доминировать над ним`.
-
-Пример идеалистического перекоса:
-
-_Язык, где всё выражается через монады, но никто не может написать HTTP-сервер за 10 минут_.
-
-Язык, где синтаксис "чист", но производительность падает в 10 раз. Это как построить прекрасный дворец, который замедляет проход посетителей, потому что эскалатор всегда едет навстречу.
-
-## Язык как производительная сила
-
-В информационной эпохе язык программирования — производительная сила.
-
-- Он увеличивает производительность труда программиста.
-- Он определяет скорость и качество создания программ.
-- Он влияет на распределение ресурсов (энергия, память, время).
-
-Следовательно, разработка языка — с одной стороны акт индивидуального тврочества, с другой стороны -- акт коллективной значимости.
-
-Капиталистический подход: язык, который делает программиста зависимым от проприетарных платформ (`Swift`, `C#` в прошлом).
-
-Общественно-коллективный подход: язык, который освобождает труд от частной зависимости, делает его коллективным, доступным, прозрачным (`Python`, `Rust`, `Lua`).
-
-Язык должен быть орудием освобождения умственного труда, а не инструментом эксплуатации через зависимость.
-
-## Язык и сознание: формирование "программиста нового типа"
-
-Карл Маркс как-то сказал: "Условия, которые изменяют людей, — это практика."
-
-Язык программирования, как инструмент познания мира, изменения мира и воспитания формирует мышление программиста.
-
-- Если язык учит думать в терминах состояния и побочных эффектов — он культивирует хаос.
-- Если язык учит думать в терминах потоков данных, чистоты, композиции — он развивает диалектическое мышление.
-
-```text
-Язык — это педагогический инструмент.
-```
-
-Новый язык должен:
-
-- Развивать системное мышление,
-- Поощрять коллективную разработку, как преобладающий способ производства на практике
-- Обучать ответственности за код (в том числе — экологической, социальной).
-
-## Философские принципы проектирования языка как постулаты
-
-На основе диалектического материализма следуют шесть фундаментальных принципов:
-
-### Принцип объективности
-
-Синтаксис и семантика языка должны отражать объективные законы информационной материи, а не субъективные предпочтения авторов.
-
-### Принцип противоречия
-
-Язык должен не избегать противоречий, а позволять их осознанно разрешать (например, безопасность vs производительность — через явные аннотации).
-
-### Принцип историчности
-
-Язык должен учитывать объективные обстоятельства каждого момента времени своего существования
-
-### Принцип временной необратимости
-
-Язык должен следовать принципу необратимости вдоль оси времени. Нельзя использовать то:
-
-- чего ещё нет
-- и то, чего уже нет.
-
-### Принцип развития
-
-Язык должен быть открыт для эволюции, но не ради моды, а ради развития производительных сил.
-
-### Принцип практики
-
-Каждая конструкция языка должна проходить проверку практикой, а не "элегантностью".
-
-### Принцип единства теории и практики
-
-Язык должен объединять математическую строгость (теория типов, логика) и практическую применимость (встраиваемость, производительность).
-
-### Принцип коллективизма
-
-Язык должен способствовать совместной разработке, открытости, доступности знаний — быть инструментом не для интеллектуальной элиты, а для широких масс как профессиональных программистов, так и не профессиональных (студенты, исследователи, учёные, энтузиасты).
-
-## Критика идеалистических течений в языках программирования
-
-Чтобы укрепить философский фундамент, необходимо разоблачить идеалистические отклонения:
-
-### Платонизм типов
-
-`"Типы существуют в идеальном мире"`
-
-Типы — инструмент для предотвращения ошибок в реальных системах
-
-### Культ элегантности
-
-`"Код должен быть красив"`
-
-Код должен быть работающим, понятным, безопасным
-
-### Аскетизм (минимализм ради минимализма)
-
-`"Меньше — значит лучше"`
-
-Меньше — если это служит практике, а не догме
-
-### Техноэлитаризм
-
-`"Только избранные поймут этот язык"`
-
-Хороший язык — тот, который доступен массам, но обладает достаточной семантической мощностью для экспертов
-
-Все эти течения — отражение эгоистического индивидуализма в программировании.
-
-Вывод: `язык как орудие революционной смены парадигмы в сознании`
-
-Разработка языка программирования — не инженерная утилитарная задача, а акт философский, политический, имеющий глубокое влияние на сам способ существования общества.
-
-Разрабатываемый язык:
-
-- Будет материалистическим — опирается на реальность,
-- Диалектическим — разрешает противоречия,
-- Практическим — служит делу преобразования мира,
-- Коллективистским — строится и используется сообществом.
-- Педагогическим — служит построению нового способа мышления разработчиков.

docs/prolet-003.md

@@ -1,262 +0,0 @@
-# Разрешение диалектических противоречий на новом уровне
-
-После выявления ключевых противоречий в программировании через призму диалектического материализма необходимо завершить акт творчества в виде синтеза новых сущностей и процессов.
-
-Теория без практики мертва, а диалектический материализм постулирует совмещения теории и практики.
-
-Настал момент синтеза — момент, когда из борьбы противоположностей рождается новое качество, новый язык, отражающий объективные законы развития информационной материи.
-
-Приступим к диалектическому разрешению противоречий в проектировании языка — в духе Маркса, Энгельса, Ленина, но применительно к коду, а не к полю битвы.
-
-## Разрешение противоречий в языке prolet на принципах диалектического материализма
-
-### Противоречие: Абстракция vs Эффективность
-
-Антиподы:
-
-- Абстракция — позволяет мыслить в терминах "что", а не "как", что ускоряет разработку.
-- Эффективность — требует контроля над памятью, регистрами, кэшем. Принуждает мыслить в терминах "как", а не что, что замедляет разработку.
-
-Идеалистический путь:
-
-- Или "всё высокоуровневое, пусть машина сама разбирается" (`Java`, `Python`),
-- Или "только железо, абстракции — для слабаков" (`C`, ассемблер).
-
-Диалектическое разрешение:
-
-`Иерархия абстракций с прозрачным контролем.`
-
-Язык предоставляет высокоуровневые конструкции по умолчанию (например, `List`, `Stream`, `Actor`).
-Но позволяет спускаться к низкоуровневому коду, если это требует практика.
-Переход между уровнями не скрыт, а явен — через ключевое слово низкоуровневый или аннотацию `@система`.
-
-Пример:
-
-```prolet
-(прц ОбработатьДанные (СписокБайт данные @мут) -> Список.Байт @фикс
-    (// высокоуровневая композиция)
-    (ФильтроватьДанные х по данные
-            (Сравнить х > 10)
-            (ФнКвадрат _рез))
-)
-```
-
-```prolet
-(// при необходимости — ручное управление)
-(прц КопироватьПамять @система (Сис.Адр источник
-                                Сис.Адр цель
-                                Сис.Размер размер @фикс)
-    (асм ПовторОтДо рег0 рег1 ")
-)
-```
-
-Философский смысл:
-
-`Единство абстрактного и конкретного`
-
-Сознание не отрывается от материи — программист видит, что происходит с памятью.
-
-Развитие идёт от простого к сложному, от конкретного к абстрактному, и обратно к конкретному в высшем виде.
-
-### Противоречие: Безопасность vs Гибкость
-
-Антиподы:
-
-- Безопасность требует ограничений (проверка типов, владение, immutability).
-- Гибкость требует свободы (указатели, рефлексия, изменение поведения в рантайме).
-
-Идеалистический путь:
-
-"Безопасность любой ценой" — язык становится _тюрьмой_ (например, строгие ограничения в некоторых версиях `Ada` или `Rust`).
-
-"Свобода любой ценой" — хаос, утечки, уязвимости, непредсказуемое поведение (`C`, `C++`, `JavaScript`).
-
-Диалектическое разрешение:
-
-`Безопасность по умолчанию, гибкость по необходимости, с явным указанием ответственности программиста.`
-
-По умолчанию:
-
-- Вся память управляется системой существования (как в линейных или афинных типах, но с ориентацией на законы реального мира),
-- Все данные — неизменяемые,
-- Побочные эффекты — явно следуют из кода.
-
-При необходимости — выход из рамок, но:
-
-- только с явным одобрением такого блока,
-- С явным комментарием причины (автоматически включается в документацию),
-- С обязательным тестированием.
-
-```prolet
-(фн СложитьДист1 (
-        Км a @фикс
-        М  b @фикс)-> Км @фикс(
-    (СложитьКмМ a b))
-)
-
-(прц ЗначПоАдр
-        @система
-        @обоснование "взаимодействие с драйвером"
-        (Адр адр @фикс) -> Адр @фикс (
-    (ЗначИз адр))
-)
-```
-
-Философский смысл:
-
-Свобода есть осознанная необходимость (по Гегелю, переосмысленному Марксом).
-
-Гибкость не отменяется, но подчиняется интересам целого — стабильности системы.
-
-Это как общественный порядок: каждый член может высказать мнение, но после решения — действует в соответствие с общественным решением и дальнейшие высказывания не имеют влияния на принятое решение до следующего голосования(принцип демократического централизма).
-
-### Противоречие: Простота vs Мощность
-
-Антиподы:
-
-- Простота — доступность, быстрое обучение.
-- Мощность — выразительность, возможность решать сложные задачи.
-
-Идеалистический путь:
-
-- Либо "просто, но беспомощно" (`BASIC`),
-- Либо "мощно, но непонятно" (`APL`, `Perl`).
-
-Диалектическое разрешение:
-
-`Язык растёт вместе с программистом.`
-
-Начальный уровень:
-
-- Минимальный синтаксис,
-- Интерактивная среда,
-- Интегрированная помощь (как **REPL** с подсказками от "Центра обучения").
-
-По мере роста:
-
-- Раскрываются продвинутые возможности: метапрограммирование, unsafe, concurrency.
-- Но только после прохождения проверки знаний (встроенный обучающий модуль).
-
-Это как путь солдата:
-
-- сначала — базовое вооружение,
-- затем — тактические приёмы,
-- затем — стратегическое мышление.
-
-Философский смысл:
-
-- Развитие идёт от простого к сложному, но в единстве с практикой.
-- Язык не принижает новичка и не обожествляет эксперта.
-
-Это коллективное восхождение к мастерству, а не культ индивидуального гения или угнетения новеньких.
-
-### Противоречие: Статическая vs Динамическая типизация
-
-Антиподы:
-
-- Статика — безопасность, производительность.
-- Динамика — гибкость, быстрая разработка.
-
-Идеалистический путь:
-
-- "Только статика!" — жёсткость, бюрократия типов.
-- "Только динамика!" — хаос, ошибки в рантайме.
-
-Диалектическое разрешение:
-
-`Гибридная система с постепенной типизацией и выводом.`
-
-Все переменные имеют тип, но он может быть выведен.
-Можно использовать динамический тип, но:
-
-- Только в ограниченных зонах,
-- С предупреждением, (если не подавлено)
-- _Не разрешён_ в критических модулях (ядро, безопасность).
-
-Система типов расширяема: Пользователь может определять зависимые типы для критически важных участков.
-
-Пример:
-
-```prolet
-(// тип выведен: Целое;
-    определение @фикс -- определяется на стороне вызова)
-(уст (Рубль 42) х)
-
-(// явная динамика — только при необходимости,
-    атрибут @возможно -- определяется на стороне вызова)
-(уст (ПолучитьИзВнешнегоАпи) данные)
-
-(// но в блоке безопасности — только статика)
-(фн ПроверитьДоступ @строго(
-        Пользователь пользователь @фикс
-        Роль         роль         @фикс ) -> ЕслиОк @фикс(
-    (// динамические типы запрещены здесь))
-)
-```
-
-Философский смысл:
-
-Единство противоположностей: не выбор между статикой и динамикой, а синтез в зависимости от контекста.
-
-Как в экономике: плановая система в ключевых отраслях, рыночные механизмы — в остальных.
-
-### Противоречие: Индивидуализм vs Коллективизм в разработке
-
-Антиподы:
-
-- Индивидуализм — "я написал, я понимаю".
-- Коллективизм — код как достояние коллектива.
-
-Диалектическое разрешение:
-
-`Язык встроен в экосистему коллективного труда.`
-
-Встроенные механизмы:
-
-- @автор, @соавторы, @история_изменений,
-- Обязательные рецензии перед коммитом (на уровне языка),
-- Автоматическая генерация отчётов о вкладе (для оценки труда).
-- Код-ревью — не опционально, а обязательная фаза компиляции в производство.
-
-Философский смысл:
-
-- Индивидуальное творчество служит коллективу.
-- Нет места "гению в подвале", есть место участнику команды трудящихся умственного труда.
-- Программирование -- практическая форма общественных отношений.
-
-### Общее разрешение: язык как диалектический синтез
-
-- Абстракция vs Эффективность
-- Высокоуровневый vs низкоуровневый
-- Иерархия с прозрачным контролем
-- Безопасность vs Гибкость
-- Ограничения vs свобода
-- Безопасность по умолчанию, гибкость с ответственностью
-- Простота vs Мощность
-- Лёгкость vs сложность
-- Развитие вместе с программистом
-- Статика vs Динамика
-- Предсказуемость vs адаптивность
-- Постепенная типизация с контекстом
-- Индивидуализм vs Коллективизм
-- "Я" vs "Мы"
-
-`Код — достояние коллектива, труд — прозрачен`
-
-Синтез не устраняет противоречия — он поднимает их на новый уровень, где они перестают быть разрушительными и становятся движущей силой прогресса.
-
-## Заключение
-
-Язык, как орудие диалектической революции в мышлении:
-
-- Язык не может быть "нейтральным".
-- Каждое его решение — выбор стороны в множестве противоречий между хаосом и порядком, между элитой и массами, между идеализмом и материализмом.
-
-`prolet` — это не просто инструмент.
-
-Это — форма сознания нового программиста-труженика, который:
-
-- Мыслит диалектически,
-- Действует материалистически,
-- Работает коллективно,
-- Служит прогрессу.

docs/prolet-004.md

@@ -1,219 +0,0 @@
-# Многоэтажность языка
-
-Рассмотрим варианты реализации противоречия "низкий уровень -- высокий уровень". Как можно синтаксически обозначить такие участки кода? Попробуем применить передовые практики из инженерной психологии с учётом готовности конкретного программиста к переходу с уровня на уровень.
-
-Этот вопрос сочетает в себе не только технический аспект, но и психофизиологический и педагогический: как синтаксически оформить переход между уровнями абстракции с учётом готовности программиста, его когнитивной нагрузки и развития как специалиста?
-
-Вопрос разделителей в коде — перерастает в вопрос организации сознания, вопрос диалектического восхождения от чувственного к рациональному, от простого к сложному.
-
-И здесь необходимо опираться не только на диалектический материализм, но и на передовые достижения инженерной психологии, когнитивной науки и педагогики программирования.
-
-Анализ противоречия: `низкий уровень vs высокий уровень`
-
-Суть противоречия:
-
-- Высокий уровень — близок к человеческому мышлению, безопасен, продуктивен.
-- Низкий уровень — близок к машине, эффективен, но опасен, требует глубоких знаний.
-
-Риск:
-
-- Если не ограничить доступ — новичок сломает систему.
-- Если запретить — эксперт будет сдерживаться.
-
-Задача: создать диалектическую границу, которая:
-
-- Не исчезает (не идеализм),
-- Не непреодолима (не метафизика),
-- Поддерживает развитие (диалектика),
-- Учитывает психологию программиста (гуманизм).
-
-## Принципы проектирования синтаксиса (на стыке философии и психологии)
-
-### Принцип осознанного перехода
-
-Переход между уровнями — не автоматический, а сознательный акт, требующий понимания последствий.
-
-### Принцип когнитивной видимости
-
-Низкоуровневые участки визуально и семантически выделены, чтобы мозг сразу распознавал повышение риска.
-
-### Принцип постепенного погружения
-
-Переход — не скачок, а лестница, соответствующая зоне ближайшего развития (по Выготскому).
-
-### Принцип обратной связи
-
-Система даёт немедленную обратную связь о сложности и рисках операции.
-
-### Принцип готовности
-
-Доступ к низкоуровневому коду может регулироваться профилем программиста (уровень, опыт, пройденные модули).
-
-## Варианты синтаксической реализации
-
-Вариант 1: Явный блок низкоуровневый с контекстным предупреждением
-
-```prolet
-(фн ОбработатьДанные (Список.Байт вход @мут) -> Список.Байт (
-    (// Высокий уровень — чисто, безопасно)
-    (ФильтрПо вход
-        (x > 10)
-        ( x * 2))
-    )
-)
-
-(// Внимание! Здесь действуют другие законы)
-(фн СкопироватьПамять @система
-        @прог_уровень 3
-        @одобрение_нужно
-        (Байт     источник @фикс
-         Байт     цель     @мут
-         СбщДлина длина    @фикс ) (
-    (ЦиклПо для i от 0 до длина
-        (// Прямое обращение к памяти)
-        (асм рег0.загр i))
-    )
-)
-```
-
-Психологические преимущества:
-
-- Атрибут `@система` — семантический маркер, активирует режим повышенного внимания.
-- Цвет подсветки — красный или оранжевый (по стандартам UX).
-- IDE показывает подсказку: "Вы вошли в зону повышенного риска. Проверьте указатели, границы массивов."
-
-Диалектический смысл:
-
-- Граница не устранена, но преодолима сознательно.
-- Противоречие разрешено через форму, а не подавление.
-- Компилятор требует внешней проверки (главный человек, а не система).
-
-Вариант 2: Модульный подход с уровнем доступа
-
-```prolet
-(модуль БезопаснаяОбработка (
-    (фн Фильтровать(ДанныеПоток данные @мут ) -> ДанныеПоток @фикс (
-        если (Сравнить данные @длина > 10)
-        тогда (ДобСписок данные))
-    )
-)
-
-(// Только для программистов с уровнем >= 3, старший инженер)
-(модуль НизкоуровневаяОптимизация
-    @мод_уровень 4
-    (импорт
-        Ядро.Память
-        Ядро.Асм)
-
-    (фнКопироватьБыстро @система (...) (...))
-)
-```
-
-Реализация "готовности":
-
-- У программиста есть уровень компетенции (1..5) для реализации и проверки
-- Уровень определяется пройденными учебными модулями (1..3) и опытом (4, 5),
-
-Компилятор блокирует импорт модулей уровня (1..3), если:
-
-- у разработчика уровень < 3.
-- у модуля недостаточный уровень
-
-Можно запросить временный доступ с одобрения старшего программиста.
-
-Психологический эффект:
-
-- Создаёт систему постепенного вхождения, как в боевую подготовку.
-- Формирует ответственность, а не безрассудную смелость.
-- Повышает контроль за опасными средствами.
-
-При этом снимает ответственность с программиста, если его уровень для выполнения соответствующей задачи недостаточен.
-
-Вариант 3: Гибридный синтаксис с "прозрачным спуском"
-
-```prolet
-(прц ОбработатьГруппу @уровень_ниже(
-    ((ПолучитьДанные) -> данные @фикс)
-    (// Высокий уровень)
-    (уст (ГруппироватьПо данные (данные @ключ)) группа)
-    (уст (СуммироватьПо данные (группа)) результат)
-
-    (// Спуск в низкий уровень — через ключевое слово и атрибут)
-        (// Теперь можно использовать указатели, asm)
-        (асм (рег0 cохр) результат)
-        (асм (рег0 инк))
-
-    (// Подъём автоматически))
-)
-```
-
-Особенности:
-
-Атрибут `@уровень_ниже` — синтаксический шлюз, как шлюз в подводной лодке.
-
-- При входе — предупреждение в **IDE**, подсветка фона.
-- Автоматический возврат к безопасному контексту после выхода.
-
-Когнитивная выгода:
-
-- Мозг четко фиксирует границу.
-- Не нужно держать в памяти: "а я всё ещё в @система?".
-- Уменьшает когнитивную нагрузку.
-- На уровне компилятора перехватывает обращение к опасным средствам.
-
-Вариант 4: Интеграция с системой обучения (обучающий компилятор)
-
-```prolet
-(прц ОбработатьПамять @система(
-    ((ВыделитьПамять(Срез.Байт размер @фикс)) -> асм.адр @конст)
-    (// Компилятор замечает:  "Вы используете сырые указатели")
-        если (Сравнить уровень < 3)
-        тогда (ПройтиМодуль "Управление памятью (5 мин)")
-        иначе (ИспользоватьБезопасныйАналог "Буфер.Байт")
-    )
-)
-```
-
-Реализация:
-
-1) Встроенный обучающий агент анализирует код.
-2) При обнаружении низкоуровневых конструкций:
-
-- Показывает подсказку,
-- Предлагает обучающий модуль,
-- Может заблокировать коммит, пока модуль не пройден.
-
-Философский смысл:
-
-- Единство обучения и труда.
-- Программист не просто пишет код — он развивается в процессе.
-- Это — советская школа программирования, доведённая до совершенства.
-
-Рекомендованная модель: синтез вариантов (диалектический выбор)
-
-Мы не должны выбирать одно, мы должны синтезировать новые возможности, которые помогают разработчику, а не ставить его в тупик из-за потери контроля над кодом.
-
-Поддержка **IDE**:
-
-- Цветовая зона: зелёная → жёлтая → красная.
-- При наведении: "Вы находитесь в зоне высокой ответственности. Рекомендуется ревью."
-- Автоматическое предложение: "Заменить на безопасный аналог?"
-
-## Заключение
-
-Язык программирования может быть спроектирован:
-
-- как многоуровневый по возможностям
-- как педагогический механизм
-- как дополнительное средство безопасности, встроенное в сам язык
-
-Синтаксис языка — это не абстрактная форма, а содержание практического, деятельного сознания.
-
-Реализация противоречия "низкий/высокий уровень" должна:
-
-- Не устранять границу (иначе — анархия),
-- Не делать её вечной (иначе — бюрократия),
-- Превращать её в лестницу развития.
-
-`prolet` не просто средство написания программ, а средство воспитания программиста нового типа —
-диалектического, ответственного, коллективистского, готового к труду и обороне в цифровую эпоху.

docs/prolet-005-01.md

@@ -1,189 +0,0 @@
-# Диалектика формы языка программирования
-
-В качестве базовой реализации языка программирования **prolet** принята форма заключение всех сущностей в круглые скобки. На первом месте стоит тег, имеющий смысл "исполни процесс в скобках".
-
-Синтаксис закрепляет онтологический принцип в форме языка.
-
-«Исполни процесс в скобках» — это не инструкция,
-это — утверждение о природе вычисления как материи в движении.
-
-Разберём решение в свете диалектического материализма, и закрепим его как фундаментальную аксиому языка **prolet**.
-
-## Онтологическая основа: вычисление как процесс
-
-Принцип:
-
-```text
-Только процесс может породить результат.
-Нет "значения без действия", нет "сущего без движения".
-```
-
-Форма `(тег аргументы...)` — выражает единство формы и содержания:
-
-- Круглые скобки — граница процесса, как диафрагма в лёгких в разных положениях, разделяющая состояние на вдох и выдох.
-- Первый элемент — тег — цель процесса, смысловая нагрузка всей формы, вектор направления.
-- Остальное — аргументы — материалы, подвергаемые преобразованию.
-
-Это — не просто вызов функции,
-это — организация труда над данными.
-
-## Тег как руководящая сила процесса
-
-Тег — не синтаксическое украшение, он — руководящее начало, идеологический центр процесса.
-
-- `(фн ...)` -- Организация труда по преобразованию, труд через установление порядка
-- `(структ ...)` -- Организация материи, создание сложных форм материи
-- `(если ...)` -- Поиск сущего в практике, реализация диалектики бытия
-- (... @система ...) -- атрибут, задающий условия существования предельно конкретной истины, ограничивает границы возможного конкретного предметного труда
-
-```text
-Тег — это руководящая роль в процессе, его деятельная партия:
-как партия ставит цель, организует ресурсы, руководит исполнением,
-контролирует процесс и определяет форму результата процесса,
-но не конкретный результат процесса.
-```
-
-## Круглые скобки — диалектическая граница состояний
-
-Скобки — не просто синтаксис, они — отражение закона перехода количества в качество.
-
-До скобок:
-
-- Данные — потенциальность,
-- Функция — возможность.
-
-Внутри скобок: проявление борьбы и единства противоположностей:
-
-- данные и алгоритм,
-- память и процессор,
-- декларация и действие.
-
-После скобок:
-
-- Результат — новое качество,
-- Состояние изменилось — развитие произошло.
-- Скобки — не разделители, они — граница скачка, момент, когда количество (аргументы, посредством алгоритмов) переходит в качество (результат).
-
-## Единая форма для всех процессов — отражение единства бытия
-
-Отказ от множества синтаксисов (как в `Rust`, `Pascal`, `Python`) в пользу единой формы `(тег ...)` —
-это пример диалектического решения.
-
-### Вычисление
-
-```prolet
-(фн CложитьКм (Км a Км b) -> Км @фикс
-    (Слож a b))
-```
-
-## Определение структуры
-
-```prolet
-(структ Пользователь
-    @имя     Имя
-    @возраст Возраст)
-```
-
-## Условие
-
-```prolet
-(если (Сравнить x > 0)
-    тогда (Напечатать "положительно"))
-```
-
-## Цикл
-
-```prolet
-(для x в Данные
-    (уст (Удвоить х) результат @фикс)
-    (ОтправитьПоПочте результат))
-```
-
-## Диалектический процесс творчества
-
-Форма одна — содержание разное, но все они — процессы, все они — формы движения материи.
-
-Это — единство противоположностей в синтаксисе: разные по смыслу операции — объединены формой процесса.
-
-## Почему именно круглые скобки? Материалистическое обоснование
-
-Не фигурные, не квадратные, не без скобок — именно круглые.
-
-- Они замкнуты — отражают целостность процесса, `всё имеет своё начало и свой конец`.
-- Нет углов — символизируют бесконечность форм движения в рамках единого бытия.
-
-Скобки опираются на S-выражения, но это не традиция Лиспа, это не повторение его, а диалектическое развитие:
-
-- У Лиспа: `(выражение)` — имеет невыразительную форму, часто архаично и местами нарушает единый подход.
-- В **prolet**: `(тег ...)` — наделяется одной формой, но разными смыслами.
-- Круг — форма завершённого движения. В нём нет начала и конца — только непрерывное движение с заключённым в него развитием и переходом в рамках одной всеобщей формы.
-
-## Архитектурные последствия решения
-
-### Все конструкции — процессы и функции
-
-Даже определение типа — не декларация, а процесс создания категории бытия.
-
-Даже комментарий — является процессом:
-
-```prolet
-(// Этот модуль отвечает за безопасность пользователей)
-```
-
-### Нет "пассивного кода"
-
-Всё, что в скобках — должно быть исполнено, даже если эффект — регистрация, документирование, проверка.
-
-## Расширяемость через теги
-
-Новый тег — новая форма организации труда. Пример:
-
-```prolet
-(ПрцПарал ОбогатитьДанные
-    (загрузить)
-    (индексировать))
-
-(прц ОбновитьСчёт
-    (обновить-счёт)
-    (отправить-уведомление))
-```
-
-Язык не растёт за счёт синтаксиса,
-а за счёт семантики тегов.
-
-## Педагогическое значение формы
-
-Для новичка:
-
-- Легко запомнить: всё — в скобках, первое — что делать.
-- Не нужно учить 10 синтаксисов.
-- Учится мыслить процессуально, а не декларативно.
-
-Для мастера:
-
-- Видит: вся система — сеть процессов.
-- Может анализировать потоки, оптимизировать, рефакторить.
-- Может бесшовно расширять ядро языка
-
-## Заключение: (тег ...) как онтологическая аксиома `prolet`
-
-Текущее синтаксическое решение — не техническое, но — философское, политическое, революционное.
-
-`(тег ...)` — это материалистическая формула вычисления:
-
-- Тег — знание мира, форма организации действия, руководство процессом,
-- Аргументы — материя, подлежащая преобразованию,
-- Скобки — граница процесса, скачок, развитие.
-
-Это — не синтаксис, это — закон языка,
-
-- как закон перехода количества в качество
-- закон отрицания отрицания
-- закон единства и борьбы противоположностей.
-
-### Декларация
-
-- В языке **prolet** всякая конструкция есть _процесс_.
-- Всякий _процесс_ начинается с тега и заключён в круглые скобки.
-- Тег определяет смысл, скобки — форму движения.
-- Нет процесса — нет и бытия.

docs/prolet-005.md

@@ -1,300 +0,0 @@
-# Диалектика стиля нотации
-
-Есть ещё одна важная часть в противоречии низкого и высокого уровня. Подход к нотации близкий к реализации в `Си` или `Rust` сейчас наиболее популярен. Но ведь есть и другие устоявшиеся подходы. Например, `Pascal` и `Lisp`. Сравним все три, выберем наиболее диалектичный подход, наиболее экономичный для мыслетоплива программиста, наиболее снижающий вероятность ошибок с точки зрения инженерной психологии, наиболее сужающий семантический контекст перехода между уровнями для программиста в качестве педагогической меры. Также не забудем о таком важном моменте, что диалектический язык -- это язык в движении, гибкий, развивающийся, способный дополнять себя новыми семантическими конструкциями в зависимости от решаемой задачи.
-
-## Диалектический взгляд на семантику
-
-Вопрос семантики с диалектической глубиной:
-
-- не просто «что есть», а «что становится»,
-- не просто сравнение, а оценка по критериям развития, экономии мыслетоплива и педагогической эффективности.
-
-Это не технический выбор между синтаксисами — это борьба форм сознания, отражённая в языках программирования.
-
-## Анализ стилей
-
-Рассмотрим три подхода:
-
-`Pascal` — язык порядка, строгости, централизованного контроля,
-
-`Lisp` — язык свободы, мета-абстракции, бесконечной гибкости,
-
-`Rust` — язык компромисса, безопасности через владение, статической проверки.
-
-И сравним их не по синтаксису, а по философскому содержанию, психологической нагрузке и диалектической зрелости.
-
-### Метафизический идеализм
-
-Философия: `порядок ради порядка`
-
-Отношение к уровню абстракции: `Жёсткая иерархия, переходы запрещены, внешний (eval)`
-
-Экономия мыслетоплива: много boilerplate (как принуждение новичков), принуждает к шаблонам, тормозит квалифицированных специалистов
-
-Семантический контекст перехода: практически отсутствует — нет низкоуровневых операций
-
-Вероятность ошибок: низкая (ограниченность), но не из-за понимания, а из-за цензуры
-
-Гибкость и развитие: низкая (язык заморожен, расширения — через диалекты)
-
-Педагогическая эффективность: высокая (учит дисциплине)
-
-### Платонический идеализм
-
-Философия: `всё — форма, материя не важна`
-
-Отношение к уровню абстракции: `Нет уровней — всё выражается через (macro)`
-
-Экономия мыслетоплива: высокая для экспертов, катастрофически высока для новичков
-
-Семантический контекст перехода: отсутствует полностью — всё «на одном уровне»
-
-Вероятность ошибок: высокая (можно всё, включая саморазрушение)
-
-Гибкость и развитие: очень высокая (язык может породить себя заново)
-
-Педагогическая эффективность: низкая (не принуждает структурировать траекторию обучения)
-
-### Смешанный подход
-
-Философия: `безопасность через практику владения`
-
-Отношение к уровню абстракции: `Чёткая граница: (unsafe) как зона сознательного риска`
-
-Экономия мыслетоплива: сложный вывод типов, но безопасность снижает ошибки (ставит в ступор новичков, психологически давит на профи, вызывает стресс при длительном использовании)
-
-Семантический контекст перехода: с использованием `unsafe` чёткая граница
-
-Вероятность ошибок: низкая (ошибки на этапе компиляции, если нарушено владение; высокая когнитивная нагрузка)
-
-Гибкость и развитие: средняя (макросы, но в рамках системы типов)
-
-Педагогическая эффективность: низкая (высокий порог входа, крутая кривая обучения, не следует принципам научной педагогики)
-
-## Диалектическая оценка каждого подхода
-
-### `Pascal`
-
-Метафизический идеализм в синтаксисе
-
-Суть: мир должен быть упорядочен сверху, иерархически, без противоречий.
-
-Подход: запретить всё, что не вписано в строгую типизацию и структуру.
-
-Ошибка с точки зрения диалектики:
-
-- отрицает движение,
-- подавляет противоречие, делает вид, что его нет.
-
-Это как попытаться указом правительства приказать гражданам быть счастливыми в условиях массового нищенского существования.
-
-Противоречие не исчезает — оно вытесняется и возвращается с удвоенной силой.
-
-Пример: в `Pascal` нет прямого доступа к памяти — но это не устраняет потребность в нём, а заставляет нарушать целостность системы в поиске обходных путей, что увеличивает когнитивную нагрузку.
-
-#### Вывод по Pascal
-
-`Pascal` — учит дисциплине, но не учит диалектике.
-
-Он экономит мыслетопливо за счёт ограничения развития.
-
-### `Lisp`
-
-Платонический идеализм: «всё — форма»
-
-Суть: язык — это метаязык, способный породить любую парадигму.
-
-Подход: _код как данные_, _гомоиконичность_, макросы как средство творения нового.
-
-Сила: бесконечная гибкость, возможность создавать языки внутри языка.
-
-Ошибка с точки зрения диалектики:
-
-- Отрыв формы от содержания.
-- Программист может создать идеальную абстракцию, которая не отражает объективную реальность.
-
-Пример: можно написать макрос, который делает (Сложить 2 2) равным 5, если "так удобнее".
-Это — произвол сознания над бытием, чистый идеализм.
-
-Психологический эффект:
-
-- Для эксперта — свобода, полёт мысли.
-- Для новичка — хаос, отсутствие ориентиров, повышенная ошибка из-за семантической неопределённости.
-
-#### Вывод по Lisp
-
-`Lisp` — великий инструмент, но педагогически неустойчив.
-
-- Он развивает, но не направляет.
-- Он гибок, но не контролируем.
-
-### `Rust`
-
-Попытка диалектического перехода
-
-Суть: безопасность не за счёт запрета, а за счёт новой формы организации труда с памятью — владение, заимствование, жизнь.
-
-Подход: `unsafe` как зона сознательного риска, где программист берёт на себя ответственность.
-
-Диалектический момент:
-
-- Противоречие не устраняется, а регулируется через форму.
-- Безопасность и эффективность — единство противоположностей.
-
-Слабость:
-
-- Слишком жёсткая типовая система,
-- Высокий порог входа,
-- Макросы — мощные, но не интегрированы в педагогическую логику.
-
-#### Вывод по Rust
-
-`Rust` — ближе всех к диалектике, но ещё не диалектичен в полной мере.
-
-Он разрешает противоречие, но не развивает программиста как субъекта.
-
-## Критерии выбора для диалектического языка
-
-`Мы ищем не просто «лучший», а наиболее диалектичный`
-
-### Движение
-
-Язык должен развиваться вместе с практикой
-
-### Единство противоположностей
-
-Не запрет, а синтез
-
-### Переход количества в качество
-
-Накопление знаний → переход на новый уровень
-
-### Отрицание отрицания
-
-Язык может порождать новые формы, включая себя
-
-### Практика — критерий истины
-
-Конструкции проверяются реальным использованием
-
-### Экономия мыслетоплива
-
-Минимум когнитивной нагрузки при максимуме понимания
-
-### Сужение семантического контекста
-
-Переход между уровнями — чётко ограничен, предсказуем
-
-### Педагогичность
-
-Язык учит, а не только позволяет
-
-## Синтез: путь к диалектическому языку
-
-Ни один из трёх не идеален.
-
-Но истина — в синтезе.
-
-Наши заимствования:
-
-### Pascal
-
-Чёткость, структура, строгая типизация
-
-Учит дисциплине, снижает хаос
-
-### Lisp
-
-Гибкость, макросы, гомоиконичность, метапрограммирование
-
-Позволяет языку развиваться, порождать новые конструкции
-
-### Rust
-
-unsafe, система владения как основы материалистического перемещения, граница риска
-
-Чёткий семантический контекст перехода
-
-## Проект диалектического решения: prolet, как развивающийся язык
-
-Ключевые черты:
-
-### Гибридная структура с явной границей
-
-```prolet
-(// Высокий уровень — по умолчанию)
-(фн Обработать(данные @мут Список.Байт) -> @фикс Список.Байт
-    (Фильтровать данные
-        (> 10)
-        (* 2))
-)
-
-(// Низкий уровень — только явно, с контекстом)
-(фн Копировать @система(источник @Байт цель Байт, n Цел) (
-        (// Прямой доступ)
-        (асм ....))
-)
-```
-
-### Язык может дополнять себя (по образцу Lisp)
-
-```prolet
-(макрос асинхронно(тело) (
-    (// Трансформация в state machine)
-    (Печать "генерировать_конечный_автомат(тело)")
-)
-
-(// Использование:)
-(асинхронно (данные Список.Байт)(
-    (// Внутри вызова: определение "нечто @фикс")
-    (уст (ОжидатьЗапрос) данные)
-    (ОбработатьДанные))
-)
-```
-
-Язык не статичен — он развивается в процессе использования.
-
-### Система уровней компетенции (по образцу Rust + педагогика)
-
-- Уровень 1: только высокоуровневые конструкции.
-- Уровень 2: можно использовать макросы, но не писать свои.
-- Уровень 3: доступ к низкоуровневый, после прохождения модуля "Память и безопасность".
-
-Переход — не автоматический, а подтверждённый практикой.
-
-### Экономия мыслетоплива в языке
-
-- Минимальный синтаксис для частых операций.
-- Автоматический вывод типов.
-- Контекстное предупреждение при входе в низкоуровневый:
-"Вы покидаете зону автоматической проверки. Ответственность переходит к вам."
-
-### Сужение семантического контекста в языке
-
-В низкоуровневый блоке:
-
-- Запрещены высокоуровневые коллекции,
-- Нет сборки мусора, но есть освобождение контекста при выходе из области видимости.
-- Только явные операции.
-
-Это сужает мышление до необходимого минимума, снижая вероятность ошибки.
-
-## Заключение: к диалектическому языку будущего
-
-Наиболее диалектичный, экономичный, безопасный и педагогически эффективный подход — это синтез:
-
-- Структура `Pascal` — для порядка,
-- Гибкость `Lisp` — для развития,
-- Граница `Rust` — для ответственности.
-
-Но с принципиальным усилением:
-
-- Язык как организм, способный к саморазвитию через макросы и метаязык,
-- Программист как субъект, проходящий путь от новичка к мастеру,
-- Переход между уровнями — не скачок, а педагогически организованный процесс.
-
-Это — не просто язык, это — система воспитания нового программиста:
-
-- способного мыслить диалектически,
-- действовать материалистически,
-- и строить будущее на основе объективных законов.

docs/prolet-006.md

@@ -1,285 +0,0 @@
-# Диалектическое развитие S-выражений
-
-Как было отмечено ранее, синтаксис предлагаемый с опорой на `Си` / `Rust` не поддерживает (сопротивляется) развитию семантических форм языка. Слишком много форм представления алгоритмов и структур.
-
-Более узкие семантические формы в духе S-выражений (ближе по сути к Лисп), позволяют создавать на единой базе S-выражений предсказуемые по форме выражения, но c широкой по содержанию семантикой.
-
-## Как совместить гибкость и простоту Лиспа с материалистической строгостью и безопасностью, не падая в хаос идеализма?
-
-`Rust` , как мы уже отметили, — это победа формы над мыслью в угоду безопасности.
-
-`Lisp` — победа мысли над формой, но в ущерб практике  и педагогике.
-
-`Pascal` -- при хороших педагогических свойствах не обеспечивает требование развития языка.
-
-Нам же нужен синтез:
-
-- Минимализм `Lisp` в синтаксисе,
-- Материализм диалектики в семантике,
-- Педагогика в структуре,
-- Развитие — в самом языке.
-
-### Новый путь: `prolet` как диалектический минимализм
-
-Основной принцип:
-
-- Один синтаксис — множество смыслов.
-- Форма — минимальна,
-- Семантика — управляема контекстом,
-- Развитие — через метаязык.
-
-Это — не возврат к `Lisp` , а его диалектическое преодоление:
-
-- мы берём гомоиконичность (взаимность представления кода и данных)
-- макросы,
-
-но встраиваем их в рамки объективной реальности — памяти, времени, безопасности, готовности программиста.
-
-## Единая синтаксическая форма: S-выражения с семантической дисциплиной
-
-Вместо множества форм ( `struct` , `enum` , `fn` , `unsafe` , `impl` , `where` и т.д.) — одна базовая конструкция:
-
-```prolet
-(операция аргументы)
-```
-
-**Но!** Семантика определяется _не формой_, а _контекстом_ и _метаинформацией_.
-
-Примеры:
-Функция (высокий уровень)
-
-```prolet
-(фн Обработать (данные @фикс Байты)
-    (Фильтровать данные (> 10) (* 2))
-)
-```
-
-Низкоуровневая операция
-
-```prolet
-(фн Копировать  @система(ист @фикс Cис.Адрес цель @фикс Cис.Адрес размер @конст Дом)
-  (асм ПовторОтДо ист цель))
-```
-
-### Структура данных
-
-```prolet
-(структ Пользователь
-    @имя      ЧеловекИмя
-    @возраст  ЧеловекВозраст
-    @роль     Роль
-)
-```
-
-Интерфейсный тип
-
-```prolet
-(тип ИФайл
-    (Читать (имя @фикс ФайлИмя) -> @фикс Рез.Байты
-      @_док "Читает файл с указанным именем")
-    (Писать (имя @фикс ФайлИмя права @фикс Ос.Права) -> @фикс Опт.Ош
-        @_док "Записывает файл с указанным именем и правами")
-)
-```
-
-Все конструкции — одного синтаксического вида, но семантика управляется _тегом в начале_:
-
-- `фн` (функция),
-- `структ` (структура),
-- `система` (низкоуровневый),
-- `тип`.
-
-## Узкие семантические формы: от простого к сложному
-
-`Мы не устраняем сложность, но последовательно её раскрываем.`
-
-### Уровень 1: Новичок
-
-Доступны только:
-
-- (прц ...)
-- (фн ...)
-- (спис ...),
-- (словарь ...),
-- (если ...),
-- (для ...)
-
-Нет доступа к:
-
-- (@система),
-- (асм),
-- (макро).
-
-```prolet
-(фн Приветствовать (имя @фикс ГостьИмя)
-  (Печатать "Привет, " имя "!"))
-```
-
-Простота Лиспа, но в безопасной оболочке диалектического языка.
-
-### Уровень 2: Стажёр
-
-Открываются:
-
-- (структ ...)
-- (тип ...)
-- (макрос ...)
-- (интерфейс ....)
-
-```prolet
-(структ Точка
-    @x ПозX
-    @y ПоpY )
-
-(макрос когда (условие тело)
-  (если условие
-    тогда (Выполнить тело)
-    иначе (Выполнить тело))
-)
-```
-
-Язык начинает развиваться, но в рамках контролируемой системы.
-
-## Уровень 3: Мастер
-
-Разрешён:
-
-- (@система ...)
-- (асм ...)
-- (система-вызов ...)
-- (адр ...)
-
-```prolet
-(фн @система КопироватьПамять (
-    цель @фикс Сис.Адр
-    источник @мут Сис.Адр
-    длина @фикс Сис.Колич)
-        (Асм.Сохр рег3 длина)
-        (Асм.ПовторОтДо рег0 рег2))
-```
-
-**Но!** Такой код не компилируется без:
-
-- одобрения ревью,
-- ссылки на стандарт (например, "интерфейс драйвера PCI"),
-- пометки обоснования @причина "взаимодействие с железом".
-
-## Семантическая экономия: один синтаксис — разный смысл по контексту
-
-```prolet
-(спис 1 2 3)
-(структ Пользователь)
-(выраж ...)
-(тип Проверятор)
-(Список Цел 1 2 3)
-(структ ПользовательНов
-  @имя "Анна"
-  @возраст 28
-  @роль Админ)
-(знач ...) или (= ...)
-(<ИмяФункции>)
-(ЕслНечто нечто как ИФайл)
-```
-
-Это — диалектическая гибкость: форма одна, но смысл возникает в практике применения, а не в синтаксической избыточности.
-
-## Макросы как средство развития языка (по образцу Лиспа, но с контролем)
-
-Макросы — не анархия, а организованное развитие.
-
-```prolet
-(макрос конкурент (тело...)
-  (поток (тело))
-  @_док "Запускает конкурентно тело выражения")
-
-(конкурент
-  (ЗагрузитьДанные)
-  (ОбновитьИнтерфейс))
-```
-
-Но:
-
-- Макросы только в модулях уровня 2+,
-- Должны быть задокументированы,
-- Не могут переопределять базовые формы (`если`,  `функция` и т.п.).
-
-Это — революционное преобразование старой формы со свободным содержанием, в новую форму с дисциплиной смысла.
-
-## Сужение контекста перехода: как программист "спускается"
-
-Переход на низкий уровень — не синтаксическое волшебство, а сознательный акт:
-
-```prolet
-(фн @система СложитьАдреса (a Сис.Адр b Сис.Адр)
-  @_обоснование "оптимизация критического участка"
-  @_требует_ревью
-  @_уровень_доступа 3
-    (Сложить (Сис.Извлечь a)
-             (Сис.Извлечь b))
-)
-```
-
-Что даёт такая форма:
-
-- Семантически сужает контекст: только указатели, только арифметика.
-- Фиксирует ответственность: обоснование, ревью, уровень.
-- Экономит мыслетопливо: нет лишних слов, только суть.
-- Педагогически настраивает: программист осознаёт, что делает.
-
-## Сравнение подходов: почему это диалектичнее
-
-### Синтаксическая сложность
-
-- `Lisp` Очень низкая
-- `Rust` Высокая
-- `prolet` Низкая
-
-### Семантическая ясность
-
-- `Lisp` Низкая (всё — список)
-- `Rust` Высокая (много форм)
-- `prolet` Высокая (контекст + тег)
-
-### Гибкость
-
-- `Lisp` Деструктивно высокая
-- `Rust` Ограниченная
-- `prolet` Высокая (макросы + уровни)
-
-### Безопасность
-
-- `Lisp` Нет
-- `Rust` Высокая
-- `prolet` (по уровням, от минимальной до высокой)
-
-### Развитие языка
-
-- `Lisp`  доступно индивидуально
-- `Rust` Через RFC
-- `prolet` Через макросы + одобрение сверху
-
-### Экономия мыслетоплива
-
-- `Lisp` Высокая для экспертов, низкая для новичков
-- `Rust` Низкая (много правил)
-- `prolet` Высокая для всех (одна форма; много фиксированных смыслов в конкретном контексте)
-
-### Педагогичность
-
-- `Lisp` Низкая
-- `Rust` Недостаточная
-- `prolet` Высокая (постепенное раскрытие)
-
-## Заключение: язык как диалектический инструмент
-
-Приведённый синтез формы из трёх языков, соответствует духу диалектического материализма:
-
-- Форма — лисп-подобная: одна, чистая, минимальная.
-- Семантика — материалистическая: определяется практикой, контекстом, уровнем развития.
-- Переход между уровнями — не скачок, а педагогически организованный процесс.
-- Язык — не замороженный объект, а развивающийся организм.
-
-Это — не упрощение, а углубление диалектики:
-
-- мы не множим формы,
-- мы углубляем понимание единства и борьбы противоположностей в самом акте программирования.

docs/prolet-007.md

@@ -1,219 +0,0 @@
-# Диалектика развития языка
-
-В духе диалектического материализма, прототип предложенного решения оснастим ещё большей выразительностью. А именно: рассмотрим вариант синтаксиса, где базовая часть ядра языка заметно (но ненавязчиво) отличается от той части, что предлагает программист в виде своего кода. Чтобы снять противоречие старого и нового, неподвижного (и малоподвижного) от движущегося.
-
-Необходимо выполнить не просто синтез противоположностей, а разделение старого и нового на уровне внутренней семантики формы, чтобы сама структура языка отражала закон отрицания отрицания.
-
-## Единообразие внешней формы и разделение по внутренней форме
-
-Если язык претендует на диалектичность, он не может быть полностью единообразным в любой форме. Он должен материально выражать противоречие между устоявшимся и возникающим, между ядром-основой и творческим дополнением, между материей прошлого и сознанием будущего.
-
-### Диалектический принцип
-
-- Ядро языка — неподвижно (в пределах версии), но совместимо (в пределах всех версий)
-- Расширение — подвижно,
-- Но движущееся порождается из неподвижного, отрицает его,
-- И в своём развитии — отрицает отрицание,
-
-поднимая язык на новый уровень.
-
-Это — не просто метапрограммирование,
-
-это — организация языка как классовой борьбы между консервацией прошлого и революцией настоящего в сфере сознания.
-
-## Новый проект: prolet с разделённой формой существующего и нового
-
-Два слоя синтаксиса:
-
-### Ядро (Базис)
-
-- Устойчивая основа: типы, управление, память, вызовы
-- Последовательная разработка ядра на основе реальных потребностей
-- Объективный подход ко всем аспектам языка
-
-### Расширение (Творчество)
-
-- Развитие: новые парадигмы, DSL, оптимизации, замена частей ядра
-- Частные расширения синтаксиса но основе текущих потребностей
-- Субъективная инициатива
-
-Это — единство и борьба форм,
-где форма выражает содержание диалектики.
-
-## Ядро: стабильное, проверенное, материалистическое
-
-Основано на S-выражениях, как в Лиспе, но семантически строго:
-
-```prolet
-(// Если не указан атрибут изменяемости -- по умолчанию @фикс)
-(фн Cложить (a Час b Час)
-    (СложитьЧас a b))
-
-(структ Пользователь
-    @имя ЧеловекИмя
-    @возраст ЧеловекВозраст)
-
-(если (Сравнить x > 0)
-  тогда (Напечатать "Положительно")
-  иначе (Напечатать "Ноль или отрицательно"))
-```
-
-Особенности ядра:
-
-- Неизменно в рамках версии 1.x.
-- Компилируется во внутреннее представление напрямую.
-- Не может быть переопределено, но может быть перекрыто частным определением.
-- Создаётся централизованно на основе теории и практики.
-
-Это — материальная база, как производительные силы в экономике — нельзя менять каждый день,
-но можно развивать в следующей версии, с развитием производственных отношений.
-
-## Расширение: творческое, подвижное, диалектическое
-
-Работает в таких же круглых скобках, где сопровождающий атрибут `@макро` означает расширение, развитие, отрицание старого на уровне пользователя. Расширение способно заменить в текущей программе более высокоуровневые реализации.
-
-Внутри — новые формы, DSL, макросы, оптимизации. Снаружи -- прежний синтаксис.
-
-```prolet
-(макро параллельно
-  (ЗагрузитьДанные)
-  (ОбновитьИнтерфейс)
-)
-
-(макро SQL "SELECT * FROM пользователи WHERE возраст > ?" возраст }
-```
-
-Как это работает: `параллельно` — не ключевое слово, а расширение, определённое в пользовательской библиотеке, на том же уровне.
-
-Это — народное творчество, как массовое движение, которое не ломает основу, но вносит новое содержание.
-
-## Разделение форм: философская и практическая необходимость
-
-### Формы ядра
-
-- Форма: `(операция аргументы)`
-- Изменяемость: Запрещена в версии
-- Компиляция: На этапе 1
-- Авторство: разработчики ядра
-- Ответственность: Гарантирована
-- Жизненный цикл: Долгий (версии 1.0, 2.0)
-
-### Формы пользователя
-
-- Форма: `(макро содержание)`
-- Изменяемость: Разрешена, по согласованию
-- Компиляция: На этапе 2 (после ядра)
-- Авторство: Сообщество, отдельные разработчики
-- Ответственность: На авторе расширения
-- Жизненный цикл: Краткий (пробный, экспериментальный))
-
-Это — диалектическое разделение труда в языке:
-
-- Ядро — закон,
-- Расширение — инициатива,
-- Их единство — развитие.
-
-## Переход от старого к новому: процесс отрицания
-
-Пример: появление нового цикла в потоках (старое ядро):
-
-```prolet
-(для задача в списокЗадач
-    (СоздатьПоток задача))
-```
-
-После проверки практикой — включение в ядро новой версии (расширение):
-Новое (расширение):
-
-```prolet
-(параллельно (Выполнить списокЗадач))
-```
-
-Это — отрицание отрицания:
-
-- Старое `(для ... СоздатьПоток)` — отрицается,
-- Новое `(параллельно ...)` — отрицает старое,
-
-Но затем `(параллельно ...)` само отрицается — становится частью ядра, и появляется новое расширение для асинхронных потоков.
-
-## Психологическая и педагогическая выгода
-
-Для новичка:
-
-- Видит только `(...)` — простота, порядок, безопасность.
-- Расширения скрыты или отключены.
-
-Для мастера:
-
-- Может писать `(макро ...)`, на пользовательском уровне, но осознаёт, что это — эксперимент, что он выходит за рамки устоявшегося, что за это несёт ответственность. При компиляции получает уведомление (если не подавлено атрибутом)
-
-Расширения разработчиками ядра могут быть:
-
-- Одобрены,
-- Отклонены,
-- Включены в следующую версию ядра.
-
-Это — демократический централизм в действии.
-
-## Реализация на уровне компилятора
-
-Этап 1: Парсинг ядра
-
-- Обрабатывает только системные библиотеки, строит **AST**.
-- выполняет предварительную компиляцию ядра (однократно)
-
-Этап 2: Макро-раскрытие расширений на уровне пользователя
-
-- Находит `(макро ...)`, подставляет определение из зарегистрированных расширений.
-
-Этап 3: Трансляция в ядро
-
-- Все пользовательские макросы интегрируются в ядро.
-
-Этап 4: Компиляция
-
-- только изменившийся код.
-- сборка готовых модулей.
-
-Таким образом, вся сложность остаётся контролируемой, сборка занимает незначительное время, а инновации не разрушают стабильность.
-
-## Пример полного кода
-
-```prolet
-(// === ЯДРО === )
-(фн ОбработатьПакет (пакет СписокДок)
-    (если (ПроверитьЦелостность пакет)
-        тогда (Расшифровать пакет)
-        иначе (Остановить "битый пакет")))
-
-(// === РАСШИРЕНИЕ === )
-(структ ВебСервер
-  @маршрут ВебОбработчик
-  @порт    СетьПорт
-)
-
-(Печатать "Запуск сервера...")
-```
-
-Здесь:
-
-- (фн ...) — ядро, стабильно,
-- (ВебСервер ...) — использование результатов творчества, может измениться,
-- (Печатать ...) — может быть переопределён под нужды среды, вместо реализации ядра
-
-## Заключение: язык как диалектическая система
-
-- Форма ядра `(...)` — отражает устоявшееся, необходимое, объективное.
-- Форма расширения — `(макро ...)` — отражает возникающее, творческое, субъективное.
-
-Их борьба и единство — двигатель развития.
-
-Переход расширения в ядро — качественный скачок.
-
-Разделение форм — материальное выражение закона отрицания отрицания.
-
-Это — не просто язык программирования, это — модель социалистического информационного общества:
-
-- стабильный базис,
-- свободное изменение по необходимости,
-- и путь от частного к общему через практику.

docs/prolet-008.md

@@ -1,303 +0,0 @@
-# Диалектика динамики типов
-
-Рассмотрим более подробно ещё одно диалектическое противоречие: "статическая типизация -- динамическая типизация". Надо получить ясный, структурированный переход между строгой статикой и высокой динамикой. А также предусмотреть контролируемый механизм перехода из одного состояния в другое.
-
-Это не просто технический выбор между безопасностью и гибкостью, а борьба форм отражения объективной реальности в сознании программиста.
-
-- Статика — стремление к порядку, предсказуемости, закону.
-- Динамика — стремление к адаптации, изменению, практике.
-
-Их единство — не компромисс, а диалектический переход, где каждая сторона отрицает другую, чтобы породить нечто высшее.
-
-## Постановка противоречия
-
-### Плюсы
-
-- статическая типизация: Безопасность, производительность, документация в коде
-- динамическая типизация: Гибкость, быстрая разработка, адаптивность
-
-### Минусы
-
-- статическая типизация: Жёсткость, сложность, высокий порог входа
-- динамическая типизация: возможны ошибки на этапе исполнения, трудно масштабировать, слабая документация
-
-## Философия
-
-- статическая типизация: идеализм порядка (мир должен быть упорядочен)
-- динамическая типизация: идеализм вечного изменения (мир — поток, форма не важна)
-
-Ни одна сторона не может победить полностью.
-
-Победа — в синтезе, в контролируемом переходе от одной формы к другой, в зависимости от объективных условий задачи.
-
-**Цель**: `диалектическая типизация`
-
-Не смешение статики и динамики, а их единство в движении, где:
-
-- Статика — норма,
-- Динамика — вынужденное отклонение,
-- Переход — не хаос, а сознательный, контролируемый, документируемый акт.
-
-## Основные принципы диалектической типизации
-
-### Статика по умолчанию
-
-Вся переменная, функция, структура — строго типизированы.
-
-### Динамика — как отрицание нормы
-
-Разрешена только в явно обозначенных зонах.
-
-- Переход — через форму, а не через волю
-- Не просто `any`, а структурированный механизм
-
-## Обратный переход — обязательный
-
-Из динамики можно выйти только через проверку и приведение типа.
-
-### Контекст определяет
-
-- В ядре системы — только статика.
-- В интерфейсе с внешним миром — динамика разрешена.
-
-### Педагогический контроль
-
-Новичок не может использовать динамику без одобрения.
-
-## Механизм перехода: "шлюз"
-
-Введём новую конструкцию — `шлюз`,
-который ограничивает пространство и время действия динамики.
-
-Динамический шлюз -- это форма диалектического преодоления несовершенства внешнего мира.
-
-`@шлюз_вход`, `@шлюз_выход` — это не просто синтаксический сахар, это — граница между мирами, между упорядоченным миром `prolet` и хаосом внешних данных, между типизированным бытием и бестиповым небытием.
-
-Шлюз не всегда требуется при обмене с внешним миром. Если приём данных из внешнего источника из экосистемы `prolet` -- тогда такой поток байтовых данных будет сопровождаться метками типа. В этой ситуации шлюз не нужен.
-
-```prolet
-(// Внутри — следует использовать байтовый поток, атрибут на выходе -- `нечто`)
-((ВебЗапросить "/data"
-    @шлюз_вход
-    @требует_ревью) -> нечто)
-(// тип: фиксированный срез байтов)
-
-(// Обратный переход — только через проверку)
- (ЕслиНечто нечто как Структ.Пользователь
-    тогда (уст (Привести нечто к Пользователь) пользователь)
-    иначе (ПечатьОшибка "неверный формат")
-)
-```
-
-Особенности шлюза:
-
-- всегда принимает поток байт.
-- прекращает работу, если атрибут `@шлюз_вход` не указан, а формат байтового потока не имеет меток типов полей.
-- Запрещён в критических модулях (ядро, безопасность).
-- Только после ревью (для уровней < 3).
-
-Это — не либерализм, а учёт требований объективной реальности, как военный коммунизм → нэп → социализм.
-
-Суть `@шлюз_вход`: граница между мирами
-
-🌍 Два мира:
-
-```text
-МИР PROLET                   ВНЕШНИЙ МИР
-Типы — первичны              Типы — отсутствуют или скрыты
-Данные — структурированы     Данные — байтовый поток
-Порядок — внутренний         Хаос — норма
-конст, фикс, мут — везде     Никаких категорий
-```
-
-`@шлюз_вход` — это не функция, это — онтологическая граница, где байт становится сущим, а хаос — формой порядка.
-
-## Динамический тип, как переходное состояние
-
-Динамический тип — не тип-ловушка, а тип-процесс.
-
-Он не может участвовать в вычислениях напрямую. Чтобы использовать — нужно привести к статическому типу.
-
-```prolet
-(// по умолчанию статичность на выходе @фикс, параметр контакта с внешним миром -- @шлюз_вход)
-(уст (ПолучитьИзApi) x)
-
-(// Ошибка: (x + 1) — запрещено)
-(ЕслиНечто x как Целое
-    тогда (ОбработатьЧисло (Привести x в Целое))
-    иначе (ПечатьОшибка "ожидалось число")
-)
-```
-
-Это — материалистическое требование: чтобы работать с реальностью, нужно понять её структуру.
-
-Если данные пришли от другого `prolet`-процесса, и сериализованы с метаданными (структуры в духе `prolet`), то `@шлюз_вход` не нужен — это внутренний поток выраженный иными средствами для внешнего хаотического мира, как товарообмен в социалистическом хозяйстве между различными предприятиями в одной цепочке производства и в одной стране, но разных городах.
-
-Но если данные — извне:
-
-- JSON без схемы,
-- бинарный протокол,
-- CSV,
-- XML с xsi:type="string" —
-
-тогда нужен `@шлюз_вход`, потому что форма несёт в себе противоречие: `байты есть, а типов — нет`.
-
-## Система приведения типов: "путь к статике"
-
-Проверка типа:
-
-- `(ЕслиНечто х как Пользователь)` Булево, безопасно
-- Безопасное извлечение типа
-
-```prolet
-(ЕслиНечто х как Пользователь)
-    тогда (Обработать (Привести х в Пользователь))
-    иначе (ПечатьОшибка "ожидался пользователь"))
-```
-
-Приведение с проверкой `((ТипКонверт х в Пользователь) -> @фикс х)` Падает, если не подходит
-
-### Функциональный стиль
-
-Схемная валидация для сложных форматов:
-
-```prolet
-(ЕслиНечто байты к Схема.Пользователь
-    тогда (уст (Привести байты в Схема.Пользователь) х)
-    иначе (ПечатьОшибка "ожидалось число"))
-```
-
-Переход из динамики в статику — не автоматический, а требующий сознательного усилия, как переход от чувственного восприятия к рациональному пониманию.
-
-## Контекстно-зависимая типизация: где разрешена динамика?
-
-- ввод: файлы (Внешний мир не контролируется)
-- ввод: внешние __API__ (не из экосистемы)
-- ввод: конфигурация (не из экосистемы)
-
-Это — не абсолютизация, а диалектический релятивизм: истина — в конкретной практике.
-
-## Развитие типов: от динамики к статике через практику
-
-Когда динамический интерфейс стабилизируется, его можно возвысить до статического закона:
-
-```prolet
-(// Сначала — динамически, "ЗапросАпи" определён как @шлюх_вход, и данные как @фикс)
-((ЗапросАпи @шлюз_вход) -> данные)
-(ЕслиНечто нечто как Схема.ФорматV1
-        тогда ...
-        иначе ...)
-
-(// Через месяц практики — выносим в структур)
-(структ ФорматV1
-  @поле1 Накладная.Название
-  @поле2 Список.Целое)
-
-(// Использование через приведение, результат определён как @фикс)
-(ЕслиНечто х как ФорматV1
-    тогда (уст (ЧитатьИз "data/sample.json") конфигТекст)
-)
-```
-
-Это — отрицание отрицания: динамика отрицает статику, но на основе практического действия — порождает заново безопасную статику.
-
-## Почему именно `@шлюз_вход`, а не просто функция?
-
-Потому что:
-
-- Это — не вычисление,
-- Это — переход количества в качество,
-- Это — восстановление формы из хаоса.
-
-Как у диалектики: `Из хаоса — порядок, из количества — качество`.
-
-## Почему `@шлюз_вход` — однонаправленный?
-
-Потому что:
-
-- Вход — из байт → в типизированное сущее — требует труда, проверки, интерпретации.
-- Выход — из `prolet` → в байты — может быть автоматическим, если используется самоописывающий формат (например, `prolet-bin` с метками типов).
-
-Но если выход — в неструктурированный формат (например, `raw TCP`), то нужен обратный шлюз — `@шлюз_выход`:
-
-```lisp
-(фн Отправить (x Пользователь)
-    @шлюз_выход
-    @цель legacy_система
-   (СериализоватьБезТипов x))
-```
-
-Это — единство и борьба: вход и выход — разные по природе, потому что мир в динамике асимметричен.
-
-## Что делает `@шлюз_вход` на уровне ВМ?
-
-При встрече `@шлюз_вход`:
-
-- Активируется режим проверки:
-- Все значения извне — являются срезом байт.
-- Нельзя использовать напрямую.
-
-Требуется явное приведение:
-
-- `(тип х как Пользователь)` → с проверкой.
-- Или — `(ПробаИз ... как Схема.ХХХ)`.
-
-Фиксируется событие:
-
-- В лог: `(@шлюз_выход @логОткл)` (по умолчанию активно).
-- В граф жизненного цикла — новая ветвь анализа.
-
-## Психологические и педагогические механизмы
-
-Для новичка:
-
-- Динамика отключена.
-- При попытке использовать — подсказка: "Динамические типы доступны после прохождения модуля 'Работа с внешними данными'".
-
-Для мастера:
-
-- Можно использовать динамический шлюз,
-- но только с обоснованием, и с автоматическим логированием всех операций (включено по умолчанию).
-
-Для системы:
-
-- Все динамические участки автоматически документируются.
-- Нет идеалистических типов данных (всегда присутствует байтовый поток).
-- При стабилизации — предлагает: "Этот шлюз использован 100 раз. Создать статический тип?" (возможна автоматическая генерация обратимого конвертера)
-
-## Пример: полный цикл перехода
-
-```prolet
-(// Внешний API — неизвестная структура)
-(уст (ВебЗапросить "https://api.partner/data"
-                @шлюз_вход) нечто @фикс)
-
-(// Проверка и переход к статике)
-(ЕслиНечто нечто как Схема.АнализДанных)
-    тогда (
-        (уст (Привести нечто в Схема.АнализДанных) отчёт @фикс)
-        (ОтправитьОтчёт отчёт))
-    иначе (ПечататьОшибку "некорректные данные"))
-
-(// Определение типа на основе практики)
-(структ АнализДанных
-  @показатель ПроцентПлана
-  @дата       АбсолютнаяМетка
-  @регион     РегионПеречисление
-  @_док       "Анализ данных по регионам с привязкой по времени")
-```
-
-От хаоса внешнего мира → к порядку внутренней системы через безопасные однонаправленные шлюзы.
-
-## Заключение: типизация как диалектический процесс
-
-Предлагаемое решение не устраняет противоречие, а развивает отношения внутренних форм в конкретной ситуации:
-
-- Статика — не догма, а результат победы над хаосом.
-- Динамика — не свобода, а временное отступление перед объективной необходимостью, но без отрыва от реальности.
-- Переход — не скачок, а контролируемый, документируемый, педагогически организованный процесс.
-- Язык — не набор правил, а механизм познания реальности через типы.
-
-Это — не просто типовая система, это — диалектика познания:
-
-от незнания → к гипотезе (динамика) → к истине (статика).

docs/prolet-009.md

@@ -1,230 +0,0 @@
-# Диалектическая несостоятельность nil
-
-Очередное диалектическое противоречие для рассмотрения `сущее - не сущее`. Ошибка на миллиард долларов в нашем новом, диалектическо-материалистическом языке недопустима. Наша модель языка должна отражать реально существующий мир.
-
-Рассмотрим корень диалектического материализма, его онтологическую основу:
-
-- `Сущее` vs `не сущее`,
-- `Бытие` vs `Небытие`,
-- `Материя` vs `Пустота`,
-- `Наличие` vs `Отсутствие`.
-
-Это не просто «обработка nil» — это фундаментальное противоречие, лежащее в основе всего сущего. И если мы хотим построить язык, который отражает реально существующий мир, а не идеальный мир платоновских форм, то мы обязаны решить это противоречие диалектически, а не технически, или прагматически, или сугубо субъективно.
-
-## Философская основа: "сущее и не сущее" в диалектическом материализме
-
-### Материя первична — сущее есть
-
-В диалектическом материализме только _объективно существующее_ — _есть_.
-
-Всё остальное — отражение, потенциальность, но не `бытие`.
-
-`Сущее` — это то, что взаимодействует с миром, что занимает место в пространстве-времени, что оказывает воздействие.
-
-`Не сущее` — это отсутствие материи, небытие, ничто.
-
-Но! Диалектика учит: ничто не возникает из ничего, и ничто не исчезает в ничто.
-
-Следовательно, `не сущее` — не абстракция, а момент развития материи вне установленных философских категорий -- `нечто`.
-
-### Противоречие в программировании: null, undefined, None, nil
-
-В большинстве языков: `nil` — это "значение, которое не есть значение".
-
-Это — онтологическая ошибка: признание существования небытия как равноправного с бытием.
-
-Пример катастрофы:
-
-```java
-String name = user.getName(); // может быть null
-int len = name.length();     // NullPointerException — ошибка на миллиард долларов
-```
-
-Это — не ошибка программиста, это — ошибка _онтологии языка_, который допускает, что `не сущее` может передаваться как `сущее`.
-
-## Идеалистические ошибки в типизации "сущее/не сущее"
-
-### C/C++
-
-`NULL` — указатель в никуда
-
-Допускает использование "ничего" как "чего-то"
-
-### Java/Python
-
-`null`/`None` — объект-пустота
-
-Придаёт небытию форму бытия
-
-### Haskell
-
-`Maybe a` — чисто, но абстрактно
-
-Отделяет форму от материи
-
-### Rust
-
-`Option<T>` — шаг вперёд, но не до конца
-
-`None` — всё ещё "значение", хотя и обёрнуто
-
-**Все они** — идеалистические компромиссы:
-
-- признают небытие как форму бытия,
-- вместо того, чтобы разрешить противоречие через практику.
-
-## Диалектическое решение: "сущее" и "нечто" как реально существующие противоположности в движении
-
-Принципы онтологии языка `prolet`:
-
-- Только `сущее` может быть значением.
-- Если чего-то нет — оно не может быть передано, не может быть переменной, не может быть в вычислении.
-- `нечто` — не значение, а реально существующее состояние процесса.
-- Оно не существует само по себе, а возникает в практике получения сущего без формы.
-- Переход от `нечто` к `сущему` — через труд, проверку, практику.
-- Как в жизни: хлеб не берётся из воздуха — он выращивается, обрабатывается, доставляется.
-- Язык не допускает "пустоту" как объект — он требует решения.
-
-Нет `null`. Нет `None`. Есть `нечто` как сущее, но неопределённое.
-
-## Механизм: нечто — тип, как пространство поиска сущего
-
-Вместо `Option<T>` или `null` — вводим сущность `нечто`, которая является типом, обозначает пространство неопределённости, в котором ещё не решено, есть ли сущее. Но сама содержащая неопределённость сущность `нечто` -- существует всегда.
-
-```prolet
-(// 1. Внешний источник — может не дать сущего,
-если шлюз принимает данные не от prolet-процесса)
-(прц ЗапросИзАпи @шлюз_вход () -> нечто
-    ...)
-
-(// Внутри `нечто` — нельзя использовать напрямую,
-ОШИБКА КОМПИЛЯЦИИ )
-(ОбработатьДанные)
-
-(// Переход к сущему — только через практику)
-(ЕслиНечто нечто как Пользователь
-    тогда (Обработать (Привести нечто к Пользователь))    (// нечто — теперь сущее)
-    иначе (ВосстановитьПоУмолчанию)) (// нет сущего — альтернатива)
-```
-
-Ключевые особенности:
-
-- `нечто` — тип для определения пространства возможного.
-- Переменная нечто имеет значение до проверки, но не имеет определённого типа
-- После тэга `ЕслиНечто` — в ветке `тогда` переменная становится сущей.
-- В ветке `иначе` — альтернативное действие.
-
-Это — единство бытия и небытия в процессе познания:
-
-- пока не проверили — нечто, а не сущее,
-- после проверки — сущее возникает как результат практики.
-
-## Онтологическая строгость: никакого "значения-пустоты"
-
-Сравните:
-
-### Небытие-значение (ошибка)
-
-```Java
-String s = null;
-```
-
-### Небытие — обёрнуто, но существует (потенциальная ошибка)
-
-```Rust
-let s: Option<String> = None;
-```
-
-### Нечто — не значение, а состояние поиска
-
-```prolet
-((прц ИзПорта @шлюз_вход) -> @фикс нечто)
-```
-
-В `prolet` нельзя написать:
-
-```lisp
-(уст (Пусто) @фикс дыра) (// ОШИБКА: "ничего" не есть)
-```
-
-Потому _что ничего не есть_.
-
-## Практическая реализация: три формы работы с _не-сущим_
-
-### Форма 1: Проверка (познание через практику)
-
-```prolet
-((НайтиПоНомеру (123 125)) -> нечто)
-
-(ЕслиНечто нечто как Пользователь
-    тогда (
-        (уст (Привести нечто к Пользователь) пользователь)
-        (напечатать "Здравствуй, " пользователь имя)
-    )
-    иначе (напечатать "Пользователь не найден"))
-```
-
-Только после проверки — пользователь становится сущим.
-
-## Форма 2: Принудительное извлечение (с ответственностью)
-
-```lisp
-(фн ПрочитатьФайл @шлюз_вход() -> @фикс нечто)
-
-(ГарантНечто нечто как Пользователь
-    @_док "данные обязательны, ошибка конфигурации"
-    иначе (уст (ПользовательНовый) @фикс пользователь)
-```
-
-Гарантировать — не отрицание онтологии, а утверждение сущего на основе практики.
-
-Но требует введения небытия и работает только в контролируемых условиях.
-
-## Педагогический и психологический аспект
-
-- Новичок не может использовать `нечто` без `ЕслиНечто`.
-- `ГарантНечто` вернёт сущее.
-
-**IDE** подсвечивает:
-
-- "Переменная 'нечто' — не содержит конкретной формы. Проверьте перед использованием."
-- При попытке передать `нечто` в функцию, ожидающую сущее — ошибка компиляции.
-
-Это — формирование диалектического сознания: программист учится не признавать пустоту как бытие, а искать сущее в практике.
-
-## Философское обобщение: онтология языка
-
-### Бытие
-
-- Только то, что существует, имеет форму, действует
-- Переход от `нечто` к `сущему` через проверку
-
-### Небытие
-
-- Не может иметь форму
-- Нет возможности перехода к сущему
-
-### Ошибка онтологии
-
-Не Использование `nil`, а признания небытия как невозможное в реальном мире
-
-Язык не допускает онтологической лжи.
-
-Он требует:
-
-- Либо — сущее,
-- Либо — честное признание, что его ещё нет,
-- Либо — создание альтернативного сущего.
-
-## Заключение: язык как отражение реального мира
-
-Дано решение главного противоречия:
-
-`prolet` не допускает ошибки на миллиард долларов, потому что он не допускает лжи онтологии.
-
-- В нём нет места `nil`, потому что _ничего не есть_.
-- В нём есть место практике, потому что сущее рождается в труде.
-- В нём есть место неопределённости, но не как значению, а как пространству поиска.
-- В нём программист — не маг, а труженик, добывающий сущее из потенциально сущего.
-
-Это — не просто безопасность, это — материалистическая честность, это — диалектика бытия, воплощённая в синтаксисе.

docs/prolet-010.md

@@ -1,273 +0,0 @@
-# Диалектическая онтология типов
-
-Диалектическая онтология типов подчиняется тем же законам, что и весь диалектический материализм.
-
-- От отрицания простого, к снятию противоречия в виде сложного.
-- От базового, к универсальному.
-
-Диалектическая онтология типов как отражение структуры объективной реальности.
-
-Мы уже отвергли идеалистические перекосы:
-
-- `nil` как "сущее небытие",
-- динамика как хаос,
-- синтаксис как идеалистическая бюрократия.
-
-Но теперь настал момент синтеза:
-
-- от отрицания простого (примитивных типов)
-- к снятию противоречия в форме сложного, универсального, развивающегося
-
-к диалектической онтологии типа.
-
-## Диалектический путь развития понятия "тип"
-
-### Простое (метафизика)
-
-Тип — ярлык, классификация. Неподвижен.
-
-`int` , `string` , `bool`
-
-Противоречие: Простые типы не отражают сложность мира. Возникает потребность в составных. Простые типы поглощаются составными.
-
-`struct` , `type` , `tuple`, `list`
-
-Кроме того, `Целое` — как простой тип не просто число, а объект с поведением. Поведение объекта, способы взаимодействия с миром определяются свойствами самого объекта. С другой стороны, те же свойства объекта диалектически накладывают ограничения на тот же объект.
-
-### Снятие противоречия (синтез)
-
-Базовый тип-процесс, отношение, структура в движении. Универсальный тип, порождающий себя и служащий строительным материалом для порождения других типов.
-
-Это — не эволюция, а революция в мышлении:
-
-- тип перестаёт быть статической меткой,
-- и становится формой существования материи в информационной сфере.
-
-`Целое` не просто как один из типов, а как фундаментальный тип реальности.
-
-## Критика метафизического подхода к типам
-
-Ошибка: тип как "вещь в себе"
-
-В `C` , `Java` , `Python` : `int` — это нечто отдельное, не связанное с практикой.
-
-Но в реальности:
-
-- Целое в банковской системе ≠ Целое в физике частиц,
-- Строка в **UI** ≠ Строка в криптографии.
-- Метафизика абстрагируется от содержания,
-- идеализм отрывает форму от материи.
-
-Нет никакого абстрактного `int` . Есть:
-
-- число яблок
-- число груш
-- число аршин сукна
-
-Это всё целые числа, но это _разные_ целые числа. Нельзя складывать _число яблок_ с _числом груш_. Это разные _числа_. Но, складывая эти разные числа -- можно получить _число фруктов_, как число нового типа.
-
-Важное замечание: арифметический знак `+` при подобном сложении будем неадекватным, так как не отражает _диалектический процесс превращения_ одного вида материи в другой.
-
-## Диалектическая онтология типа: тип как единство формы, содержания и практики
-
-Принципы:
-
-### Тип — не ярлык, а категория бытия
-
-Отражает объективную структуру предметной области
-
-### Тип возникает в практике
-
-Не задаётся сверху, а вырастает из задачи
-
-### Тип — в движении форм материи
-
-Развивается, дополняется, трансформируется
-
-### Тип — отношение форм материи
-
-Не изолирован, а связан с другими типами, с памятью, с временем
-
-### Тип — результат познания материи
-
-Чем глубже понимание — тем точнее тип. Тип — это не только ответ на вопрос "что это", но и "почему", "каким образом", "зачем".
-
-## Путь от базового к универсальному: три стадии онтологического развития
-
-### Стадия 1: Отрицание абстрактов (антипод метафизике)
-
-Мы отрицаем существование "абстрактных типов" как таковых.
-
-Нет `int` . Есть `Счёт` , `Индекс` , `Количество` , `КодОшибки` .
-
-Нет `string` . Есть `Имя` , `Хэш` , `Запрос` , `Ответ` .
-
-```prolet
-(тип Рубль или Рубля или Рублей (// синонимы типа)
-    @_база    Целое             (// Абстракция в основе типа)
-    @_диапазон (0 999_999_999)  (// Допустимый диапазон на базе абстрактного типа)
-    @_операции (слож выч))      (// Допустимые операции над конкретным типом)
-```
-
-Примитив не уничтожен, но воспроизведён на новом уровне — как осмысленная категория.
-
-### Онтологическое уточнение: свойство `@_база Целое`
-
-Свойство `@_база` опирается на аппаратную абстракцию `Целое`, но по отношению к материалистичному миру является сущим _только в рамках математического дискурса_. Т.е. математические типы не ограничиваются типом `Целое`. Но этим типом ограничивает аппаратура.
-
-Это — _ключевое_ уточнение, которое позволяет не отступать от диалектического материализма, но признать относительную самостоятельность аппаратного, равно и математического мышления как _специфической формы отражения реальности_.
-
-### Интерпретация
-
-ПОНЯТИЕ|          СТАТУС В ОНТОЛОГИИ PROLET
- -------- | -----------------------------------
-`Целое`    | Не первичная данность, а результат высшего обобщения практики счёта (считали камни, яблоки, дни — и выделили общую форму)
-Аппаратный дискурс | Специфическая техническая практика, в которой абстракция (вроде `Целое`) обращаются как сущее, хотя она и есть специфичная форма материи
-@база      | Указание на форму, заимствованную из математического дискурса, но используемую как инструмент для организации сущего
-
-Это — не признание платонизма, а признание автономии отражения.
-
-Как язык отражает мир, так и аппаратура, так и математика — отражает количественные отношения, и эти отношения не существуют вне практики.
-
-📜 Принципы объявления типов `prolet`
-
-- Тип — только материализованная форма сущего
-- `Целое`,  `Строка`,  `Дробное`,  `Логическое` — не типы, а базовые абстракции
-- `@база` — не наследование, а заимствование формы из дискурса аппаратного обеспечения
-- Тип всегда имеет социальный, экономический или технический контекст
-- Без свойств, отражающих практику — _нет типа_
-- Определение вида c использованием аппаратного типа `(тип Целое ...)` — ошибка онтологии, запрещено
-
-## Стадия 2: Сложное — как единство противоположностей
-
-Структура — не просто набор свойств, а единство противоречий:
-
-```prolet
-
-(// любой тип имеет одно значение,
-не число свойств может быть любым)
-(тип Роль или Права
-    @_обязательно
-    @_база Перечисление
-    @_выбор_ (Админ Пользователь Гость)
-    @значение Гость (// По умолчанию, можно менять)
-    @_док "Роль пользователя в системе"
-
-(тип ПользовательНомер
-    @_обязательно
-    @_база          Целое
-    @_диапазон      (1 999_999_999)
-    @_автоИнкремент
-    @_уникально
-    @_док ( "идентификация пользователя в системе")
-
-(тип Имя или Название
-    @_база      Строка
-    @_умолчание "Иван"
-    @_док       "идентификация пользователя в системе")
-
-(структ Пользователь
-    @_номер ПользовательНомер
-    @имя  Имя (// Можно менять)
-    @счёт Счёт
-    @роль Роль
-    @если_акт Активность
-)
-```
-
-Свойство в структуре может ссылаться только на практический тип — то есть на материализованное сущее (тип или структура).
-
-Прямая ссылка на аппаратную абстракцию вне явно обозначенных границ (`Целое`, `Вещ` и т.п.) — запрещена.
-
-Все свойства, помечены префиксами:
-
-- `@_база` -- системный, нельзя изменить
-- `@значение` -- пользовательский, можно изменять.
-
-В приведённом синтаксисе достигается единство формы и содержания:
-
-- Разделение "атрибут vs поле" — идеализм, ведущий к ложному противопоставлению "сущности" и "её свойств". В предлагаемом подходе всё является свойством.
-- В реальности — есть только объект с характеристиками: у человека — имя, возраст, роль, статус, история.
-- Нет "основных данных" и "метаданных" — есть все данные как единое сущее.
-
-### Философский и практический смысл
-
-АСПЕКТ    |   ОБЪЯСНЕНИЕ
-  ------  |      ---------------------------
-Онтология |  Тип — не шаблон, а форма сущего в практике. Если в практике номер всегда уникален и присваивается автоматически, то такие свойства — часть его бытия, а не внешнее условие.
-Единство формы  |   Если ПользовательНомер используется в 10 структурах — не нужно 10 раз писать `@уникально`. Нарушение — на уровне типа, а не контекста.
-Безопасность  |  Система гарантирует уникальность и обязательность на уровне типа,    а не доверяет типу "не забыть".
-Эволюция практики  | Если правило изменится (например, номер перестанет быть авто-инкрементным), —  меняется одно свойство в типе
-
-### Принципы проектирования в prolet
-
-- Тип несёт свои нормы: `@обязательно`, `@уникально`, `@авто-инкремент`, `@умолчание` — определяются в (тип ...)
-- Структура — композиция, а не конфигурация: она не задаёт правила, а использует уже заданные
-- Свойства в структуре — только контекстные: например, `@источник`, `@момент`, `@ответственный`, но не базовые свойства типа
-- Повторное указание свойств типа в структуре — избыточно и запрещено, но не запрещены свойства самого свойства (свойство структуры рассматривается как тип на своём уровне)
-- Тип — со всеми своими свойствами, законченная форма сущего, пригодная к использованию в любой структуре
-
-## Форма 3: интерфейс — тип как отношение
-
-```prolet
-(интерфейс ИХранилище
-    @_док "Абстракция работы с хранилищем"
-    (ПолучФайл (имя ИмяФайла @фикс) ->Результат Спис.Байт @фикс
-        @_док "Читает файл с диска")
-    (ЗаписатьФайл (имя @фикс ИмяФайла данные @фикс Спис.Байт) -> @фикс Результат Логическое
-        @_док "Записывает файл на диск")
-    (ЗакрытьХранилище)
-)
-
-(уст (НовХранилище) @мут хран)
-(хран ПолучФайл "test.txt")
-```
-
-Интерфейс определяется не сущностью, а связями — как в диалектике.
-
-- интерфейс — объявляет форму взаимодействия, а не математическую сигнатуру
-- Каждое действие — глагол, отражающий практику
-- Параметры: `(имя Тип, данные Тип)` — именованные, ссылаются на типы
-- Возврат: (Результат Тип) — структура, отражающая результат практики
-- Возвращаемый результат может отсутствовать
-- Все типы в интерфейсе — практические, определённые через (тип, структ, ...)
-- @_док — не обязателен для каждого метода и интерфейса, но можно потребовать обязательность на уровне проекта или конкретного действия
-- Интерфейс не содержит реализации — только действия с параметрами и возвращаемые значения
-
-## Онтологическая иерархия типов
-
-```text
-    Математические типы (отрицание)
-      ↓
-    Конкретные типы (противоположность)
-      ↓
-    Структуры (синтез)
-      ↓           ↘
-    свойства    действия
-                    ^
-                Интерфейсы
-```
-
-Это — спираль развития, а не лестница.
-Каждый новый тип — не просто добавление,
-а результат борьбы и единства противоположностей.
-
-## Практические гарантии онтологии
-
-- Нет "голых" примитивов в публичных интерфейсах.
-- Все типы — документированы, семантически обогащены.
-- Переход от простого к сложному — не волевой, а мотивированный практикой.
-- форма — не обязательна, но поощряется в крупных системах.
-
-## Заключение: онтология как отражение мира
-
-- предложенная онтология отрицает метафизику примитивов,
-- Разрешает противоречие между простым и сложным,
-- Снимает противоречие в универсальной форме,
-- Делает тип не статической меткой, а категорией бытия, движения и отношения.
-
-Это — не просто система типов, это — модель познания мира:
-
-`от чувственного (примитив)` → `к рациональному (сложное)` → `к диалектическому (универсальное)`.
-
-Язык, построенный так, не может допустить ошибку на миллиард долларов, потому что он не позволяет мыслить иначе, чем в категориях реальности.

docs/prolet-011.md

@@ -1,142 +0,0 @@
-# Диалектика становления: абстракция - конкретное - обобщение
-
-Дерево сущностей в **prolet** представлено ниже:
-
-```text
-    Обобщённые абстракции (отрицание)
-      ↓
-    Конкретные типы (противоположность)
-      ↓
-    Структуры (синтез)
-      ↓           ↘
-    атрибуты     методы
-                    ^
-                Интерфейс
-```
-
-В данном случае отображается не иерархия типов, а онтологический процесс становления, в соответствии с законами диалектического материализма:
-
-- `отрицание` → `противоположность` → `синтез`,
-- `форма` → `содержание` → `единство формы и содержания`.
-
-Разберём схему более подробно, уточним и закрепим эти положения как каноническое _отражение развития сущего_ в **prolet**.
-
-## 🔍 Диалектический разбор
-
-### Обобщённые абстракции (отрицание)
-
-**Что**: `Целое`, `Строка`, `Перечисление`, `Массив`, `Логическое` — формы из математического или логического дискурса.
-
-**Статус**: не типы, а отрицание конкретности, идеализированные формы, выделенные из практики.
-
-**Роль в диалектике**: «Отрицание первичной практики счёта, измерения, классификации».
-
-❗ В **prolet** нельзя использовать напрямую — только через `@_база`.
-
-### Конкретные типы (противоположность)
-
-**Что**: `Рубль`, `ЧеловекИмя`, `ПользовательНомер`, `Роль` — материализованные формы сущего, возникшие в практике.
-
-**Статус**: противоположность абстракциям — они вписаны в контекст, имеют единицы, ограничения, назначение.
-
-**Роль в диалектике**: «Противоположность идеализму — конкретное, социальное, ограниченное сущее».
-
-✅ Определяются через `(тип ... @_база Абстракция)`.
-
-### Структуры (синтез)
-
-**Что**: `Пользователь`, `Заказ`, `Документ` — формы композиции, отражающие организацию практики.
-
-**Статус**: синтез абстрактного и конкретного — не просто набор полей, а целостная форма сущего, в которой отношения между частями — так же важны, как и сами части.
-
-**Роль в диалектике**: «Синтез: не тип, не значение, а форма организации практики».
-
-✅ Определяются через `(структ ...)`.
-
-### Атрибуты
-
-**Что**: `@_база`, `@_диапазон`, `@_обязательно`, `@значение`, `@активен` — характеристики сущего.
-
-**Происхождение**: Унаследованы от структур, как их внутренние свойства.
-
-**Роль**: Отражают состояние, статус, ограничения, контекст.
-
-✅ Атрибуты — не метаданные, а сущее, выделенное из структуры.
-
-## Методы и Интерфейсы
-
-```text
-    структуры
-      ↓
-    методы
-      ↑
-  интерфейсы
-```
-
-**Методы**: действия, применяемые к структурам — `ПроверитьАктивность`, `ОтправитьЧерезПочту`.
-
-**Интерфейсы**: обобщение методов, отражающее форму взаимодействия с сущим, независимо от реализации.
-
-💡 Интерфейс — не "сверху", а "снизу": он возникает как обобщение практики работы со структурами, как отрицание конкретной реализации.
-
-✅ Таким образом:
-
-- Структуры порождают методы,
-- Методы обобщаются в интерфейсы,
-- Интерфейсы — отрицание конкретности методов, но на основе практики.
-
-🔄 Полная диалектическая цепочка
-
-```text
-      (1) Обобщённые абстракции
-               ↓
-          (отрицание практики)
-               ↓
-     (2) Конкретные типы
-               ↓
-    (противоположность абстракции)
-               ↓
-       (3) Структуры
-               ↓
-         (синтез формы и содержания)
-        ↓             ↘
-(4) Атрибуты        (5) Методы
-                       ↓
-                 (6) Интерфейсы
-                       ↑
-              (обобщение практики)
-```
-
-## 📜 Онтологическое содержание уровней
-
-- Обобщённые абстракции: `Целое`, `Строка` (Идеализация практики)
-- Конкретные типы: `Рубль`, `Роль` (Материализация абстракции)
-- Структуры: `Пользователь`, `Заказ` (Форма организации сущего)
-- Атрибуты: `@_база`, `@активен` (Характеристики сущего)
-- Методы: `ПроверитьАктивность` (Действия над сущим)
-- Интерфейсы: `Хранилище`, `Аутентификатор` (Обобщение форм взаимодействия)
-
-## 💡 Философское обоснование
-
-Идеи языка следуют диалектическому материализму:
-
-- Развитие идёт не сверху вниз, а от практики к её обобщению.
-- Интерфейс не первичен, он — порождение практики работы со структурами.
-- Абстракция не основа, она — отрицание конкретного,
-- а конкретный тип — противоположность абстрактного обобщения,
-- структура — синтез конкретных типов.
-💬
-«Не `interface` как божественный замысел, а `структ` как продукт труда, и интерфейс как его обобщение —
-вот путь материалистического программирования».
-
-## 🏁 Заключение
-
-Установлена онтологическая модель **prolet**:
-
-Это не иерархия типов.
-
-Это — диалектика становления сущего: `от идеализированной формы` → `к конкретному` → `к организованному` → `к взаимодействующему`.
-
-**prolet** — не язык программирования.
-
-Это — _язык фиксации развития практики_.

docs/prolet-012.md

@@ -1,145 +0,0 @@
-# Диалектика изменяющего и трансформирующего действия
-
-Язык, отражающий диалектически реальный мир должен явно в общей форме различать две типа тэгов-действий: процесс и функция.
-
-Первое -- может приводить к разным результатам при одном порядке действий.
-
-Второе -- имеет всегда одно и то же завершение при одних и тех же входных данных (чистая функция).
-
-Введение чёткого онтологического различия между двумя формами действия в языке **prolet** позволяет добиться следующих диалектических эффектов:
-
-- _процесс_ — _форма практики_, зависящая от материи, времени и условий, может давать разные результаты при одинаковых шагах.
-- _функция_ — _форма чистого преобразования_, детерминированная, всегда дающая одинаковый результат при одинаковых входах.
-
-Это — не просто синтаксическое различие.
-
-Это — отражение диалектики необходимости и случайности, единства и борьбы противоположностей: материи и формы, практики и логики, времени и закона.
-
-## ✅ Принятое положение
-
-В коде на языке **prolet** различаются два типа тэгов-действий :
-
-- `(прц ...)` — материальный процесс, зависящий от внешних условий, времени, состояния системы.
-- `(фн ...)` — чистое преобразование, не имеющее побочных эффектов, детерминированное, отвечающее критерию математической функции.
-
-## 🔁 Диалектическое различие
-
-КАТЕГОРИЯ |  ПРОЦЕСС | ФУНКЦИЯ
----|---|---
-Природа |  Материальный, исторически обусловленный | Формальный, логически детерминированный
-Зависимость от времени |   Да: каждый запуск — новый момент  | Нет: время не влияет
-Побочные эффекты |   Допустимы (запись, отправка, изменение)|  Запрещены
-Детерминированность |  Нет: может зависеть от шлюзов, состояния |  Да: одинаковые входы → одинаковые выходы
-Онтологический статус|Практика, действие, изменение|Закон преобразования
-Аналог в реальности|Работа завода, регистрация пользователя|Формула: f(x) = x²
-
-💬 Процесс — это диалектика материи в движении.
-Функция — это закон, выделенный из практики.
-
-## ✅ Форма объявления: процесс
-
-```prolet
-(прц ОтправитьУведомление
-    (пользователь @фикс Пользователь сообщение @фикс Сообщение)
-                                            -> @фикс Результат КодОшибки
-
-    (если (ПроверитьАктивность пользователь)
-        тогда ((ПодготовитьСообщение сообщение)
-                (ОтправитьЧерезПочту (ПолучитьПочту пользователь) сообщение)
-                (ЗаписатьЖурнал "Уведомление отправлено"))
-    )
-)
-```
-
-### Семантика процесса
-
-Может возвращать разные результаты при одинаковых `пользователь` и `сообщение`:
-
-- почта упала,
-- email изменился,
-- пользователь деактивирован.
-
-Имеет побочные эффекты:
-
-- запись в журнал,
-- отправка.
-
-Зависит от времени и состояния системы.
-
-❗ Это — _не функция_, а _практика социального взаимодействия_.
-
-## ✅ Форма объявления: функция
-
-```prolet
-(фн ПолучитьКвадрат (x @фикс Число) -> @фикс Число)
-    (Умножить x x))
-
-(фн ФорматироватьИмя (имя @фикс Имя фамилия @фикс Фамилия) -> @фикс Текст)
-    (Соединить фамилия " " имя))
-```
-
-### Семантика функции
-
-- При одинаковых `x` всегда вернёт одинаковый результат.
-- Нет побочных эффектов: не пишет, не отправляет, не изменяет.
-- Не зависит от времени, состояния, внешних условий.
-- Может быть вычислена в любой момент, _даже заранее_.
-
-✅ Это — чистое преобразование, заимствованное из логического дискурса, но вписанное в практику как инструмент.
-
-## 📜 Онтологические правила `prolet`
-
-ПРАВИЛО|ФОРМУЛИРОВКА
----|---
-1|процесс -- действие, зависящее от материи и времени, может давать разные результаты
-2|функция -- чистое преобразование, всегда одинаковый результат при одинаковых входах
-3|функция не может вызывать процесс (иначе — не чистая)
-4|процесс может использовать функцию (как инструмент преобразования)
-5|функция не имеет побочных эффектов
-6|процесс может иметь побочные эффекты (запись, отправка, изменение)
-7|функция может быть встроена в процесс, но не наоборот
-
-## 🔄 Пример: процесс, использующий функцию
-
-```prolet
-(прц ОбновитьПрофиль (пользователь @мут Пользователь
-                    имя_новое @фикс Имя
-                    фамилия_новая @фикс Фамилия) -> Результат
-    (если (ПроверитьПрава пользователь)
-    тогда (
-        ((ФорматироватьИмя имя_новое фамилия_новая) -> полноеИмя @фикс)
-        (СохранитьБаза пользователь полноеИмя))
-    )
-)
-```
-
-Здесь:
-
-- ФорматироватьИмя — функция, чистая, детерминированная.
-- ОбновитьПрофиль — процесс, зависит от прав, состояния базы, времени.
-
-## 💡 Философское обоснование
-
-Нотация следует духу диалектического материализма:
-
-- Материя первична — процесс отражает её движение.
-- Форма вторична — функция — идеализация, выделенная из практики.
-- Но форма может служить практике — функция используется внутри процесса.
-- Но не наоборот — практика не может быть сведена к форме.
-
-## 💬 «Функция — как формула в голове инженера
-
-- Процесс — как работа завода.
-- Формула помогает управлять заводом,
-- но завод не сводится к формуле.
-
-## 🏁 Заключение
-
-В этой части установлено ключевое онтологическое различие:
-
-- функция — закон преобразования, выделенный из практики, но не зависящий от неё.
-- процесс — реализация практики, зависящая от материи, времени, случайностей.
-
-`prolet` больше не смешивает форму и содержание.
-
-Он разделяет их — чтобы соединить на высшем уровне.

docs/prolet-013.md

@@ -1,200 +0,0 @@
-# Присвоение результатов как диалектическое отражение времени
-
-В языке программирования **prolet**, присвоение основано на стреле времени и онтологической чёткости: присвоение — не операция в стиле `x = f()`, а процесс перехода от действия к сущему,
-зафиксированный как направленное преобразование во времени:
-
-`(выражение) -> @фикс переменная`
-
-Это — не синтаксический курьёз.
-
-Это — онтологическая фиксация становления:
-
-- сначала — процесс,
-- потом — сущее.
-
-Мы живём в мире, где стрела времени всегда направлена в одну сторону. Это означает, что все процессы протекают в одном направлении вдоль оси времени (даже если процесс обратим).
-
-Поэтому и синтаксис языка должен следовать реальности в духе диалектического материализма.
-
-Это — не просто замечание. Это объективное требование, чтобы язык **prolet** не просто описывал сущее, а воспроизводил в своей форме саму природу бытия: материю, движение, развитие, необратимость времени.
-
-## Отражение односторонней направленности времени
-
-- Все процессы — упорядочены по оси времени,
-- Все операции — имеют начало, развитие и результат,
-- Никакого «возврата в прошлое»,
-- Никакого «параллелизма без указания порядка»,
-- Никакого «абстрактного одновременного существования».
-
-## 🔁 Диалектика времени и языка
-
-- Время -- Одностороннее, необратимое
-- Синтаксис -- линейный, направленный
-- Процесс -- Развивается: причина → следствие
-- Код -- отражает последовательность
-- Обратимость -- Физически возможна, но всё равно идёт вперёд
-- Даже "откат" — новый процесс
-- Состояние -- Момент среза процесса. Фиксируется как сущее в момент `t`
-
-❗ Даже если система «возвращается» в предыдущее состояние — это не возврат во времени, а новый процесс, имитирующий прошлое.
-
-💬 Форма языка — не статична, а процессуальна. Как материя в движении, так и код в **prolet** — развивается во времени.
-
-## ✅ Канонический пример
-
-Код читается и выполняется слева направо, сверху вниз — как поток практики.
-
-Операции отражают движение от причины к следствию.
-
-Нельзя использовать то, чего ещё не было. Синтаксис запрещает ссылки на будущее.
-
-```prolet
-(// Фиксированный результат, мутабельность определяется в сигнатуре вызова,
-по необходимости можно усилить требования, но не ослабить по Бертрану Мейеру)
-((ПолучитьДанные) -> данные)
-((ГруппироватьПо данные ключ) -> группа)
-((СуммироватьПо данные группа) -> результат)
-```
-
-Нет «выражений, вычисляемых в параллель без указания порядка».
-Порядок — не подразумевается, а фиксируется.
-
-Разберём досконально.
-
-### 🧩 Семантическая структура присвоения
-
-Форма:
-
-```prolet
-((выражение) -> имя)
-```
-
-или
-
-```prolet
-(// Если возвращает @мут -- можно усилить требования, но не ослабить)
-((Выражение) -> @фикс имя)
-```
-
-#### Внешние скобки — единое выражение присвоения
-
-```prolet
-( ... )
-```
-
-✅ Всё — одно выражение, отражающее процесс становления.
-
-#### Внутреннее выражение — действие, порождающее сущее
-
-```prolet
-(ПолучитьДанные)
-```
-
-Это — вызов, процесс, действие во времени.
-
-Он ещё не сущее, но источник сущего.
-
-#### -> — стрелка времени
-
-Указывает направление:
-
-- от процесса к результату,
-- от возможного к сущему.
-
-✅ Допустима, потому что:
-
-- однозначна,
-- отражает направленность времени,
-- не перегружена смыслами.
-
-### фикс / мут — онтологический статус переменной
-
-- `@фикс Переменная` — сущее, неизменяемое после присвоения; Аналог "закреплённого факта"
-- `@мут Переменная` — сущее, допускающее последующие изменения; Аналог "рабочей величины"
-
-Это — _не тип_, а _статус существования во времени_.
-
-## имя — идентификатор сущего
-
-Пример: `данные`, `группа`, `результат`
-
-Имя — _не метка_ памяти, а обозначение _зафиксированного сущего_.
-
-## ✅ Полная семантика
-
-```prolet
-((ПолучитьДанные) -> @фикс данные)
-(// Результат процесса 'ПолучитьДанные' становится сущим,
-именуется 'данные', и далее считается завершённым, неизменяемым фактом)
-
-((СуммироватьПо данные группа) -> результат)
-(// Результат процесса 'СуммироватьПо' становится сущим,
-именуется 'результат', но может быть изменён в будущем)
-```
-
-## 📜 Онтологические правила присвоения в **prolet**
-
-- Присвоение — выражение в парных скобках
-- Форма: `((выражение) -> @фикс имя)` или `((выражение) -> имя)`
-- `@фикс` — создаёт неизменяемое сущее
-- `@мут` — создаёт (повторяет из сигнатуры вызова) изменяемое сущее
-- `->` — стрелка времени, отражает переход от действия к сущему
-- Нет форм `:=`, `=`, `<-`. Только `->` как отражение реального потока времени в одну сторону
-- Нельзя использовать имя до его присвоения
-- `@фикс` нельзя переопределять;
-- `@мут` — можно, если сигнатура вызова определяет мутабельность результата
-
-## 🔄 Пример: полный процесс
-
-```prolet
-(прц ОбработатьДанные () -> @фикс Результат.Ок
-    ((ПолучитьДанные) -> @фикс данные)
-    (если (ПроверитьПусто данные)
-        тогда (вернуть Результат.Ошибка "нет_данных"))
-
-    ((ГруппироватьПо данные ключ) -> @фикс группа)
-    ((СуммироватьПо группа) -> результат)
-
-    ((ДобавитьМетаданные результат) -> результат)
-
-    (вернуть Результат.Ок результат)
-)
-```
-
-- ✅ Каждое присвоение — этап фиксации сущего.
-- ✅ `@фикс` — для завершённых фактов.
-- ✅ `@мут` — для рабочих величин, допускающих развитие.
-
-## 💡 Философское обоснование
-
-Язык **prolet** следует диалектическому материализму:
-
-- Сущее не дано сразу — оно становится через процесс.
-- Присвоение — не копирование, а онтологическое рождение.
-- Стрелка `->` — не оператор, а символ времени, отражающий:
-  - «сначала было действие,
-  - потом — результат,
-  - потом — имя».
-
-💬 «Как пролетариат не становится классом сам по себе, а только в ходе развития классовых противоречий, через осознание себя общественной силой, так и значение не становится сущим без фиксации».
-
-## 🏁 Заключение
-
-Язык установил онтологически чистую форму присвоения:
-
-**prolet** — не язык программирования, а язык фиксации процесса во времени.
-
-- Он не абстрагируется от времени.
-- Он воспроизводит его в синтаксисе.
-- Стрела времени — не метафора. Она — структура языка.
-
-`((действие) -> @фикс имя)` — это не присваивание, это — акт фиксации сущего во времени.
-
-Нет места для `x = f()`. Есть только `((f) -> @фикс x )` — как протокол становления.
-
-- Время — объективная форма существования материи.
-- Никакого «вневременного» существования типов, функций, значений.
-- Каждое сущее — момент процесса.
-- Язык — не зеркало, а отражение, в котором форма подчинена содержанию.
-
-💬 «Код в prolet — не набор инструкций, а запись практики, зафиксированной в единстве материи и движения».

docs/prolet-014.md

@@ -1,218 +0,0 @@
-# Взгляд на виртуальную машину через диалектику бытия
-
-Ниже следуют рассуждения о сущности виртуальной машины для диалектического языка, которая должна диалектически отражать все теги на уровень исполнения. Такая виртуальная машина, которая снимает противоречие различных аппаратных архитектур. Какими свойствами должна обладать такая виртуальная машина чтобы диалектично отражать язык **prolet** на свои возможности?
-
-Виртуальная машина отражает стык бытия и сознания, границу между языком как описанием реальности и машиной реализующей это описание реальности, в диалектике абстрактного и конкретного.
-
-Какова должна быть виртуальная машина (**ВМ**), чтобы диалектически воплощать **prolet** в железе?
-
-Ответ — не технический, а философско-материалистический:
-
-**IL** для **ВМ** (и сама **ВМ**) в такой постановке вопроса неизбежен, но не как технический костыль, а как необходимый этап отрицания отрицания в развитии вычислительной формы.
-
-## Зачем IL? Диалектическое обоснование промежуточного языка для ВМ
-
-Противоречие: `язык` vs `аппаратура`
-
-- Язык **prolet** — абстрактный, человекоцентричный, диалектический.
-- Аппаратура — конкретная, разнообразная, ограниченная.
-
-Без посредника, отрицающего переход от абстрактного к конкретному — нет единства, нет перехода от идеи к действию.
-
-Решение: **IL** как отрицание языка и отрицание железа
-
-- **IL** не есть **prolet**, но порождён им.
-- **IL** не есть машинный код, но ведёт к нему.
-
-Он — синтез:
-
-- отрицает непосредственность языка,
-- отрицает разнородность железа,
-- и порождает _новое_ качество — _исполняемый процесс_.
-
-Это — отрицание отрицания:
-
-**prolet** (как идея) → IL (форма-посредник) → машинный код (реализация) → но на новом уровне — с сохранением смысла **prolet**.
-
-## Свойства IL: диалектический промежуточный язык
-
-**IL** должен быть не просто набором инструкций, а отражением онтологии **prolet** иными средствами, от философского созерцания и описания к практическому действию.
-
-## Принципы построения IL
-
-### Соответствие атомарным тегам
-
-Каждый атомарный тег имеет однозначное, минимальное отражение в **IL**
-
-### Неделимость
-
-**IL**-инструкции — атомарны в рамках **ВМ**, не могут быть прерваны
-
-### Объективность
-
-**IL** _не зависит_ от архитектуры, ОС, компилятора
-
-### Развиваемость
-
-**IL** может расширяться, но только через синтез атомарных смыслов, а не хаос интегрированного движения
-
-### Читаемость
-
-**IL** должен быть понятен человеку — как чертёж завода
-
-### Педагогичность
-
-По **IL** можно понять, как работает **prolet**
-
-### Отображение атомарных тегов в IL
-
-Каждый тег **prolet** → одна или несколько **IL**-инструкций,
-но без потери смысла.
-
-`( -> @фикс x)`
-
-```prolet
-(вм.Сохр x сп)
-(// Поместить значение в стек)
-
-(если (Сравнить c == e)
-тогда (...))
-(вм.ИдтиЕслиНе рег0)
-
-(// Порядок инструкций — порядок времени)
-(n -> @фикс v)
-(вм.Сохр рег0 v)
-
-(// Организация стекового кадра)
-(f a)
-(вм.Сохр а сп)
-(вм.Вызов f)
-(вм.Загр рег0)(// Извлечение результат)
-
-(// Передача управления)
-(вм.Авария m)
-(вм.ВызовВектор m) (// Маскируемое прерывание)
-```
-
-**IL** — не потеря смысла, а его трансляция в форму, пригодную для машинной практики.
-
-## Виртуальная машина: диалектический посредник
-
-**ВМ** — не имитация, не "виртуальность" в идеалистическом смысле, а материальная система, созданная человеком, чтобы преодолеть противоречие между разными формами бытия железа.
-
-Диалектические задачи **ВМ** -- снять  противоречие между:
-
-- аппаратными платформами x86, ARM, RISC-V,
-- различными ОС: Windows, Linux, мобильные ОС,
-- стековыми и регистровыми архитектурами.
-
-## Свойства виртуальной машины (с точки зрения диалектического материализма)
-
-### Единство и борьба форм
-
-Поддерживает множество архитектур, но через единую модель исполнения
-
-### Материальность
-
-ВМ — не абстракция, а процесс в памяти и на процессоре
-
-### Первичность IL, вторичность машинного кода
-
-**IL** — отражение сознания, машинный код — его материализация
-
-### Развивающийся интерфейс
-
-Новые инструкции **IL** добавляются не по воле, а по необходимости практики
-
-### Контроль над памятью
-
-Реализует принципы владения **prolet**: нет случайного доступа
-
-### Время как ресурс
-
-Поддерживает точный учёт времени выполнения — как в диалектике, развитие — через время
-
-### Ошибки как объективные сигналы
-
-Не маскирует сбои, а фиксирует их как нарушение законов бытия
-
-### Архитектура ВМ: стековая машина с контролем
-
-Выбор стековой модели — не потому что она "популярна", а потому что она диалектически отражает структуру **prolet**:
-
-- Стек вызовов — отражает иерархию процессов.
-- Стек значений — отражает последовательность вычислений.
-- Локальные переменные — привязаны к кадру, как в `(() -> переменная ...)`
-- Контроль потока — через метки и переходы, как в `(если ...)`
-
-```prolet
-(вм.Сохр [х] сп) (// На стэк отправить ссылку на х)
-(вм.Сохр рег0 сп) (// На стэк значение регистра)
-(вм.Сохр у сп)(// На стэк содержимое значения)
-(вм.Загр сп рег0)(// Со стека -- значение у)
-(вм.Дек сп)(// Вытолкнуть с стека)
-(вм.Загр сп рег1)(// Со стека -- значение х)
-(вм.Дек сп)
-(вм.Слож рег1 рег0)(// Сложить рег1 и рег0 с результатом в рег0)
-(вм.Возврат) (// Возврат из функции)
-```
-
-Это — не ассемблер, это — чертёж диалектического процесса, выраженный иными средствами.
-
-## ВМ как "государство" в мире вычислений
-
-ВМ — не анархия, а организованная система:
-
-- Контроль доступа к памяти — как контроль доступа к общим ресурсам в социализме: никто не может трогать чужую память без разрешения.
--- Учёт всех видов ресурсов — время, память, энергия.
--- Обеспечение справедливости — потоки исполняются по предсказуемым правилам.
--- Поддержка развития — через обновление **IL**, но с сохранением обратной совместимости.
-
-Это — не идеалистическая "свобода", где текущий процесс эксплуатирует ресурсы процесса-неудачника, это — плановая экономика вычислений.
-
-### Практический пример (если ...)
-
-```prolet
-(если (Сравнить x > 0)
-  тогда (Напечатать "положительно")
-  иначе (Напечатать "не положительно"))
-```
-
-компилируется в **IL**:
-
-```prolet
-(вм.Загр сп [x])(// Загрузить значение с вершины стэка, по ссылке в х)
-(вм.Дек сп)
-(вм.Сохр 0 сп)
-(вм.Срав сп 0) (// РЕзультат сравнения в рег0)
-(вм.ЕслиЛожь МеткаЕслиНет)
-(вм.Вызов МеткаЕслиДа)
-
-(вм.Метка МеткаЕслиНет)
-(вм.Вызов ПечатьЕслиНет)
-(вм.Возврат)
-
-(вм.Метка МеткаЕслиДа)
-(вм.Вызов ПечатьЕслиДа)
-(вм.Возврат)
-```
-
-→ **ВМ** интерпретирует или **JIT**-компилирует в машинный код.
-
-На каждом этапе — сохраняется смысл, но форма меняется в соответствии с условиями бытия.
-
-## Заключение: **IL** и **ВМ** как диалектический мост
-
-**prolet** требует в виде среды действия **IL** и **ВМ**, но не как технические утилиты, а как необходимые формы развития:
-
-- **IL** — отражение онтологии **prolet** в форме, пригодной для машины,
-- **ВМ** — материальный посредник, снимающий противоречие между языком и железом.
-
-Это — не компромисс, это — синтез, где:
-
-- Идея не теряется,
-- Реальность не игнорируется,
-- Развитие обеспечивается.
-
-**ВМ** — это не замена железа, это — его диалектическое преодоление, как социализм преодолевает капитализм,
-сохраняя его производительные силы.

docs/prolet-015.md

@@ -1,202 +0,0 @@
-# Диалектика статических обобщённых типов
-
-Руководствуясь принципами диалектического материализма необходимо признать, что не существует типов вообще. Если один из типов существует фактически в качестве типа процессора или ВМ -- именно он должен являться базовым по отношению ко всем обобщённым типам.
-
-Базовым типом **ВМ** будет знаковое целое. Беззнаковое целое в качестве _базового_ типа является идеалистическим отражением наличного бытия. Беззнаковое целое, литера и булево значение будем считать производными значениями от целого.
-
-Таким образом провозглашён онтологический принцип:
-
-```text
-Целое как первооснова информационной материи,
-как атомарная форма количества,
-как единица измерения бытия в мире вычислений.
-```
-
-Это — не компромисс, не инженерная хитрость в духе `ad hoc`, а революционный шаг в построении онтологии **prolet**, где сложное выводится из простого, а многообразие — из единого и реально существующего.
-
-Разберём это решение в свете диалектического материализма.
-
-## Зачем именно знаковое целое? Онтологическое обоснование
-
-- Принцип: `количество — первая форма бытия`
-- В диалектике качество возникает из количества.
-- Прежде чем различать "истина/ложь", "литера", "адрес" — мир различает "сколько?".
-
-Целое — минимальная форма количества, способная отражать объективные состояния:
-
-- температура,
-- счёт,
-- индекс,
-- время,
-- ошибка (код),
-- адрес памяти (в относительной форме).
-
-Оно — не абстракция, а отражение закона измерения в природе.
-
-## Почему именно знаковое?
-
-Потому что реальный мир — не только "больше нуля".
-
-- Температура может быть −273°C,
-- Баланс — отрицательным,
-- Ошибка — кодом `−1`.
-
-Беззнаковое — идеализм, оно отрицает возможность отрицания, а диалектика — основана на отрицании.
-
-Знаковое целое — единство положительного и отрицательного, оно носит в себе внутреннее противоречие, и потому — диалектически полно.
-
-## Производные типы: снятие противоречия через практику
-
-В **prolet** отказ от "независимых" типов носит методический характер.
-
-Вместо куста чудесным образом возникающих типов — все типы порождаются от целого, но не механически, а через ограничение и интерпретацию.
-
-### Булево
-
-целое (перечисление [0, не 0])
-
-### Литера
-
-целое (интерпретация Юникода, диапазон [0x00, 0x10FFFF])
-
-### Беззнаковое
-
-целое (диапазон [0, +∞)) — как ограничение, а не отдельный тип
-
-Это — не упрощение, это — развитие через снятие противоречия:
-
-- Простое (целое) — утверждается,
-- Сложное (булево, литера) — отрицает его,
-- Но затем — отрицается само,
-- И возвращается как интерпретация целого в заданном контексте.
-
-## Реализация в prolet: типы как категории бытия
-
-### Базовый тип: (тип Целое : целое)
-
-```prolet
-(тип Яблоки : Целое)
-```
-
-Целое не определяется через что-то более простое. Является _аксиомой_ онтологии.
-
-Все операции (`+`, `-`, `*`, `>>`, `&`) — определены на нём напрямую.
-
-### Булево как ограниченное целое
-
-```prolet
-(тип Булево : Целое
-    @перечисл [Ложь, Истина]
-    @интерпретация (0 → Ложь, не 0 → Истина)
-```
-
-Использование:
-
-```prolet
-((Бул 5) -> @фикс еслиВкл)( // значение  Истина)
-(если еслиВкл
-    тогда (Напечатать "ВКЛ"))
-```
-
-При этом:
-
-- В памяти — просто не 0,
-- Но в контексте условия — интерпретируется как Истина.
-
-## Литера как целое с семантикой кода UTF-8
-
-```prolet
-
-(тип Литера : Целое
-    @диапазон [0, 0x10FFFF]
-    @интерпретация Юникод
-    @литералы ('a' → 97, 'я' → 1071))
-
-((Лит 'А') -> @фикс литА)(// литра с кодом 1040)
-```
-
-Литера — не "отдельный тип",
-а целое, наделённое смыслом через стандарт.
-
-### Беззнаковое — как контракт, а не тип
-
-```prolet
-
-(тип Абс (// Абсолютное значение целого)
-    @диапазон (0, ЦелМакс)(// проверяется на этапе компиляции или рантайме)
-)
-```
-
-Или — через валидатор:
-
-```prolet
-(фн Беззнаковый (имя Битность) -> @фикс Результат.Бул
-    (ПроверитьБезЗнак имя))
-
-(Беззнаковый U32)(// Проверяет беззнаковое число в рантайме
-```
-
-Беззнаковое — не база, а производная категория, возникающая в практике индексации, адресации, счётчиков.
-
-## Преимущества подхода
-
-- Минимализм онтологии
-- Один базовый тип — меньше путаницы, меньше ошибок
-- Единство представления
-- Все данные — целые, значит, можно сравнивать, передавать, сериализовать одинаково
-- Безопасность через контекст
-- Ошибка "сложить символ и булево" — не на уровне типов, а на уровне смысла
-- Развиваемость
-
-Новые типы — не добавляются, а выводятся из целого через практику
-
-## Экономия мыслетоплива
-
-Программист не думает: "это `int` или `uint`?", а думает: "это счётчик, значит — неотрицательное"
-
-## Психологическая и педагогическая выгода
-
-- Новичок учит один тип — целое, а потом — как его интерпретировать.
-- Ошибки вроде `i = -1`; `for (i < n; ...)` — обнаруживаются не по типу, а по нарушению контракта `(@диапазон [0, ∞))`.
-- Система подсказывает: "Переменная `i` помечена как беззнаковая, но присваивается `-1`. Это противоречит контракту."
-
-Это — не бюрократия, это — диалектическое воспитание сознания.
-
-## Диалектическая природа целого: от количества к качеству
-
-Целое — не конец пути, а начало познания.
-
-### Количество
-
-`x = 42`
-
-### Простое накопление
-
-Ограничение: `x : [0, 100]`
-
-### Единство и борьба (ограничение свободы ради смысла)
-
-- Интерпретация `x` как возраст, код ошибки, символ
-- Переход количества в качество
-- Синтез: `@возможно Пользователь`
-
-`Целое` становится частью сложного процесса
-
-`Целое` — не "вещь", оно — форма движения материи в пространстве значений.
-
-## Заключение: целое как первооснова prolet
-
-Приведённое решение — не просто техническое, оно — философское, революционное, диалектически зрелое.
-
-`Целое` — это не тип,
-
-- это — категория бытия,
-- это — мера количества,
-- это — зародыш качества,
-- это — материальная основа информационного мира **prolet**.
-
-Все прочие типы — _не равноправны_,
-
-- они — его производные,
-- его развитие,
-- его самопознание.

go.mod

@@ -1,33 +1,34 @@
 module gitp78su.ipnodns.ru/svi/prolet
 
-go 1.25.0
+go 1.25.5
 
-require gitp78su.ipnodns.ru/svi/kern/v2 v2.3.0
+require gitp78su.ipnodns.ru/svi/kern/v3 v3.1.1
 
 require (
 	github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b // indirect
 	github.com/andybalholm/brotli v1.2.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
 	github.com/dgraph-io/badger/v4 v4.8.0 // indirect
 	github.com/dgraph-io/ristretto/v2 v2.3.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/gofiber/fiber/v2 v2.52.9 // indirect
-	github.com/google/flatbuffers v25.2.10+incompatible // indirect
+	github.com/gofiber/fiber/v2 v2.52.10 // indirect
+	github.com/google/flatbuffers v25.9.23+incompatible // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/compress v1.18.2 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	github.com/valyala/fasthttp v1.65.0 // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	github.com/valyala/fasthttp v1.68.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
 	go.opentelemetry.io/otel v1.38.0 // indirect
 	go.opentelemetry.io/otel/metric v1.38.0 // indirect
 	go.opentelemetry.io/otel/trace v1.38.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/sys v0.35.0 // indirect
-	google.golang.org/protobuf v1.36.8 // indirect
+	golang.org/x/net v0.47.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 )

go.sum

@@ -7,6 +7,10 @@ github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwTo
 github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
+github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgraph-io/badger/v4 v4.8.0 h1:JYph1ChBijCw8SLeybvPINizbDKWZ5n/GYbz2yhN/bs=
@@ -22,41 +26,38 @@ github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/gofiber/fiber/v2 v2.52.9 h1:YjKl5DOiyP3j0mO61u3NTmK7or8GzzWzCFzkboyP5cw=
-github.com/gofiber/fiber/v2 v2.52.9/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw=
-github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q=
-github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/gofiber/fiber/v2 v2.52.10 h1:jRHROi2BuNti6NYXmZ6gbNSfT3zj/8c0xy94GOU5elY=
+github.com/gofiber/fiber/v2 v2.52.10/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw=
+github.com/google/flatbuffers v25.9.23+incompatible h1:rGZKv+wOb6QPzIdkM2KxhBZCDrA0DeN6DNmRDrqIsQU=
+github.com/google/flatbuffers v25.9.23+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.65.0 h1:j/u3uzFEGFfRxw79iYzJN+TteTJwbYkru9uDp3d0Yf8=
-github.com/valyala/fasthttp v1.65.0/go.mod h1:P/93/YkKPMsKSnATEeELUCkG8a7Y+k99uxNHVbKINr4=
+github.com/valyala/fasthttp v1.68.0 h1:v12Nx16iepr8r9ySOwqI+5RBJ/DqTxhOy1HrHoDFnok=
+github.com/valyala/fasthttp v1.68.0/go.mod h1:5EXiRfYQAoiO/khu4oU9VISC/eVY6JqmSpPJoHCKsz4=
 github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
 github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-gitp78su.ipnodns.ru/svi/kern/v2 v2.3.0 h1:HF0soPN1oK4Nl4wPGJ0qrs/6ftht0pNXJa8E7fZXAhY=
-gitp78su.ipnodns.ru/svi/kern/v2 v2.3.0/go.mod h1:eWJXB887/t+fqcQdnh8Emq/PMueIHQQRgcHSdHLy3uQ=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+gitp78su.ipnodns.ru/svi/kern/v3 v3.1.1 h1:1ymYrax2WuEB13JSj0aA9pUQJU/VGRI7CpqTyFOaTB4=
+gitp78su.ipnodns.ru/svi/kern/v3 v3.1.1/go.mod h1:hq6dlAu+6/x2HJAA1yXKRRILaBXFzywBdgXIL5uwEwg=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
 go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
 go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
 go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
@@ -70,8 +71,8 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -79,8 +80,8 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -89,8 +90,8 @@ golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
-google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las=

lang/alias/alias.go

@@ -1,5 +1,5 @@
 // package alias -- алиасы типов для работы
 package alias
 
-// Tempor -- время жизни переменной
-type Tempor int
+// Lifetime -- признак времени жизни сущности
+type Lifetime int

lang/cons/cons.go

@@ -3,11 +3,11 @@ package cons
 
 import "gitp78su.ipnodns.ru/svi/prolet/lang/alias"
 
-const ( // Tempor -- время жизни, для анализа потока исполнения
-	// TemporConst -- вечное значение
-	TemporConst = alias.Tempor(0)
-	// TemporFix -- фиксированное значение от создания до передачи/трансформации
-	TemporFix = alias.Tempor(1)
-	// TemportMut -- изменяемое значение от создания до передачи/трансформации
-	TemporMut = alias.Tempor(2)
+const ( // Life -- время жизни, для анализа потока исполнения
+	// LifeConst -- вечное значение
+	LifeConst = alias.Lifetime(0)
+	// LifeFix -- фиксированное значение от создания (по умолчанию)
+	LifeFix = alias.Lifetime(1)
+	// LifeMut -- изменяемое значение от создания до передачи/трансформации
+	LifeMut = alias.Lifetime(2)
 )

lang/types/ival.go

@@ -1,11 +0,0 @@
-package types
-
-import "gitp78su.ipnodns.ru/svi/prolet/lang/alias"
-
-// IVal -- интерфейс значения
-type IVal interface {
-	// Val -- возвращает хранимое значение
-	Val() int
-	// Tempor -- возвращает время жизни значения
-	Tempor() alias.Tempor
-}

lang/types/ival_const.go

@@ -0,0 +1,11 @@
+package types
+
+import "gitp78su.ipnodns.ru/svi/prolet/lang/alias"
+
+// IValConst -- интерфейс константного значения
+type IValConst interface {
+	// Val -- возвращает хранимое значение
+	Val() int
+	// Lifetime -- возвращает время жизни значения
+	Lifetime() alias.Lifetime
+}

lang/types/ival_mut.go

@@ -1 +1,8 @@
 package types
+
+// IValMut -- интерфейс изменяемого значения
+type IValMut interface {
+	IValConst
+	// Set -- устанавливает хранимое значение
+	Set(val int)
+}

lang/val_const/val_const.go

@@ -17,7 +17,7 @@ func CompileValConst(val int) *ValConst {
 	sf := &ValConst{
 		val: val,
 	}
-	_ = types.IVal(sf)
+	_ = types.IValConst(sf)
 	return sf
 }
 
@@ -26,7 +26,7 @@ func (sf *ValConst) Val() int {
 	return sf.val
 }
 
-// Tempor -- возвращает время жизни значения
-func (sf *ValConst) Tempor() alias.Tempor {
-	return cons.TemporConst
+// Lifetime -- возвращает время жизни значения
+func (sf *ValConst) Lifetime() alias.Lifetime {
+	return cons.LifeConst
 }

lang/val_fix/val_fix.go

@@ -17,7 +17,7 @@ func NewValFix(val int) *ValFix {
 	sf := &ValFix{
 		val: val,
 	}
-	_ = types.IVal(sf)
+	_ = types.IValConst(sf)
 	return sf
 }
 
@@ -26,7 +26,7 @@ func (sf *ValFix) Val() int {
 	return sf.val
 }
 
-// Tempor -- возвращает время жизни значения
-func (sf *ValFix) Tempor() alias.Tempor {
-	return cons.TemporFix
+// Lifetime -- возвращает время жизни значения
+func (sf *ValFix) Lifetime() alias.Lifetime {
+	return cons.LifeFix
 }

lang/val_mut/val_mut.go

@@ -1,7 +1,10 @@
 // package val_mut -- изменяемое значение
 package val_mut
 
-import "gitp78su.ipnodns.ru/svi/prolet/lang/types"
+import (
+	"gitp78su.ipnodns.ru/svi/prolet/lang/alias"
+	"gitp78su.ipnodns.ru/svi/prolet/lang/types"
+)
 
 // ValMut -- изменяемое значение, определяется в рантайме и может быть изменено
 type ValMut struct {
@@ -16,3 +19,13 @@ func NewValMut(val int) *ValMut {
 	_ = types.IValMut(sf)
 	return sf
 }
+
+// Set -- устанавливает хранимое значение
+func (sf *ValMut) Set(val int) {
+	sf.val = val
+}
+
+// IsLive -- признак жизни сущности
+func (sf *ValMut) IsLive() alias.Lifetime {
+	return alias.Lifetime(true)
+}

lev3/app/app.go

@@ -0,0 +1,23 @@
+// package app -- главный класс приложения
+package app
+
+import (
+	"gitp78su.ipnodns.ru/svi/kern/v3"
+	"gitp78su.ipnodns.ru/svi/kern/v3/kc/log_buf"
+	. "gitp78su.ipnodns.ru/svi/kern/v3/krn/ktypes"
+)
+
+// App -- главный класс приложения
+type App struct {
+	log ILogBuf
+}
+
+// NewApp -- возвращает новый главный класс приложения
+func NewApp() *App {
+	log := kern.NewLogBuf(log_buf.OptIsTerm(true), log_buf.OptPrefix("App"))
+	log.Debug("new()")
+	sf := &App{
+		log: log,
+	}
+	return sf
+}

vendor/github.com/clipperhouse/stringish/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.test

vendor/github.com/rivo/uniseg/LICENSE.txt → vendor/github.com/clipperhouse/stringish/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Oliver Kuederle
+Copyright (c) 2025 Matt Sherman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

vendor/github.com/clipperhouse/stringish/README.md

@@ -0,0 +1,64 @@
+# stringish
+
+A small Go module that provides a generic type constraint for “string-like”
+data, and a utf8 package that works with both strings and byte slices
+without conversions.
+
+```go
+type Interface interface {
+	~[]byte | ~string
+}
+```
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/clipperhouse/stringish/utf8.svg)](https://pkg.go.dev/github.com/clipperhouse/stringish/utf8)
+[![Test Status](https://github.com/clipperhouse/stringish/actions/workflows/gotest.yml/badge.svg)](https://github.com/clipperhouse/stringish/actions/workflows/gotest.yml)
+
+## Install
+
+```
+go get github.com/clipperhouse/stringish
+```
+
+## Examples
+
+```go
+import (
+    "github.com/clipperhouse/stringish"
+    "github.com/clipperhouse/stringish/utf8"
+)
+
+s := "Hello, 世界"
+r, size := utf8.DecodeRune(s)   // not DecodeRuneInString 🎉
+
+b := []byte("Hello, 世界")
+r, size = utf8.DecodeRune(b)    // same API!
+
+func MyFoo[T stringish.Interface](s T) T {
+    // pass a string or a []byte
+    // iterate, slice, transform, whatever
+}
+```
+
+## Motivation
+
+Sometimes we want APIs to accept `string` or `[]byte` without having to convert
+between those types. That conversion usually allocates!
+
+By implementing with `stringish.Interface`, we can have a single API, and
+single implementation for both types: one `Foo` instead of `Foo` and
+`FooString`.
+
+We have converted the
+[`unicode/utf8` package](https://github.com/clipperhouse/stringish/blob/main/utf8/utf8.go)
+as an example -- note the absence of`*InString` funcs. We might look at `x/text`
+next.
+
+## Used by
+
+- clipperhouse/uax29: [stringish trie](https://github.com/clipperhouse/uax29/blob/master/graphemes/trie.go#L27), [stringish iterator](https://github.com/clipperhouse/uax29/blob/master/internal/iterators/iterator.go#L9), [stringish SplitFunc](https://github.com/clipperhouse/uax29/blob/master/graphemes/splitfunc.go#L21)
+
+- [clipperhouse/displaywidth](https://github.com/clipperhouse/displaywidth)
+
+## Prior discussion
+
+- [Consideration of similar by the Go team](https://github.com/golang/go/issues/48643)

vendor/github.com/clipperhouse/stringish/interface.go

@@ -0,0 +1,5 @@
+package stringish
+
+type Interface interface {
+	~[]byte | ~string
+}

vendor/github.com/clipperhouse/uax29/v2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matt Sherman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/clipperhouse/uax29/v2/graphemes/README.md

@@ -0,0 +1,94 @@
+An implementation of grapheme cluster boundaries from [Unicode text segmentation](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) (UAX 29), for Unicode version 15.0.0.
+
+[![Documentation](https://pkg.go.dev/badge/github.com/clipperhouse/uax29/v2/graphemes.svg)](https://pkg.go.dev/github.com/clipperhouse/uax29/v2/graphemes)
+![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg)
+![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg)
+
+## Quick start
+
+```
+go get "github.com/clipperhouse/uax29/v2/graphemes"
+```
+
+```go
+import "github.com/clipperhouse/uax29/v2/graphemes"
+
+text := "Hello, 世界. Nice dog! 👍🐶"
+
+tokens := graphemes.FromString(text)
+
+for tokens.Next() {                     // Next() returns true until end of data
+	fmt.Println(tokens.Value())         // Do something with the current grapheme
+}
+```
+
+_A grapheme is a “single visible character”, which might be a simple as a single letter, or a complex emoji that consists of several Unicode code points._
+
+## Conformance
+
+We use the Unicode [test suite](https://unicode.org/reports/tr41/tr41-26.html#Tests29).
+
+![Tests](https://github.com/clipperhouse/uax29/actions/workflows/gotest.yml/badge.svg)
+![Fuzz](https://github.com/clipperhouse/uax29/actions/workflows/gofuzz.yml/badge.svg)
+
+## APIs
+
+### If you have a `string`
+
+```go
+text := "Hello, 世界. Nice dog! 👍🐶"
+
+tokens := graphemes.FromString(text)
+
+for tokens.Next() {                     // Next() returns true until end of data
+	fmt.Println(tokens.Value())         // Do something with the current grapheme
+}
+```
+
+### If you have an `io.Reader`
+
+`FromReader` embeds a [`bufio.Scanner`](https://pkg.go.dev/bufio#Scanner), so just use those methods.
+
+```go
+r := getYourReader()                        // from a file or network maybe
+tokens := graphemes.FromReader(r)
+
+for tokens.Scan() {                         // Scan() returns true until error or EOF
+	fmt.Println(tokens.Text())              // Do something with the current grapheme
+}
+
+if tokens.Err() != nil {                    // Check the error
+	log.Fatal(tokens.Err())
+}
+```
+
+### If you have a `[]byte`
+
+```go
+b := []byte("Hello, 世界. Nice dog! 👍🐶")
+
+tokens := graphemes.FromBytes(b)
+
+for tokens.Next() {                     // Next() returns true until end of data
+	fmt.Println(tokens.Value())         // Do something with the current grapheme
+}
+```
+
+### Benchmarks
+
+On a Mac M2 laptop, we see around 200MB/s, or around 100 million graphemes per second, and no allocations.
+
+```
+goos: darwin
+goarch: arm64
+pkg: github.com/clipperhouse/uax29/graphemes/comparative
+cpu: Apple M2
+BenchmarkGraphemes/clipperhouse/uax29-8    	    173805 ns/op	 201.16 MB/s      0 B/op	   0 allocs/op
+BenchmarkGraphemes/rivo/uniseg-8           	   2045128 ns/op	  17.10 MB/s      0 B/op	   0 allocs/op
+```
+
+### Invalid inputs
+
+Invalid UTF-8 input is considered undefined behavior. We test to ensure that bad inputs will not cause pathological outcomes, such as a panic or infinite loop. Callers should expect “garbage-in, garbage-out”.
+
+Your pipeline should probably include a call to [`utf8.Valid()`](https://pkg.go.dev/unicode/utf8#Valid).

vendor/github.com/clipperhouse/uax29/v2/graphemes/iterator.go

@@ -0,0 +1,31 @@
+package graphemes
+
+import (
+	"github.com/clipperhouse/stringish"
+	"github.com/clipperhouse/uax29/v2/internal/iterators"
+)
+
+type Iterator[T stringish.Interface] struct {
+	*iterators.Iterator[T]
+}
+
+var (
+	splitFuncString = splitFunc[string]
+	splitFuncBytes  = splitFunc[[]byte]
+)
+
+// FromString returns an iterator for the grapheme clusters in the input string.
+// Iterate while Next() is true, and access the grapheme via Value().
+func FromString(s string) Iterator[string] {
+	return Iterator[string]{
+		iterators.New(splitFuncString, s),
+	}
+}
+
+// FromBytes returns an iterator for the grapheme clusters in the input bytes.
+// Iterate while Next() is true, and access the grapheme via Value().
+func FromBytes(b []byte) Iterator[[]byte] {
+	return Iterator[[]byte]{
+		iterators.New(splitFuncBytes, b),
+	}
+}

vendor/github.com/clipperhouse/uax29/v2/graphemes/reader.go

@@ -0,0 +1,25 @@
+// Package graphemes implements Unicode grapheme cluster boundaries: https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries
+package graphemes
+
+import (
+	"bufio"
+	"io"
+)
+
+type Scanner struct {
+	*bufio.Scanner
+}
+
+// FromReader returns a Scanner, to split graphemes per
+// https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries.
+//
+// It embeds a [bufio.Scanner], so you can use its methods.
+//
+// Iterate through graphemes by calling Scan() until false, then check Err().
+func FromReader(r io.Reader) *Scanner {
+	sc := bufio.NewScanner(r)
+	sc.Split(SplitFunc)
+	return &Scanner{
+		Scanner: sc,
+	}
+}

vendor/github.com/clipperhouse/uax29/v2/graphemes/splitfunc.go

@@ -0,0 +1,174 @@
+package graphemes
+
+import (
+	"bufio"
+
+	"github.com/clipperhouse/stringish"
+)
+
+// is determines if lookup intersects propert(ies)
+func (lookup property) is(properties property) bool {
+	return (lookup & properties) != 0
+}
+
+const _Ignore = _Extend
+
+// SplitFunc is a bufio.SplitFunc implementation of Unicode grapheme cluster segmentation, for use with bufio.Scanner.
+//
+// See https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries.
+var SplitFunc bufio.SplitFunc = splitFunc[[]byte]
+
+func splitFunc[T stringish.Interface](data T, atEOF bool) (advance int, token T, err error) {
+	var empty T
+	if len(data) == 0 {
+		return 0, empty, nil
+	}
+
+	// These vars are stateful across loop iterations
+	var pos int
+	var lastExIgnore property = 0     // "last excluding ignored categories"
+	var lastLastExIgnore property = 0 // "last one before that"
+	var regionalIndicatorCount int
+
+	// Rules are usually of the form Cat1 × Cat2; "current" refers to the first property
+	// to the right of the ×, from which we look back or forward
+
+	current, w := lookup(data[pos:])
+	if w == 0 {
+		if !atEOF {
+			// Rune extends past current data, request more
+			return 0, empty, nil
+		}
+		pos = len(data)
+		return pos, data[:pos], nil
+	}
+
+	// https://unicode.org/reports/tr29/#GB1
+	// Start of text always advances
+	pos += w
+
+	for {
+		eot := pos == len(data) // "end of text"
+
+		if eot {
+			if !atEOF {
+				// Token extends past current data, request more
+				return 0, empty, nil
+			}
+
+			// https://unicode.org/reports/tr29/#GB2
+			break
+		}
+
+		/*
+			We've switched the evaluation order of GB1↓ and GB2↑. It's ok:
+			because we've checked for len(data) at the top of this function,
+			sot and eot are mutually exclusive, order doesn't matter.
+		*/
+
+		// Rules are usually of the form Cat1 × Cat2; "current" refers to the first property
+		// to the right of the ×, from which we look back or forward
+
+		// Remember previous properties to avoid lookups/lookbacks
+		last := current
+		if !last.is(_Ignore) {
+			lastLastExIgnore = lastExIgnore
+			lastExIgnore = last
+		}
+
+		current, w = lookup(data[pos:])
+		if w == 0 {
+			if atEOF {
+				// Just return the bytes, we can't do anything with them
+				pos = len(data)
+				break
+			}
+			// Rune extends past current data, request more
+			return 0, empty, nil
+		}
+
+		// Optimization: no rule can possibly apply
+		if current|last == 0 { // i.e. both are zero
+			break
+		}
+
+		// https://unicode.org/reports/tr29/#GB3
+		if current.is(_LF) && last.is(_CR) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB4
+		// https://unicode.org/reports/tr29/#GB5
+		if (current | last).is(_Control | _CR | _LF) {
+			break
+		}
+
+		// https://unicode.org/reports/tr29/#GB6
+		if current.is(_L|_V|_LV|_LVT) && last.is(_L) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB7
+		if current.is(_V|_T) && last.is(_LV|_V) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB8
+		if current.is(_T) && last.is(_LVT|_T) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB9
+		if current.is(_Extend | _ZWJ) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB9a
+		if current.is(_SpacingMark) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB9b
+		if last.is(_Prepend) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB9c
+		// TODO(clipperhouse):
+		// It appears to be added in Unicode 15.1.0:
+		// https://unicode.org/versions/Unicode15.1.0/#Migration
+		// This package currently supports Unicode 15.0.0, so
+		// out of scope for now
+
+		// https://unicode.org/reports/tr29/#GB11
+		if current.is(_ExtendedPictographic) && last.is(_ZWJ) && lastLastExIgnore.is(_ExtendedPictographic) {
+			pos += w
+			continue
+		}
+
+		// https://unicode.org/reports/tr29/#GB12
+		// https://unicode.org/reports/tr29/#GB13
+		if (current & last).is(_RegionalIndicator) {
+			regionalIndicatorCount++
+
+			odd := regionalIndicatorCount%2 == 1
+			if odd {
+				pos += w
+				continue
+			}
+		}
+
+		// If we fall through all the above rules, it's a grapheme cluster break
+		break
+	}
+
+	// Return token
+	return pos, data[:pos], nil
+}

vendor/github.com/clipperhouse/uax29/v2/graphemes/trie.go

@@ -0,0 +1,1409 @@
+package graphemes
+
+import "github.com/clipperhouse/stringish"
+
+// generated by github.com/clipperhouse/uax29/v2
+// from https://www.unicode.org/Public/15.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
+
+type property uint16
+
+const (
+	_CR property = 1 << iota
+	_Control
+	_Extend
+	_ExtendedPictographic
+	_L
+	_LF
+	_LV
+	_LVT
+	_Prepend
+	_RegionalIndicator
+	_SpacingMark
+	_T
+	_V
+	_ZWJ
+)
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func lookup[T stringish.Interface](s T) (v property, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return graphemesValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := graphemesIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := graphemesIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = graphemesIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := graphemesIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = graphemesIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = graphemesIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// graphemesTrie. Total size: 29120 bytes (28.44 KiB). Checksum: 80ad0c5ab9375f7.
+// type graphemesTrie struct { }
+
+// func newGraphemesTrie(i int) *graphemesTrie {
+// 	return &graphemesTrie{}
+// }
+
+// lookupValue determines the type of block n and looks up the value for b.
+func lookupValue(n uint32, b byte) property {
+	switch {
+	default:
+		return property(graphemesValues[n<<6+uint32(b)])
+	}
+}
+
+// graphemesValues: 215 blocks, 13760 entries, 27520 bytes
+// The third block is the zero block.
+var graphemesValues = [13760]property{
+	// Block 0x0, offset 0x0
+	0x00: 0x0002, 0x01: 0x0002, 0x02: 0x0002, 0x03: 0x0002, 0x04: 0x0002, 0x05: 0x0002,
+	0x06: 0x0002, 0x07: 0x0002, 0x08: 0x0002, 0x09: 0x0002, 0x0a: 0x0020, 0x0b: 0x0002,
+	0x0c: 0x0002, 0x0d: 0x0001, 0x0e: 0x0002, 0x0f: 0x0002, 0x10: 0x0002, 0x11: 0x0002,
+	0x12: 0x0002, 0x13: 0x0002, 0x14: 0x0002, 0x15: 0x0002, 0x16: 0x0002, 0x17: 0x0002,
+	0x18: 0x0002, 0x19: 0x0002, 0x1a: 0x0002, 0x1b: 0x0002, 0x1c: 0x0002, 0x1d: 0x0002,
+	0x1e: 0x0002, 0x1f: 0x0002,
+	// Block 0x1, offset 0x40
+	0x7f: 0x0002,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x0002, 0xc1: 0x0002, 0xc2: 0x0002, 0xc3: 0x0002, 0xc4: 0x0002, 0xc5: 0x0002,
+	0xc6: 0x0002, 0xc7: 0x0002, 0xc8: 0x0002, 0xc9: 0x0002, 0xca: 0x0002, 0xcb: 0x0002,
+	0xcc: 0x0002, 0xcd: 0x0002, 0xce: 0x0002, 0xcf: 0x0002, 0xd0: 0x0002, 0xd1: 0x0002,
+	0xd2: 0x0002, 0xd3: 0x0002, 0xd4: 0x0002, 0xd5: 0x0002, 0xd6: 0x0002, 0xd7: 0x0002,
+	0xd8: 0x0002, 0xd9: 0x0002, 0xda: 0x0002, 0xdb: 0x0002, 0xdc: 0x0002, 0xdd: 0x0002,
+	0xde: 0x0002, 0xdf: 0x0002,
+	0xe9: 0x0008,
+	0xed: 0x0002, 0xee: 0x0008,
+	// Block 0x4, offset 0x100
+	0x100: 0x0004, 0x101: 0x0004, 0x102: 0x0004, 0x103: 0x0004, 0x104: 0x0004, 0x105: 0x0004,
+	0x106: 0x0004, 0x107: 0x0004, 0x108: 0x0004, 0x109: 0x0004, 0x10a: 0x0004, 0x10b: 0x0004,
+	0x10c: 0x0004, 0x10d: 0x0004, 0x10e: 0x0004, 0x10f: 0x0004, 0x110: 0x0004, 0x111: 0x0004,
+	0x112: 0x0004, 0x113: 0x0004, 0x114: 0x0004, 0x115: 0x0004, 0x116: 0x0004, 0x117: 0x0004,
+	0x118: 0x0004, 0x119: 0x0004, 0x11a: 0x0004, 0x11b: 0x0004, 0x11c: 0x0004, 0x11d: 0x0004,
+	0x11e: 0x0004, 0x11f: 0x0004, 0x120: 0x0004, 0x121: 0x0004, 0x122: 0x0004, 0x123: 0x0004,
+	0x124: 0x0004, 0x125: 0x0004, 0x126: 0x0004, 0x127: 0x0004, 0x128: 0x0004, 0x129: 0x0004,
+	0x12a: 0x0004, 0x12b: 0x0004, 0x12c: 0x0004, 0x12d: 0x0004, 0x12e: 0x0004, 0x12f: 0x0004,
+	0x130: 0x0004, 0x131: 0x0004, 0x132: 0x0004, 0x133: 0x0004, 0x134: 0x0004, 0x135: 0x0004,
+	0x136: 0x0004, 0x137: 0x0004, 0x138: 0x0004, 0x139: 0x0004, 0x13a: 0x0004, 0x13b: 0x0004,
+	0x13c: 0x0004, 0x13d: 0x0004, 0x13e: 0x0004, 0x13f: 0x0004,
+	// Block 0x5, offset 0x140
+	0x140: 0x0004, 0x141: 0x0004, 0x142: 0x0004, 0x143: 0x0004, 0x144: 0x0004, 0x145: 0x0004,
+	0x146: 0x0004, 0x147: 0x0004, 0x148: 0x0004, 0x149: 0x0004, 0x14a: 0x0004, 0x14b: 0x0004,
+	0x14c: 0x0004, 0x14d: 0x0004, 0x14e: 0x0004, 0x14f: 0x0004, 0x150: 0x0004, 0x151: 0x0004,
+	0x152: 0x0004, 0x153: 0x0004, 0x154: 0x0004, 0x155: 0x0004, 0x156: 0x0004, 0x157: 0x0004,
+	0x158: 0x0004, 0x159: 0x0004, 0x15a: 0x0004, 0x15b: 0x0004, 0x15c: 0x0004, 0x15d: 0x0004,
+	0x15e: 0x0004, 0x15f: 0x0004, 0x160: 0x0004, 0x161: 0x0004, 0x162: 0x0004, 0x163: 0x0004,
+	0x164: 0x0004, 0x165: 0x0004, 0x166: 0x0004, 0x167: 0x0004, 0x168: 0x0004, 0x169: 0x0004,
+	0x16a: 0x0004, 0x16b: 0x0004, 0x16c: 0x0004, 0x16d: 0x0004, 0x16e: 0x0004, 0x16f: 0x0004,
+	// Block 0x6, offset 0x180
+	0x183: 0x0004, 0x184: 0x0004, 0x185: 0x0004,
+	0x186: 0x0004, 0x187: 0x0004, 0x188: 0x0004, 0x189: 0x0004,
+	// Block 0x7, offset 0x1c0
+	0x1d1: 0x0004,
+	0x1d2: 0x0004, 0x1d3: 0x0004, 0x1d4: 0x0004, 0x1d5: 0x0004, 0x1d6: 0x0004, 0x1d7: 0x0004,
+	0x1d8: 0x0004, 0x1d9: 0x0004, 0x1da: 0x0004, 0x1db: 0x0004, 0x1dc: 0x0004, 0x1dd: 0x0004,
+	0x1de: 0x0004, 0x1df: 0x0004, 0x1e0: 0x0004, 0x1e1: 0x0004, 0x1e2: 0x0004, 0x1e3: 0x0004,
+	0x1e4: 0x0004, 0x1e5: 0x0004, 0x1e6: 0x0004, 0x1e7: 0x0004, 0x1e8: 0x0004, 0x1e9: 0x0004,
+	0x1ea: 0x0004, 0x1eb: 0x0004, 0x1ec: 0x0004, 0x1ed: 0x0004, 0x1ee: 0x0004, 0x1ef: 0x0004,
+	0x1f0: 0x0004, 0x1f1: 0x0004, 0x1f2: 0x0004, 0x1f3: 0x0004, 0x1f4: 0x0004, 0x1f5: 0x0004,
+	0x1f6: 0x0004, 0x1f7: 0x0004, 0x1f8: 0x0004, 0x1f9: 0x0004, 0x1fa: 0x0004, 0x1fb: 0x0004,
+	0x1fc: 0x0004, 0x1fd: 0x0004, 0x1ff: 0x0004,
+	// Block 0x8, offset 0x200
+	0x201: 0x0004, 0x202: 0x0004, 0x204: 0x0004, 0x205: 0x0004,
+	0x207: 0x0004,
+	// Block 0x9, offset 0x240
+	0x240: 0x0100, 0x241: 0x0100, 0x242: 0x0100, 0x243: 0x0100, 0x244: 0x0100, 0x245: 0x0100,
+	0x250: 0x0004, 0x251: 0x0004,
+	0x252: 0x0004, 0x253: 0x0004, 0x254: 0x0004, 0x255: 0x0004, 0x256: 0x0004, 0x257: 0x0004,
+	0x258: 0x0004, 0x259: 0x0004, 0x25a: 0x0004, 0x25c: 0x0002,
+	// Block 0xa, offset 0x280
+	0x28b: 0x0004,
+	0x28c: 0x0004, 0x28d: 0x0004, 0x28e: 0x0004, 0x28f: 0x0004, 0x290: 0x0004, 0x291: 0x0004,
+	0x292: 0x0004, 0x293: 0x0004, 0x294: 0x0004, 0x295: 0x0004, 0x296: 0x0004, 0x297: 0x0004,
+	0x298: 0x0004, 0x299: 0x0004, 0x29a: 0x0004, 0x29b: 0x0004, 0x29c: 0x0004, 0x29d: 0x0004,
+	0x29e: 0x0004, 0x29f: 0x0004,
+	0x2b0: 0x0004,
+	// Block 0xb, offset 0x2c0
+	0x2d6: 0x0004, 0x2d7: 0x0004,
+	0x2d8: 0x0004, 0x2d9: 0x0004, 0x2da: 0x0004, 0x2db: 0x0004, 0x2dc: 0x0004, 0x2dd: 0x0100,
+	0x2df: 0x0004, 0x2e0: 0x0004, 0x2e1: 0x0004, 0x2e2: 0x0004, 0x2e3: 0x0004,
+	0x2e4: 0x0004, 0x2e7: 0x0004, 0x2e8: 0x0004,
+	0x2ea: 0x0004, 0x2eb: 0x0004, 0x2ec: 0x0004, 0x2ed: 0x0004,
+	// Block 0xc, offset 0x300
+	0x30f: 0x0100, 0x311: 0x0004,
+	0x330: 0x0004, 0x331: 0x0004, 0x332: 0x0004, 0x333: 0x0004, 0x334: 0x0004, 0x335: 0x0004,
+	0x336: 0x0004, 0x337: 0x0004, 0x338: 0x0004, 0x339: 0x0004, 0x33a: 0x0004, 0x33b: 0x0004,
+	0x33c: 0x0004, 0x33d: 0x0004, 0x33e: 0x0004, 0x33f: 0x0004,
+	// Block 0xd, offset 0x340
+	0x340: 0x0004, 0x341: 0x0004, 0x342: 0x0004, 0x343: 0x0004, 0x344: 0x0004, 0x345: 0x0004,
+	0x346: 0x0004, 0x347: 0x0004, 0x348: 0x0004, 0x349: 0x0004, 0x34a: 0x0004,
+	// Block 0xe, offset 0x380
+	0x3a6: 0x0004, 0x3a7: 0x0004, 0x3a8: 0x0004, 0x3a9: 0x0004,
+	0x3aa: 0x0004, 0x3ab: 0x0004, 0x3ac: 0x0004, 0x3ad: 0x0004, 0x3ae: 0x0004, 0x3af: 0x0004,
+	0x3b0: 0x0004,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0x0004, 0x3ec: 0x0004, 0x3ed: 0x0004, 0x3ee: 0x0004, 0x3ef: 0x0004,
+	0x3f0: 0x0004, 0x3f1: 0x0004, 0x3f2: 0x0004, 0x3f3: 0x0004,
+	0x3fd: 0x0004,
+	// Block 0x10, offset 0x400
+	0x416: 0x0004, 0x417: 0x0004,
+	0x418: 0x0004, 0x419: 0x0004, 0x41b: 0x0004, 0x41c: 0x0004, 0x41d: 0x0004,
+	0x41e: 0x0004, 0x41f: 0x0004, 0x420: 0x0004, 0x421: 0x0004, 0x422: 0x0004, 0x423: 0x0004,
+	0x425: 0x0004, 0x426: 0x0004, 0x427: 0x0004, 0x429: 0x0004,
+	0x42a: 0x0004, 0x42b: 0x0004, 0x42c: 0x0004, 0x42d: 0x0004,
+	// Block 0x11, offset 0x440
+	0x459: 0x0004, 0x45a: 0x0004, 0x45b: 0x0004,
+	// Block 0x12, offset 0x480
+	0x490: 0x0100, 0x491: 0x0100,
+	0x498: 0x0004, 0x499: 0x0004, 0x49a: 0x0004, 0x49b: 0x0004, 0x49c: 0x0004, 0x49d: 0x0004,
+	0x49e: 0x0004, 0x49f: 0x0004,
+	// Block 0x13, offset 0x4c0
+	0x4ca: 0x0004, 0x4cb: 0x0004,
+	0x4cc: 0x0004, 0x4cd: 0x0004, 0x4ce: 0x0004, 0x4cf: 0x0004, 0x4d0: 0x0004, 0x4d1: 0x0004,
+	0x4d2: 0x0004, 0x4d3: 0x0004, 0x4d4: 0x0004, 0x4d5: 0x0004, 0x4d6: 0x0004, 0x4d7: 0x0004,
+	0x4d8: 0x0004, 0x4d9: 0x0004, 0x4da: 0x0004, 0x4db: 0x0004, 0x4dc: 0x0004, 0x4dd: 0x0004,
+	0x4de: 0x0004, 0x4df: 0x0004, 0x4e0: 0x0004, 0x4e1: 0x0004, 0x4e2: 0x0100, 0x4e3: 0x0004,
+	0x4e4: 0x0004, 0x4e5: 0x0004, 0x4e6: 0x0004, 0x4e7: 0x0004, 0x4e8: 0x0004, 0x4e9: 0x0004,
+	0x4ea: 0x0004, 0x4eb: 0x0004, 0x4ec: 0x0004, 0x4ed: 0x0004, 0x4ee: 0x0004, 0x4ef: 0x0004,
+	0x4f0: 0x0004, 0x4f1: 0x0004, 0x4f2: 0x0004, 0x4f3: 0x0004, 0x4f4: 0x0004, 0x4f5: 0x0004,
+	0x4f6: 0x0004, 0x4f7: 0x0004, 0x4f8: 0x0004, 0x4f9: 0x0004, 0x4fa: 0x0004, 0x4fb: 0x0004,
+	0x4fc: 0x0004, 0x4fd: 0x0004, 0x4fe: 0x0004, 0x4ff: 0x0004,
+	// Block 0x14, offset 0x500
+	0x500: 0x0004, 0x501: 0x0004, 0x502: 0x0004, 0x503: 0x0400,
+	0x53a: 0x0004, 0x53b: 0x0400,
+	0x53c: 0x0004, 0x53e: 0x0400, 0x53f: 0x0400,
+	// Block 0x15, offset 0x540
+	0x540: 0x0400, 0x541: 0x0004, 0x542: 0x0004, 0x543: 0x0004, 0x544: 0x0004, 0x545: 0x0004,
+	0x546: 0x0004, 0x547: 0x0004, 0x548: 0x0004, 0x549: 0x0400, 0x54a: 0x0400, 0x54b: 0x0400,
+	0x54c: 0x0400, 0x54d: 0x0004, 0x54e: 0x0400, 0x54f: 0x0400, 0x551: 0x0004,
+	0x552: 0x0004, 0x553: 0x0004, 0x554: 0x0004, 0x555: 0x0004, 0x556: 0x0004, 0x557: 0x0004,
+	0x562: 0x0004, 0x563: 0x0004,
+	// Block 0x16, offset 0x580
+	0x581: 0x0004, 0x582: 0x0400, 0x583: 0x0400,
+	0x5bc: 0x0004, 0x5be: 0x0004, 0x5bf: 0x0400,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x0400, 0x5c1: 0x0004, 0x5c2: 0x0004, 0x5c3: 0x0004, 0x5c4: 0x0004,
+	0x5c7: 0x0400, 0x5c8: 0x0400, 0x5cb: 0x0400,
+	0x5cc: 0x0400, 0x5cd: 0x0004,
+	0x5d7: 0x0004,
+	0x5e2: 0x0004, 0x5e3: 0x0004,
+	0x5fe: 0x0004,
+	// Block 0x18, offset 0x600
+	0x601: 0x0004, 0x602: 0x0004, 0x603: 0x0400,
+	0x63c: 0x0004, 0x63e: 0x0400, 0x63f: 0x0400,
+	// Block 0x19, offset 0x640
+	0x640: 0x0400, 0x641: 0x0004, 0x642: 0x0004,
+	0x647: 0x0004, 0x648: 0x0004, 0x64b: 0x0004,
+	0x64c: 0x0004, 0x64d: 0x0004, 0x651: 0x0004,
+	0x670: 0x0004, 0x671: 0x0004, 0x675: 0x0004,
+	// Block 0x1a, offset 0x680
+	0x680: 0x0400, 0x681: 0x0004, 0x682: 0x0004, 0x683: 0x0004, 0x684: 0x0004, 0x685: 0x0004,
+	0x687: 0x0004, 0x688: 0x0004, 0x689: 0x0400, 0x68b: 0x0400,
+	0x68c: 0x0400, 0x68d: 0x0004,
+	0x6a2: 0x0004, 0x6a3: 0x0004,
+	0x6ba: 0x0004, 0x6bb: 0x0004,
+	0x6bc: 0x0004, 0x6bd: 0x0004, 0x6be: 0x0004, 0x6bf: 0x0004,
+	// Block 0x1b, offset 0x6c0
+	0x6c1: 0x0004, 0x6c2: 0x0400, 0x6c3: 0x0400,
+	0x6fc: 0x0004, 0x6fe: 0x0004, 0x6ff: 0x0004,
+	// Block 0x1c, offset 0x700
+	0x700: 0x0400, 0x701: 0x0004, 0x702: 0x0004, 0x703: 0x0004, 0x704: 0x0004,
+	0x707: 0x0400, 0x708: 0x0400, 0x70b: 0x0400,
+	0x70c: 0x0400, 0x70d: 0x0004,
+	0x715: 0x0004, 0x716: 0x0004, 0x717: 0x0004,
+	0x722: 0x0004, 0x723: 0x0004,
+	// Block 0x1d, offset 0x740
+	0x742: 0x0004,
+	0x77e: 0x0004, 0x77f: 0x0400,
+	// Block 0x1e, offset 0x780
+	0x780: 0x0004, 0x781: 0x0400, 0x782: 0x0400,
+	0x786: 0x0400, 0x787: 0x0400, 0x788: 0x0400, 0x78a: 0x0400, 0x78b: 0x0400,
+	0x78c: 0x0400, 0x78d: 0x0004,
+	0x797: 0x0004,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x0004, 0x7c1: 0x0400, 0x7c2: 0x0400, 0x7c3: 0x0400, 0x7c4: 0x0004,
+	0x7fc: 0x0004, 0x7fe: 0x0004, 0x7ff: 0x0004,
+	// Block 0x20, offset 0x800
+	0x800: 0x0004, 0x801: 0x0400, 0x802: 0x0400, 0x803: 0x0400, 0x804: 0x0400,
+	0x806: 0x0004, 0x807: 0x0004, 0x808: 0x0004, 0x80a: 0x0004, 0x80b: 0x0004,
+	0x80c: 0x0004, 0x80d: 0x0004,
+	0x815: 0x0004, 0x816: 0x0004,
+	0x822: 0x0004, 0x823: 0x0004,
+	// Block 0x21, offset 0x840
+	0x841: 0x0004, 0x842: 0x0400, 0x843: 0x0400,
+	0x87c: 0x0004, 0x87e: 0x0400, 0x87f: 0x0004,
+	// Block 0x22, offset 0x880
+	0x880: 0x0400, 0x881: 0x0400, 0x882: 0x0004, 0x883: 0x0400, 0x884: 0x0400,
+	0x886: 0x0004, 0x887: 0x0400, 0x888: 0x0400, 0x88a: 0x0400, 0x88b: 0x0400,
+	0x88c: 0x0004, 0x88d: 0x0004,
+	0x895: 0x0004, 0x896: 0x0004,
+	0x8a2: 0x0004, 0x8a3: 0x0004,
+	0x8b3: 0x0400,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0004, 0x8c1: 0x0004, 0x8c2: 0x0400, 0x8c3: 0x0400,
+	0x8fb: 0x0004,
+	0x8fc: 0x0004, 0x8fe: 0x0004, 0x8ff: 0x0400,
+	// Block 0x24, offset 0x900
+	0x900: 0x0400, 0x901: 0x0004, 0x902: 0x0004, 0x903: 0x0004, 0x904: 0x0004,
+	0x906: 0x0400, 0x907: 0x0400, 0x908: 0x0400, 0x90a: 0x0400, 0x90b: 0x0400,
+	0x90c: 0x0400, 0x90d: 0x0004, 0x90e: 0x0100,
+	0x917: 0x0004,
+	0x922: 0x0004, 0x923: 0x0004,
+	// Block 0x25, offset 0x940
+	0x941: 0x0004, 0x942: 0x0400, 0x943: 0x0400,
+	// Block 0x26, offset 0x980
+	0x98a: 0x0004,
+	0x98f: 0x0004, 0x990: 0x0400, 0x991: 0x0400,
+	0x992: 0x0004, 0x993: 0x0004, 0x994: 0x0004, 0x996: 0x0004,
+	0x998: 0x0400, 0x999: 0x0400, 0x99a: 0x0400, 0x99b: 0x0400, 0x99c: 0x0400, 0x99d: 0x0400,
+	0x99e: 0x0400, 0x99f: 0x0004,
+	0x9b2: 0x0400, 0x9b3: 0x0400,
+	// Block 0x27, offset 0x9c0
+	0x9f1: 0x0004, 0x9f3: 0x0400, 0x9f4: 0x0004, 0x9f5: 0x0004,
+	0x9f6: 0x0004, 0x9f7: 0x0004, 0x9f8: 0x0004, 0x9f9: 0x0004, 0x9fa: 0x0004,
+	// Block 0x28, offset 0xa00
+	0xa07: 0x0004, 0xa08: 0x0004, 0xa09: 0x0004, 0xa0a: 0x0004, 0xa0b: 0x0004,
+	0xa0c: 0x0004, 0xa0d: 0x0004, 0xa0e: 0x0004,
+	// Block 0x29, offset 0xa40
+	0xa71: 0x0004, 0xa73: 0x0400, 0xa74: 0x0004, 0xa75: 0x0004,
+	0xa76: 0x0004, 0xa77: 0x0004, 0xa78: 0x0004, 0xa79: 0x0004, 0xa7a: 0x0004, 0xa7b: 0x0004,
+	0xa7c: 0x0004,
+	// Block 0x2a, offset 0xa80
+	0xa88: 0x0004, 0xa89: 0x0004, 0xa8a: 0x0004, 0xa8b: 0x0004,
+	0xa8c: 0x0004, 0xa8d: 0x0004, 0xa8e: 0x0004,
+	// Block 0x2b, offset 0xac0
+	0xad8: 0x0004, 0xad9: 0x0004,
+	0xaf5: 0x0004,
+	0xaf7: 0x0004, 0xaf9: 0x0004,
+	0xafe: 0x0400, 0xaff: 0x0400,
+	// Block 0x2c, offset 0xb00
+	0xb31: 0x0004, 0xb32: 0x0004, 0xb33: 0x0004, 0xb34: 0x0004, 0xb35: 0x0004,
+	0xb36: 0x0004, 0xb37: 0x0004, 0xb38: 0x0004, 0xb39: 0x0004, 0xb3a: 0x0004, 0xb3b: 0x0004,
+	0xb3c: 0x0004, 0xb3d: 0x0004, 0xb3e: 0x0004, 0xb3f: 0x0400,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x0004, 0xb41: 0x0004, 0xb42: 0x0004, 0xb43: 0x0004, 0xb44: 0x0004,
+	0xb46: 0x0004, 0xb47: 0x0004,
+	0xb4d: 0x0004, 0xb4e: 0x0004, 0xb4f: 0x0004, 0xb50: 0x0004, 0xb51: 0x0004,
+	0xb52: 0x0004, 0xb53: 0x0004, 0xb54: 0x0004, 0xb55: 0x0004, 0xb56: 0x0004, 0xb57: 0x0004,
+	0xb59: 0x0004, 0xb5a: 0x0004, 0xb5b: 0x0004, 0xb5c: 0x0004, 0xb5d: 0x0004,
+	0xb5e: 0x0004, 0xb5f: 0x0004, 0xb60: 0x0004, 0xb61: 0x0004, 0xb62: 0x0004, 0xb63: 0x0004,
+	0xb64: 0x0004, 0xb65: 0x0004, 0xb66: 0x0004, 0xb67: 0x0004, 0xb68: 0x0004, 0xb69: 0x0004,
+	0xb6a: 0x0004, 0xb6b: 0x0004, 0xb6c: 0x0004, 0xb6d: 0x0004, 0xb6e: 0x0004, 0xb6f: 0x0004,
+	0xb70: 0x0004, 0xb71: 0x0004, 0xb72: 0x0004, 0xb73: 0x0004, 0xb74: 0x0004, 0xb75: 0x0004,
+	0xb76: 0x0004, 0xb77: 0x0004, 0xb78: 0x0004, 0xb79: 0x0004, 0xb7a: 0x0004, 0xb7b: 0x0004,
+	0xb7c: 0x0004,
+	// Block 0x2e, offset 0xb80
+	0xb86: 0x0004,
+	// Block 0x2f, offset 0xbc0
+	0xbed: 0x0004, 0xbee: 0x0004, 0xbef: 0x0004,
+	0xbf0: 0x0004, 0xbf1: 0x0400, 0xbf2: 0x0004, 0xbf3: 0x0004, 0xbf4: 0x0004, 0xbf5: 0x0004,
+	0xbf6: 0x0004, 0xbf7: 0x0004, 0xbf9: 0x0004, 0xbfa: 0x0004, 0xbfb: 0x0400,
+	0xbfc: 0x0400, 0xbfd: 0x0004, 0xbfe: 0x0004,
+	// Block 0x30, offset 0xc00
+	0xc16: 0x0400, 0xc17: 0x0400,
+	0xc18: 0x0004, 0xc19: 0x0004,
+	0xc1e: 0x0004, 0xc1f: 0x0004, 0xc20: 0x0004,
+	0xc31: 0x0004, 0xc32: 0x0004, 0xc33: 0x0004, 0xc34: 0x0004,
+	// Block 0x31, offset 0xc40
+	0xc42: 0x0004, 0xc44: 0x0400, 0xc45: 0x0004,
+	0xc46: 0x0004,
+	0xc4d: 0x0004,
+	0xc5d: 0x0004,
+	// Block 0x32, offset 0xc80
+	0xc80: 0x0010, 0xc81: 0x0010, 0xc82: 0x0010, 0xc83: 0x0010, 0xc84: 0x0010, 0xc85: 0x0010,
+	0xc86: 0x0010, 0xc87: 0x0010, 0xc88: 0x0010, 0xc89: 0x0010, 0xc8a: 0x0010, 0xc8b: 0x0010,
+	0xc8c: 0x0010, 0xc8d: 0x0010, 0xc8e: 0x0010, 0xc8f: 0x0010, 0xc90: 0x0010, 0xc91: 0x0010,
+	0xc92: 0x0010, 0xc93: 0x0010, 0xc94: 0x0010, 0xc95: 0x0010, 0xc96: 0x0010, 0xc97: 0x0010,
+	0xc98: 0x0010, 0xc99: 0x0010, 0xc9a: 0x0010, 0xc9b: 0x0010, 0xc9c: 0x0010, 0xc9d: 0x0010,
+	0xc9e: 0x0010, 0xc9f: 0x0010, 0xca0: 0x0010, 0xca1: 0x0010, 0xca2: 0x0010, 0xca3: 0x0010,
+	0xca4: 0x0010, 0xca5: 0x0010, 0xca6: 0x0010, 0xca7: 0x0010, 0xca8: 0x0010, 0xca9: 0x0010,
+	0xcaa: 0x0010, 0xcab: 0x0010, 0xcac: 0x0010, 0xcad: 0x0010, 0xcae: 0x0010, 0xcaf: 0x0010,
+	0xcb0: 0x0010, 0xcb1: 0x0010, 0xcb2: 0x0010, 0xcb3: 0x0010, 0xcb4: 0x0010, 0xcb5: 0x0010,
+	0xcb6: 0x0010, 0xcb7: 0x0010, 0xcb8: 0x0010, 0xcb9: 0x0010, 0xcba: 0x0010, 0xcbb: 0x0010,
+	0xcbc: 0x0010, 0xcbd: 0x0010, 0xcbe: 0x0010, 0xcbf: 0x0010,
+	// Block 0x33, offset 0xcc0
+	0xcc0: 0x0010, 0xcc1: 0x0010, 0xcc2: 0x0010, 0xcc3: 0x0010, 0xcc4: 0x0010, 0xcc5: 0x0010,
+	0xcc6: 0x0010, 0xcc7: 0x0010, 0xcc8: 0x0010, 0xcc9: 0x0010, 0xcca: 0x0010, 0xccb: 0x0010,
+	0xccc: 0x0010, 0xccd: 0x0010, 0xcce: 0x0010, 0xccf: 0x0010, 0xcd0: 0x0010, 0xcd1: 0x0010,
+	0xcd2: 0x0010, 0xcd3: 0x0010, 0xcd4: 0x0010, 0xcd5: 0x0010, 0xcd6: 0x0010, 0xcd7: 0x0010,
+	0xcd8: 0x0010, 0xcd9: 0x0010, 0xcda: 0x0010, 0xcdb: 0x0010, 0xcdc: 0x0010, 0xcdd: 0x0010,
+	0xcde: 0x0010, 0xcdf: 0x0010, 0xce0: 0x1000, 0xce1: 0x1000, 0xce2: 0x1000, 0xce3: 0x1000,
+	0xce4: 0x1000, 0xce5: 0x1000, 0xce6: 0x1000, 0xce7: 0x1000, 0xce8: 0x1000, 0xce9: 0x1000,
+	0xcea: 0x1000, 0xceb: 0x1000, 0xcec: 0x1000, 0xced: 0x1000, 0xcee: 0x1000, 0xcef: 0x1000,
+	0xcf0: 0x1000, 0xcf1: 0x1000, 0xcf2: 0x1000, 0xcf3: 0x1000, 0xcf4: 0x1000, 0xcf5: 0x1000,
+	0xcf6: 0x1000, 0xcf7: 0x1000, 0xcf8: 0x1000, 0xcf9: 0x1000, 0xcfa: 0x1000, 0xcfb: 0x1000,
+	0xcfc: 0x1000, 0xcfd: 0x1000, 0xcfe: 0x1000, 0xcff: 0x1000,
+	// Block 0x34, offset 0xd00
+	0xd00: 0x1000, 0xd01: 0x1000, 0xd02: 0x1000, 0xd03: 0x1000, 0xd04: 0x1000, 0xd05: 0x1000,
+	0xd06: 0x1000, 0xd07: 0x1000, 0xd08: 0x1000, 0xd09: 0x1000, 0xd0a: 0x1000, 0xd0b: 0x1000,
+	0xd0c: 0x1000, 0xd0d: 0x1000, 0xd0e: 0x1000, 0xd0f: 0x1000, 0xd10: 0x1000, 0xd11: 0x1000,
+	0xd12: 0x1000, 0xd13: 0x1000, 0xd14: 0x1000, 0xd15: 0x1000, 0xd16: 0x1000, 0xd17: 0x1000,
+	0xd18: 0x1000, 0xd19: 0x1000, 0xd1a: 0x1000, 0xd1b: 0x1000, 0xd1c: 0x1000, 0xd1d: 0x1000,
+	0xd1e: 0x1000, 0xd1f: 0x1000, 0xd20: 0x1000, 0xd21: 0x1000, 0xd22: 0x1000, 0xd23: 0x1000,
+	0xd24: 0x1000, 0xd25: 0x1000, 0xd26: 0x1000, 0xd27: 0x1000, 0xd28: 0x0800, 0xd29: 0x0800,
+	0xd2a: 0x0800, 0xd2b: 0x0800, 0xd2c: 0x0800, 0xd2d: 0x0800, 0xd2e: 0x0800, 0xd2f: 0x0800,
+	0xd30: 0x0800, 0xd31: 0x0800, 0xd32: 0x0800, 0xd33: 0x0800, 0xd34: 0x0800, 0xd35: 0x0800,
+	0xd36: 0x0800, 0xd37: 0x0800, 0xd38: 0x0800, 0xd39: 0x0800, 0xd3a: 0x0800, 0xd3b: 0x0800,
+	0xd3c: 0x0800, 0xd3d: 0x0800, 0xd3e: 0x0800, 0xd3f: 0x0800,
+	// Block 0x35, offset 0xd40
+	0xd40: 0x0800, 0xd41: 0x0800, 0xd42: 0x0800, 0xd43: 0x0800, 0xd44: 0x0800, 0xd45: 0x0800,
+	0xd46: 0x0800, 0xd47: 0x0800, 0xd48: 0x0800, 0xd49: 0x0800, 0xd4a: 0x0800, 0xd4b: 0x0800,
+	0xd4c: 0x0800, 0xd4d: 0x0800, 0xd4e: 0x0800, 0xd4f: 0x0800, 0xd50: 0x0800, 0xd51: 0x0800,
+	0xd52: 0x0800, 0xd53: 0x0800, 0xd54: 0x0800, 0xd55: 0x0800, 0xd56: 0x0800, 0xd57: 0x0800,
+	0xd58: 0x0800, 0xd59: 0x0800, 0xd5a: 0x0800, 0xd5b: 0x0800, 0xd5c: 0x0800, 0xd5d: 0x0800,
+	0xd5e: 0x0800, 0xd5f: 0x0800, 0xd60: 0x0800, 0xd61: 0x0800, 0xd62: 0x0800, 0xd63: 0x0800,
+	0xd64: 0x0800, 0xd65: 0x0800, 0xd66: 0x0800, 0xd67: 0x0800, 0xd68: 0x0800, 0xd69: 0x0800,
+	0xd6a: 0x0800, 0xd6b: 0x0800, 0xd6c: 0x0800, 0xd6d: 0x0800, 0xd6e: 0x0800, 0xd6f: 0x0800,
+	0xd70: 0x0800, 0xd71: 0x0800, 0xd72: 0x0800, 0xd73: 0x0800, 0xd74: 0x0800, 0xd75: 0x0800,
+	0xd76: 0x0800, 0xd77: 0x0800, 0xd78: 0x0800, 0xd79: 0x0800, 0xd7a: 0x0800, 0xd7b: 0x0800,
+	0xd7c: 0x0800, 0xd7d: 0x0800, 0xd7e: 0x0800, 0xd7f: 0x0800,
+	// Block 0x36, offset 0xd80
+	0xd9d: 0x0004,
+	0xd9e: 0x0004, 0xd9f: 0x0004,
+	// Block 0x37, offset 0xdc0
+	0xdd2: 0x0004, 0xdd3: 0x0004, 0xdd4: 0x0004, 0xdd5: 0x0400,
+	0xdf2: 0x0004, 0xdf3: 0x0004, 0xdf4: 0x0400,
+	// Block 0x38, offset 0xe00
+	0xe12: 0x0004, 0xe13: 0x0004,
+	0xe32: 0x0004, 0xe33: 0x0004,
+	// Block 0x39, offset 0xe40
+	0xe74: 0x0004, 0xe75: 0x0004,
+	0xe76: 0x0400, 0xe77: 0x0004, 0xe78: 0x0004, 0xe79: 0x0004, 0xe7a: 0x0004, 0xe7b: 0x0004,
+	0xe7c: 0x0004, 0xe7d: 0x0004, 0xe7e: 0x0400, 0xe7f: 0x0400,
+	// Block 0x3a, offset 0xe80
+	0xe80: 0x0400, 0xe81: 0x0400, 0xe82: 0x0400, 0xe83: 0x0400, 0xe84: 0x0400, 0xe85: 0x0400,
+	0xe86: 0x0004, 0xe87: 0x0400, 0xe88: 0x0400, 0xe89: 0x0004, 0xe8a: 0x0004, 0xe8b: 0x0004,
+	0xe8c: 0x0004, 0xe8d: 0x0004, 0xe8e: 0x0004, 0xe8f: 0x0004, 0xe90: 0x0004, 0xe91: 0x0004,
+	0xe92: 0x0004, 0xe93: 0x0004,
+	0xe9d: 0x0004,
+	// Block 0x3b, offset 0xec0
+	0xecb: 0x0004,
+	0xecc: 0x0004, 0xecd: 0x0004, 0xece: 0x0002, 0xecf: 0x0004,
+	// Block 0x3c, offset 0xf00
+	0xf05: 0x0004,
+	0xf06: 0x0004,
+	0xf29: 0x0004,
+	// Block 0x3d, offset 0xf40
+	0xf60: 0x0004, 0xf61: 0x0004, 0xf62: 0x0004, 0xf63: 0x0400,
+	0xf64: 0x0400, 0xf65: 0x0400, 0xf66: 0x0400, 0xf67: 0x0004, 0xf68: 0x0004, 0xf69: 0x0400,
+	0xf6a: 0x0400, 0xf6b: 0x0400,
+	0xf70: 0x0400, 0xf71: 0x0400, 0xf72: 0x0004, 0xf73: 0x0400, 0xf74: 0x0400, 0xf75: 0x0400,
+	0xf76: 0x0400, 0xf77: 0x0400, 0xf78: 0x0400, 0xf79: 0x0004, 0xf7a: 0x0004, 0xf7b: 0x0004,
+	// Block 0x3e, offset 0xf80
+	0xf97: 0x0004,
+	0xf98: 0x0004, 0xf99: 0x0400, 0xf9a: 0x0400, 0xf9b: 0x0004,
+	// Block 0x3f, offset 0xfc0
+	0xfd5: 0x0400, 0xfd6: 0x0004, 0xfd7: 0x0400,
+	0xfd8: 0x0004, 0xfd9: 0x0004, 0xfda: 0x0004, 0xfdb: 0x0004, 0xfdc: 0x0004, 0xfdd: 0x0004,
+	0xfde: 0x0004, 0xfe0: 0x0004, 0xfe2: 0x0004,
+	0xfe5: 0x0004, 0xfe6: 0x0004, 0xfe7: 0x0004, 0xfe8: 0x0004, 0xfe9: 0x0004,
+	0xfea: 0x0004, 0xfeb: 0x0004, 0xfec: 0x0004, 0xfed: 0x0400, 0xfee: 0x0400, 0xfef: 0x0400,
+	0xff0: 0x0400, 0xff1: 0x0400, 0xff2: 0x0400, 0xff3: 0x0004, 0xff4: 0x0004, 0xff5: 0x0004,
+	0xff6: 0x0004, 0xff7: 0x0004, 0xff8: 0x0004, 0xff9: 0x0004, 0xffa: 0x0004, 0xffb: 0x0004,
+	0xffc: 0x0004, 0xfff: 0x0004,
+	// Block 0x40, offset 0x1000
+	0x1030: 0x0004, 0x1031: 0x0004, 0x1032: 0x0004, 0x1033: 0x0004, 0x1034: 0x0004, 0x1035: 0x0004,
+	0x1036: 0x0004, 0x1037: 0x0004, 0x1038: 0x0004, 0x1039: 0x0004, 0x103a: 0x0004, 0x103b: 0x0004,
+	0x103c: 0x0004, 0x103d: 0x0004, 0x103e: 0x0004, 0x103f: 0x0004,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x0004, 0x1041: 0x0004, 0x1042: 0x0004, 0x1043: 0x0004, 0x1044: 0x0004, 0x1045: 0x0004,
+	0x1046: 0x0004, 0x1047: 0x0004, 0x1048: 0x0004, 0x1049: 0x0004, 0x104a: 0x0004, 0x104b: 0x0004,
+	0x104c: 0x0004, 0x104d: 0x0004, 0x104e: 0x0004,
+	// Block 0x42, offset 0x1080
+	0x1080: 0x0004, 0x1081: 0x0004, 0x1082: 0x0004, 0x1083: 0x0004, 0x1084: 0x0400,
+	0x10b4: 0x0004, 0x10b5: 0x0004,
+	0x10b6: 0x0004, 0x10b7: 0x0004, 0x10b8: 0x0004, 0x10b9: 0x0004, 0x10ba: 0x0004, 0x10bb: 0x0400,
+	0x10bc: 0x0004, 0x10bd: 0x0400, 0x10be: 0x0400, 0x10bf: 0x0400,
+	// Block 0x43, offset 0x10c0
+	0x10c0: 0x0400, 0x10c1: 0x0400, 0x10c2: 0x0004, 0x10c3: 0x0400, 0x10c4: 0x0400,
+	0x10eb: 0x0004, 0x10ec: 0x0004, 0x10ed: 0x0004, 0x10ee: 0x0004, 0x10ef: 0x0004,
+	0x10f0: 0x0004, 0x10f1: 0x0004, 0x10f2: 0x0004, 0x10f3: 0x0004,
+	// Block 0x44, offset 0x1100
+	0x1100: 0x0004, 0x1101: 0x0004, 0x1102: 0x0400,
+	0x1121: 0x0400, 0x1122: 0x0004, 0x1123: 0x0004,
+	0x1124: 0x0004, 0x1125: 0x0004, 0x1126: 0x0400, 0x1127: 0x0400, 0x1128: 0x0004, 0x1129: 0x0004,
+	0x112a: 0x0400, 0x112b: 0x0004, 0x112c: 0x0004, 0x112d: 0x0004,
+	// Block 0x45, offset 0x1140
+	0x1166: 0x0004, 0x1167: 0x0400, 0x1168: 0x0004, 0x1169: 0x0004,
+	0x116a: 0x0400, 0x116b: 0x0400, 0x116c: 0x0400, 0x116d: 0x0004, 0x116e: 0x0400, 0x116f: 0x0004,
+	0x1170: 0x0004, 0x1171: 0x0004, 0x1172: 0x0400, 0x1173: 0x0400,
+	// Block 0x46, offset 0x1180
+	0x11a4: 0x0400, 0x11a5: 0x0400, 0x11a6: 0x0400, 0x11a7: 0x0400, 0x11a8: 0x0400, 0x11a9: 0x0400,
+	0x11aa: 0x0400, 0x11ab: 0x0400, 0x11ac: 0x0004, 0x11ad: 0x0004, 0x11ae: 0x0004, 0x11af: 0x0004,
+	0x11b0: 0x0004, 0x11b1: 0x0004, 0x11b2: 0x0004, 0x11b3: 0x0004, 0x11b4: 0x0400, 0x11b5: 0x0400,
+	0x11b6: 0x0004, 0x11b7: 0x0004,
+	// Block 0x47, offset 0x11c0
+	0x11d0: 0x0004, 0x11d1: 0x0004,
+	0x11d2: 0x0004, 0x11d4: 0x0004, 0x11d5: 0x0004, 0x11d6: 0x0004, 0x11d7: 0x0004,
+	0x11d8: 0x0004, 0x11d9: 0x0004, 0x11da: 0x0004, 0x11db: 0x0004, 0x11dc: 0x0004, 0x11dd: 0x0004,
+	0x11de: 0x0004, 0x11df: 0x0004, 0x11e0: 0x0004, 0x11e1: 0x0400, 0x11e2: 0x0004, 0x11e3: 0x0004,
+	0x11e4: 0x0004, 0x11e5: 0x0004, 0x11e6: 0x0004, 0x11e7: 0x0004, 0x11e8: 0x0004,
+	0x11ed: 0x0004,
+	0x11f4: 0x0004,
+	0x11f7: 0x0400, 0x11f8: 0x0004, 0x11f9: 0x0004,
+	// Block 0x48, offset 0x1200
+	0x120b: 0x0002,
+	0x120c: 0x0004, 0x120d: 0x2000, 0x120e: 0x0002, 0x120f: 0x0002,
+	0x1228: 0x0002, 0x1229: 0x0002,
+	0x122a: 0x0002, 0x122b: 0x0002, 0x122c: 0x0002, 0x122d: 0x0002, 0x122e: 0x0002,
+	0x123c: 0x0008,
+	// Block 0x49, offset 0x1240
+	0x1249: 0x0008,
+	0x1260: 0x0002, 0x1261: 0x0002, 0x1262: 0x0002, 0x1263: 0x0002,
+	0x1264: 0x0002, 0x1265: 0x0002, 0x1266: 0x0002, 0x1267: 0x0002, 0x1268: 0x0002, 0x1269: 0x0002,
+	0x126a: 0x0002, 0x126b: 0x0002, 0x126c: 0x0002, 0x126d: 0x0002, 0x126e: 0x0002, 0x126f: 0x0002,
+	// Block 0x4a, offset 0x1280
+	0x1290: 0x0004, 0x1291: 0x0004,
+	0x1292: 0x0004, 0x1293: 0x0004, 0x1294: 0x0004, 0x1295: 0x0004, 0x1296: 0x0004, 0x1297: 0x0004,
+	0x1298: 0x0004, 0x1299: 0x0004, 0x129a: 0x0004, 0x129b: 0x0004, 0x129c: 0x0004, 0x129d: 0x0004,
+	0x129e: 0x0004, 0x129f: 0x0004, 0x12a0: 0x0004, 0x12a1: 0x0004, 0x12a2: 0x0004, 0x12a3: 0x0004,
+	0x12a4: 0x0004, 0x12a5: 0x0004, 0x12a6: 0x0004, 0x12a7: 0x0004, 0x12a8: 0x0004, 0x12a9: 0x0004,
+	0x12aa: 0x0004, 0x12ab: 0x0004, 0x12ac: 0x0004, 0x12ad: 0x0004, 0x12ae: 0x0004, 0x12af: 0x0004,
+	0x12b0: 0x0004,
+	// Block 0x4b, offset 0x12c0
+	0x12e2: 0x0008,
+	0x12f9: 0x0008,
+	// Block 0x4c, offset 0x1300
+	0x1314: 0x0008, 0x1315: 0x0008, 0x1316: 0x0008, 0x1317: 0x0008,
+	0x1318: 0x0008, 0x1319: 0x0008,
+	0x1329: 0x0008,
+	0x132a: 0x0008,
+	// Block 0x4d, offset 0x1340
+	0x135a: 0x0008, 0x135b: 0x0008,
+	0x1368: 0x0008,
+	// Block 0x4e, offset 0x1380
+	0x1388: 0x0008,
+	// Block 0x4f, offset 0x13c0
+	0x13cf: 0x0008,
+	0x13e9: 0x0008,
+	0x13ea: 0x0008, 0x13eb: 0x0008, 0x13ec: 0x0008, 0x13ed: 0x0008, 0x13ee: 0x0008, 0x13ef: 0x0008,
+	0x13f0: 0x0008, 0x13f1: 0x0008, 0x13f2: 0x0008, 0x13f3: 0x0008,
+	0x13f8: 0x0008, 0x13f9: 0x0008, 0x13fa: 0x0008,
+	// Block 0x50, offset 0x1400
+	0x1402: 0x0008,
+	// Block 0x51, offset 0x1440
+	0x146a: 0x0008, 0x146b: 0x0008,
+	0x1476: 0x0008,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x0008,
+	0x14bb: 0x0008,
+	0x14bc: 0x0008, 0x14bd: 0x0008, 0x14be: 0x0008,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x0008, 0x14c1: 0x0008, 0x14c2: 0x0008, 0x14c3: 0x0008, 0x14c4: 0x0008, 0x14c5: 0x0008,
+	0x14c7: 0x0008, 0x14c8: 0x0008, 0x14c9: 0x0008, 0x14ca: 0x0008, 0x14cb: 0x0008,
+	0x14cc: 0x0008, 0x14cd: 0x0008, 0x14ce: 0x0008, 0x14cf: 0x0008, 0x14d0: 0x0008, 0x14d1: 0x0008,
+	0x14d2: 0x0008, 0x14d4: 0x0008, 0x14d5: 0x0008, 0x14d6: 0x0008, 0x14d7: 0x0008,
+	0x14d8: 0x0008, 0x14d9: 0x0008, 0x14da: 0x0008, 0x14db: 0x0008, 0x14dc: 0x0008, 0x14dd: 0x0008,
+	0x14de: 0x0008, 0x14df: 0x0008, 0x14e0: 0x0008, 0x14e1: 0x0008, 0x14e2: 0x0008, 0x14e3: 0x0008,
+	0x14e4: 0x0008, 0x14e5: 0x0008, 0x14e6: 0x0008, 0x14e7: 0x0008, 0x14e8: 0x0008, 0x14e9: 0x0008,
+	0x14ea: 0x0008, 0x14eb: 0x0008, 0x14ec: 0x0008, 0x14ed: 0x0008, 0x14ee: 0x0008, 0x14ef: 0x0008,
+	0x14f0: 0x0008, 0x14f1: 0x0008, 0x14f2: 0x0008, 0x14f3: 0x0008, 0x14f4: 0x0008, 0x14f5: 0x0008,
+	0x14f6: 0x0008, 0x14f7: 0x0008, 0x14f8: 0x0008, 0x14f9: 0x0008, 0x14fa: 0x0008, 0x14fb: 0x0008,
+	0x14fc: 0x0008, 0x14fd: 0x0008, 0x14fe: 0x0008, 0x14ff: 0x0008,
+	// Block 0x54, offset 0x1500
+	0x1500: 0x0008, 0x1501: 0x0008, 0x1502: 0x0008, 0x1503: 0x0008, 0x1504: 0x0008, 0x1505: 0x0008,
+	0x1506: 0x0008, 0x1507: 0x0008, 0x1508: 0x0008, 0x1509: 0x0008, 0x150a: 0x0008, 0x150b: 0x0008,
+	0x150c: 0x0008, 0x150d: 0x0008, 0x150e: 0x0008, 0x150f: 0x0008, 0x1510: 0x0008, 0x1511: 0x0008,
+	0x1512: 0x0008, 0x1513: 0x0008, 0x1514: 0x0008, 0x1515: 0x0008, 0x1516: 0x0008, 0x1517: 0x0008,
+	0x1518: 0x0008, 0x1519: 0x0008, 0x151a: 0x0008, 0x151b: 0x0008, 0x151c: 0x0008, 0x151d: 0x0008,
+	0x151e: 0x0008, 0x151f: 0x0008, 0x1520: 0x0008, 0x1521: 0x0008, 0x1522: 0x0008, 0x1523: 0x0008,
+	0x1524: 0x0008, 0x1525: 0x0008, 0x1526: 0x0008, 0x1527: 0x0008, 0x1528: 0x0008, 0x1529: 0x0008,
+	0x152a: 0x0008, 0x152b: 0x0008, 0x152c: 0x0008, 0x152d: 0x0008, 0x152e: 0x0008, 0x152f: 0x0008,
+	0x1530: 0x0008, 0x1531: 0x0008, 0x1532: 0x0008, 0x1533: 0x0008, 0x1534: 0x0008, 0x1535: 0x0008,
+	0x1536: 0x0008, 0x1537: 0x0008, 0x1538: 0x0008, 0x1539: 0x0008, 0x153a: 0x0008, 0x153b: 0x0008,
+	0x153c: 0x0008, 0x153d: 0x0008, 0x153e: 0x0008, 0x153f: 0x0008,
+	// Block 0x55, offset 0x1540
+	0x1540: 0x0008, 0x1541: 0x0008, 0x1542: 0x0008, 0x1543: 0x0008, 0x1544: 0x0008, 0x1545: 0x0008,
+	0x1550: 0x0008, 0x1551: 0x0008,
+	0x1552: 0x0008, 0x1553: 0x0008, 0x1554: 0x0008, 0x1555: 0x0008, 0x1556: 0x0008, 0x1557: 0x0008,
+	0x1558: 0x0008, 0x1559: 0x0008, 0x155a: 0x0008, 0x155b: 0x0008, 0x155c: 0x0008, 0x155d: 0x0008,
+	0x155e: 0x0008, 0x155f: 0x0008, 0x1560: 0x0008, 0x1561: 0x0008, 0x1562: 0x0008, 0x1563: 0x0008,
+	0x1564: 0x0008, 0x1565: 0x0008, 0x1566: 0x0008, 0x1567: 0x0008, 0x1568: 0x0008, 0x1569: 0x0008,
+	0x156a: 0x0008, 0x156b: 0x0008, 0x156c: 0x0008, 0x156d: 0x0008, 0x156e: 0x0008, 0x156f: 0x0008,
+	0x1570: 0x0008, 0x1571: 0x0008, 0x1572: 0x0008, 0x1573: 0x0008, 0x1574: 0x0008, 0x1575: 0x0008,
+	0x1576: 0x0008, 0x1577: 0x0008, 0x1578: 0x0008, 0x1579: 0x0008, 0x157a: 0x0008, 0x157b: 0x0008,
+	0x157c: 0x0008, 0x157d: 0x0008, 0x157e: 0x0008, 0x157f: 0x0008,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x0008, 0x1581: 0x0008, 0x1582: 0x0008, 0x1583: 0x0008, 0x1584: 0x0008, 0x1585: 0x0008,
+	0x1588: 0x0008, 0x1589: 0x0008, 0x158a: 0x0008, 0x158b: 0x0008,
+	0x158c: 0x0008, 0x158d: 0x0008, 0x158e: 0x0008, 0x158f: 0x0008, 0x1590: 0x0008, 0x1591: 0x0008,
+	0x1592: 0x0008, 0x1594: 0x0008, 0x1596: 0x0008,
+	0x159d: 0x0008,
+	0x15a1: 0x0008,
+	0x15a8: 0x0008,
+	0x15b3: 0x0008, 0x15b4: 0x0008,
+	// Block 0x57, offset 0x15c0
+	0x15c4: 0x0008,
+	0x15c7: 0x0008,
+	0x15cc: 0x0008, 0x15ce: 0x0008,
+	0x15d3: 0x0008, 0x15d4: 0x0008, 0x15d5: 0x0008, 0x15d7: 0x0008,
+	0x15e3: 0x0008,
+	0x15e4: 0x0008, 0x15e5: 0x0008, 0x15e6: 0x0008, 0x15e7: 0x0008,
+	// Block 0x58, offset 0x1600
+	0x1615: 0x0008, 0x1616: 0x0008, 0x1617: 0x0008,
+	0x1621: 0x0008,
+	0x1630: 0x0008,
+	0x163f: 0x0008,
+	// Block 0x59, offset 0x1640
+	0x1674: 0x0008, 0x1675: 0x0008,
+	// Block 0x5a, offset 0x1680
+	0x1685: 0x0008,
+	0x1686: 0x0008, 0x1687: 0x0008,
+	0x169b: 0x0008, 0x169c: 0x0008,
+	// Block 0x5b, offset 0x16c0
+	0x16d0: 0x0008,
+	0x16d5: 0x0008,
+	// Block 0x5c, offset 0x1700
+	0x172f: 0x0004,
+	0x1730: 0x0004, 0x1731: 0x0004,
+	// Block 0x5d, offset 0x1740
+	0x177f: 0x0004,
+	// Block 0x5e, offset 0x1780
+	0x17a0: 0x0004, 0x17a1: 0x0004, 0x17a2: 0x0004, 0x17a3: 0x0004,
+	0x17a4: 0x0004, 0x17a5: 0x0004, 0x17a6: 0x0004, 0x17a7: 0x0004, 0x17a8: 0x0004, 0x17a9: 0x0004,
+	0x17aa: 0x0004, 0x17ab: 0x0004, 0x17ac: 0x0004, 0x17ad: 0x0004, 0x17ae: 0x0004, 0x17af: 0x0004,
+	0x17b0: 0x0004, 0x17b1: 0x0004, 0x17b2: 0x0004, 0x17b3: 0x0004, 0x17b4: 0x0004, 0x17b5: 0x0004,
+	0x17b6: 0x0004, 0x17b7: 0x0004, 0x17b8: 0x0004, 0x17b9: 0x0004, 0x17ba: 0x0004, 0x17bb: 0x0004,
+	0x17bc: 0x0004, 0x17bd: 0x0004, 0x17be: 0x0004, 0x17bf: 0x0004,
+	// Block 0x5f, offset 0x17c0
+	0x17ea: 0x0004, 0x17eb: 0x0004, 0x17ec: 0x0004, 0x17ed: 0x0004, 0x17ee: 0x0004, 0x17ef: 0x0004,
+	0x17f0: 0x0008,
+	0x17fd: 0x0008,
+	// Block 0x60, offset 0x1800
+	0x1819: 0x0004, 0x181a: 0x0004,
+	// Block 0x61, offset 0x1840
+	0x1857: 0x0008,
+	0x1859: 0x0008,
+	// Block 0x62, offset 0x1880
+	0x18af: 0x0004,
+	0x18b0: 0x0004, 0x18b1: 0x0004, 0x18b2: 0x0004, 0x18b4: 0x0004, 0x18b5: 0x0004,
+	0x18b6: 0x0004, 0x18b7: 0x0004, 0x18b8: 0x0004, 0x18b9: 0x0004, 0x18ba: 0x0004, 0x18bb: 0x0004,
+	0x18bc: 0x0004, 0x18bd: 0x0004,
+	// Block 0x63, offset 0x18c0
+	0x18de: 0x0004, 0x18df: 0x0004,
+	// Block 0x64, offset 0x1900
+	0x1930: 0x0004, 0x1931: 0x0004,
+	// Block 0x65, offset 0x1940
+	0x1942: 0x0004,
+	0x1946: 0x0004, 0x194b: 0x0004,
+	0x1963: 0x0400,
+	0x1964: 0x0400, 0x1965: 0x0004, 0x1966: 0x0004, 0x1967: 0x0400,
+	0x196c: 0x0004,
+	// Block 0x66, offset 0x1980
+	0x1980: 0x0400, 0x1981: 0x0400,
+	0x19b4: 0x0400, 0x19b5: 0x0400,
+	0x19b6: 0x0400, 0x19b7: 0x0400, 0x19b8: 0x0400, 0x19b9: 0x0400, 0x19ba: 0x0400, 0x19bb: 0x0400,
+	0x19bc: 0x0400, 0x19bd: 0x0400, 0x19be: 0x0400, 0x19bf: 0x0400,
+	// Block 0x67, offset 0x19c0
+	0x19c0: 0x0400, 0x19c1: 0x0400, 0x19c2: 0x0400, 0x19c3: 0x0400, 0x19c4: 0x0004, 0x19c5: 0x0004,
+	0x19e0: 0x0004, 0x19e1: 0x0004, 0x19e2: 0x0004, 0x19e3: 0x0004,
+	0x19e4: 0x0004, 0x19e5: 0x0004, 0x19e6: 0x0004, 0x19e7: 0x0004, 0x19e8: 0x0004, 0x19e9: 0x0004,
+	0x19ea: 0x0004, 0x19eb: 0x0004, 0x19ec: 0x0004, 0x19ed: 0x0004, 0x19ee: 0x0004, 0x19ef: 0x0004,
+	0x19f0: 0x0004, 0x19f1: 0x0004,
+	0x19ff: 0x0004,
+	// Block 0x68, offset 0x1a00
+	0x1a26: 0x0004, 0x1a27: 0x0004, 0x1a28: 0x0004, 0x1a29: 0x0004,
+	0x1a2a: 0x0004, 0x1a2b: 0x0004, 0x1a2c: 0x0004, 0x1a2d: 0x0004,
+	// Block 0x69, offset 0x1a40
+	0x1a47: 0x0004, 0x1a48: 0x0004, 0x1a49: 0x0004, 0x1a4a: 0x0004, 0x1a4b: 0x0004,
+	0x1a4c: 0x0004, 0x1a4d: 0x0004, 0x1a4e: 0x0004, 0x1a4f: 0x0004, 0x1a50: 0x0004, 0x1a51: 0x0004,
+	0x1a52: 0x0400, 0x1a53: 0x0400,
+	0x1a60: 0x0010, 0x1a61: 0x0010, 0x1a62: 0x0010, 0x1a63: 0x0010,
+	0x1a64: 0x0010, 0x1a65: 0x0010, 0x1a66: 0x0010, 0x1a67: 0x0010, 0x1a68: 0x0010, 0x1a69: 0x0010,
+	0x1a6a: 0x0010, 0x1a6b: 0x0010, 0x1a6c: 0x0010, 0x1a6d: 0x0010, 0x1a6e: 0x0010, 0x1a6f: 0x0010,
+	0x1a70: 0x0010, 0x1a71: 0x0010, 0x1a72: 0x0010, 0x1a73: 0x0010, 0x1a74: 0x0010, 0x1a75: 0x0010,
+	0x1a76: 0x0010, 0x1a77: 0x0010, 0x1a78: 0x0010, 0x1a79: 0x0010, 0x1a7a: 0x0010, 0x1a7b: 0x0010,
+	0x1a7c: 0x0010,
+	// Block 0x6a, offset 0x1a80
+	0x1a80: 0x0004, 0x1a81: 0x0004, 0x1a82: 0x0004, 0x1a83: 0x0400,
+	0x1ab3: 0x0004, 0x1ab4: 0x0400, 0x1ab5: 0x0400,
+	0x1ab6: 0x0004, 0x1ab7: 0x0004, 0x1ab8: 0x0004, 0x1ab9: 0x0004, 0x1aba: 0x0400, 0x1abb: 0x0400,
+	0x1abc: 0x0004, 0x1abd: 0x0004, 0x1abe: 0x0400, 0x1abf: 0x0400,
+	// Block 0x6b, offset 0x1ac0
+	0x1ac0: 0x0400,
+	0x1ae5: 0x0004,
+	// Block 0x6c, offset 0x1b00
+	0x1b29: 0x0004,
+	0x1b2a: 0x0004, 0x1b2b: 0x0004, 0x1b2c: 0x0004, 0x1b2d: 0x0004, 0x1b2e: 0x0004, 0x1b2f: 0x0400,
+	0x1b30: 0x0400, 0x1b31: 0x0004, 0x1b32: 0x0004, 0x1b33: 0x0400, 0x1b34: 0x0400, 0x1b35: 0x0004,
+	0x1b36: 0x0004,
+	// Block 0x6d, offset 0x1b40
+	0x1b43: 0x0004,
+	0x1b4c: 0x0004, 0x1b4d: 0x0400,
+	0x1b7c: 0x0004,
+	// Block 0x6e, offset 0x1b80
+	0x1bb0: 0x0004, 0x1bb2: 0x0004, 0x1bb3: 0x0004, 0x1bb4: 0x0004,
+	0x1bb7: 0x0004, 0x1bb8: 0x0004,
+	0x1bbe: 0x0004, 0x1bbf: 0x0004,
+	// Block 0x6f, offset 0x1bc0
+	0x1bc1: 0x0004,
+	0x1beb: 0x0400, 0x1bec: 0x0004, 0x1bed: 0x0004, 0x1bee: 0x0400, 0x1bef: 0x0400,
+	0x1bf5: 0x0400,
+	0x1bf6: 0x0004,
+	// Block 0x70, offset 0x1c00
+	0x1c23: 0x0400,
+	0x1c24: 0x0400, 0x1c25: 0x0004, 0x1c26: 0x0400, 0x1c27: 0x0400, 0x1c28: 0x0004, 0x1c29: 0x0400,
+	0x1c2a: 0x0400, 0x1c2c: 0x0400, 0x1c2d: 0x0004,
+	// Block 0x71, offset 0x1c40
+	0x1c40: 0x0040, 0x1c41: 0x0080, 0x1c42: 0x0080, 0x1c43: 0x0080, 0x1c44: 0x0080, 0x1c45: 0x0080,
+	0x1c46: 0x0080, 0x1c47: 0x0080, 0x1c48: 0x0080, 0x1c49: 0x0080, 0x1c4a: 0x0080, 0x1c4b: 0x0080,
+	0x1c4c: 0x0080, 0x1c4d: 0x0080, 0x1c4e: 0x0080, 0x1c4f: 0x0080, 0x1c50: 0x0080, 0x1c51: 0x0080,
+	0x1c52: 0x0080, 0x1c53: 0x0080, 0x1c54: 0x0080, 0x1c55: 0x0080, 0x1c56: 0x0080, 0x1c57: 0x0080,
+	0x1c58: 0x0080, 0x1c59: 0x0080, 0x1c5a: 0x0080, 0x1c5b: 0x0080, 0x1c5c: 0x0040, 0x1c5d: 0x0080,
+	0x1c5e: 0x0080, 0x1c5f: 0x0080, 0x1c60: 0x0080, 0x1c61: 0x0080, 0x1c62: 0x0080, 0x1c63: 0x0080,
+	0x1c64: 0x0080, 0x1c65: 0x0080, 0x1c66: 0x0080, 0x1c67: 0x0080, 0x1c68: 0x0080, 0x1c69: 0x0080,
+	0x1c6a: 0x0080, 0x1c6b: 0x0080, 0x1c6c: 0x0080, 0x1c6d: 0x0080, 0x1c6e: 0x0080, 0x1c6f: 0x0080,
+	0x1c70: 0x0080, 0x1c71: 0x0080, 0x1c72: 0x0080, 0x1c73: 0x0080, 0x1c74: 0x0080, 0x1c75: 0x0080,
+	0x1c76: 0x0080, 0x1c77: 0x0080, 0x1c78: 0x0040, 0x1c79: 0x0080, 0x1c7a: 0x0080, 0x1c7b: 0x0080,
+	0x1c7c: 0x0080, 0x1c7d: 0x0080, 0x1c7e: 0x0080, 0x1c7f: 0x0080,
+	// Block 0x72, offset 0x1c80
+	0x1c80: 0x0080, 0x1c81: 0x0080, 0x1c82: 0x0080, 0x1c83: 0x0080, 0x1c84: 0x0080, 0x1c85: 0x0080,
+	0x1c86: 0x0080, 0x1c87: 0x0080, 0x1c88: 0x0080, 0x1c89: 0x0080, 0x1c8a: 0x0080, 0x1c8b: 0x0080,
+	0x1c8c: 0x0080, 0x1c8d: 0x0080, 0x1c8e: 0x0080, 0x1c8f: 0x0080, 0x1c90: 0x0080, 0x1c91: 0x0080,
+	0x1c92: 0x0080, 0x1c93: 0x0080, 0x1c94: 0x0040, 0x1c95: 0x0080, 0x1c96: 0x0080, 0x1c97: 0x0080,
+	0x1c98: 0x0080, 0x1c99: 0x0080, 0x1c9a: 0x0080, 0x1c9b: 0x0080, 0x1c9c: 0x0080, 0x1c9d: 0x0080,
+	0x1c9e: 0x0080, 0x1c9f: 0x0080, 0x1ca0: 0x0080, 0x1ca1: 0x0080, 0x1ca2: 0x0080, 0x1ca3: 0x0080,
+	0x1ca4: 0x0080, 0x1ca5: 0x0080, 0x1ca6: 0x0080, 0x1ca7: 0x0080, 0x1ca8: 0x0080, 0x1ca9: 0x0080,
+	0x1caa: 0x0080, 0x1cab: 0x0080, 0x1cac: 0x0080, 0x1cad: 0x0080, 0x1cae: 0x0080, 0x1caf: 0x0080,
+	0x1cb0: 0x0040, 0x1cb1: 0x0080, 0x1cb2: 0x0080, 0x1cb3: 0x0080, 0x1cb4: 0x0080, 0x1cb5: 0x0080,
+	0x1cb6: 0x0080, 0x1cb7: 0x0080, 0x1cb8: 0x0080, 0x1cb9: 0x0080, 0x1cba: 0x0080, 0x1cbb: 0x0080,
+	0x1cbc: 0x0080, 0x1cbd: 0x0080, 0x1cbe: 0x0080, 0x1cbf: 0x0080,
+	// Block 0x73, offset 0x1cc0
+	0x1cc0: 0x0080, 0x1cc1: 0x0080, 0x1cc2: 0x0080, 0x1cc3: 0x0080, 0x1cc4: 0x0080, 0x1cc5: 0x0080,
+	0x1cc6: 0x0080, 0x1cc7: 0x0080, 0x1cc8: 0x0080, 0x1cc9: 0x0080, 0x1cca: 0x0080, 0x1ccb: 0x0080,
+	0x1ccc: 0x0040, 0x1ccd: 0x0080, 0x1cce: 0x0080, 0x1ccf: 0x0080, 0x1cd0: 0x0080, 0x1cd1: 0x0080,
+	0x1cd2: 0x0080, 0x1cd3: 0x0080, 0x1cd4: 0x0080, 0x1cd5: 0x0080, 0x1cd6: 0x0080, 0x1cd7: 0x0080,
+	0x1cd8: 0x0080, 0x1cd9: 0x0080, 0x1cda: 0x0080, 0x1cdb: 0x0080, 0x1cdc: 0x0080, 0x1cdd: 0x0080,
+	0x1cde: 0x0080, 0x1cdf: 0x0080, 0x1ce0: 0x0080, 0x1ce1: 0x0080, 0x1ce2: 0x0080, 0x1ce3: 0x0080,
+	0x1ce4: 0x0080, 0x1ce5: 0x0080, 0x1ce6: 0x0080, 0x1ce7: 0x0080, 0x1ce8: 0x0040, 0x1ce9: 0x0080,
+	0x1cea: 0x0080, 0x1ceb: 0x0080, 0x1cec: 0x0080, 0x1ced: 0x0080, 0x1cee: 0x0080, 0x1cef: 0x0080,
+	0x1cf0: 0x0080, 0x1cf1: 0x0080, 0x1cf2: 0x0080, 0x1cf3: 0x0080, 0x1cf4: 0x0080, 0x1cf5: 0x0080,
+	0x1cf6: 0x0080, 0x1cf7: 0x0080, 0x1cf8: 0x0080, 0x1cf9: 0x0080, 0x1cfa: 0x0080, 0x1cfb: 0x0080,
+	0x1cfc: 0x0080, 0x1cfd: 0x0080, 0x1cfe: 0x0080, 0x1cff: 0x0080,
+	// Block 0x74, offset 0x1d00
+	0x1d00: 0x0080, 0x1d01: 0x0080, 0x1d02: 0x0080, 0x1d03: 0x0080, 0x1d04: 0x0040, 0x1d05: 0x0080,
+	0x1d06: 0x0080, 0x1d07: 0x0080, 0x1d08: 0x0080, 0x1d09: 0x0080, 0x1d0a: 0x0080, 0x1d0b: 0x0080,
+	0x1d0c: 0x0080, 0x1d0d: 0x0080, 0x1d0e: 0x0080, 0x1d0f: 0x0080, 0x1d10: 0x0080, 0x1d11: 0x0080,
+	0x1d12: 0x0080, 0x1d13: 0x0080, 0x1d14: 0x0080, 0x1d15: 0x0080, 0x1d16: 0x0080, 0x1d17: 0x0080,
+	0x1d18: 0x0080, 0x1d19: 0x0080, 0x1d1a: 0x0080, 0x1d1b: 0x0080, 0x1d1c: 0x0080, 0x1d1d: 0x0080,
+	0x1d1e: 0x0080, 0x1d1f: 0x0080, 0x1d20: 0x0040, 0x1d21: 0x0080, 0x1d22: 0x0080, 0x1d23: 0x0080,
+	0x1d24: 0x0080, 0x1d25: 0x0080, 0x1d26: 0x0080, 0x1d27: 0x0080, 0x1d28: 0x0080, 0x1d29: 0x0080,
+	0x1d2a: 0x0080, 0x1d2b: 0x0080, 0x1d2c: 0x0080, 0x1d2d: 0x0080, 0x1d2e: 0x0080, 0x1d2f: 0x0080,
+	0x1d30: 0x0080, 0x1d31: 0x0080, 0x1d32: 0x0080, 0x1d33: 0x0080, 0x1d34: 0x0080, 0x1d35: 0x0080,
+	0x1d36: 0x0080, 0x1d37: 0x0080, 0x1d38: 0x0080, 0x1d39: 0x0080, 0x1d3a: 0x0080, 0x1d3b: 0x0080,
+	0x1d3c: 0x0040, 0x1d3d: 0x0080, 0x1d3e: 0x0080, 0x1d3f: 0x0080,
+	// Block 0x75, offset 0x1d40
+	0x1d40: 0x0080, 0x1d41: 0x0080, 0x1d42: 0x0080, 0x1d43: 0x0080, 0x1d44: 0x0080, 0x1d45: 0x0080,
+	0x1d46: 0x0080, 0x1d47: 0x0080, 0x1d48: 0x0080, 0x1d49: 0x0080, 0x1d4a: 0x0080, 0x1d4b: 0x0080,
+	0x1d4c: 0x0080, 0x1d4d: 0x0080, 0x1d4e: 0x0080, 0x1d4f: 0x0080, 0x1d50: 0x0080, 0x1d51: 0x0080,
+	0x1d52: 0x0080, 0x1d53: 0x0080, 0x1d54: 0x0080, 0x1d55: 0x0080, 0x1d56: 0x0080, 0x1d57: 0x0080,
+	0x1d58: 0x0040, 0x1d59: 0x0080, 0x1d5a: 0x0080, 0x1d5b: 0x0080, 0x1d5c: 0x0080, 0x1d5d: 0x0080,
+	0x1d5e: 0x0080, 0x1d5f: 0x0080, 0x1d60: 0x0080, 0x1d61: 0x0080, 0x1d62: 0x0080, 0x1d63: 0x0080,
+	0x1d64: 0x0080, 0x1d65: 0x0080, 0x1d66: 0x0080, 0x1d67: 0x0080, 0x1d68: 0x0080, 0x1d69: 0x0080,
+	0x1d6a: 0x0080, 0x1d6b: 0x0080, 0x1d6c: 0x0080, 0x1d6d: 0x0080, 0x1d6e: 0x0080, 0x1d6f: 0x0080,
+	0x1d70: 0x0080, 0x1d71: 0x0080, 0x1d72: 0x0080, 0x1d73: 0x0080, 0x1d74: 0x0040, 0x1d75: 0x0080,
+	0x1d76: 0x0080, 0x1d77: 0x0080, 0x1d78: 0x0080, 0x1d79: 0x0080, 0x1d7a: 0x0080, 0x1d7b: 0x0080,
+	0x1d7c: 0x0080, 0x1d7d: 0x0080, 0x1d7e: 0x0080, 0x1d7f: 0x0080,
+	// Block 0x76, offset 0x1d80
+	0x1d80: 0x0080, 0x1d81: 0x0080, 0x1d82: 0x0080, 0x1d83: 0x0080, 0x1d84: 0x0080, 0x1d85: 0x0080,
+	0x1d86: 0x0080, 0x1d87: 0x0080, 0x1d88: 0x0080, 0x1d89: 0x0080, 0x1d8a: 0x0080, 0x1d8b: 0x0080,
+	0x1d8c: 0x0080, 0x1d8d: 0x0080, 0x1d8e: 0x0080, 0x1d8f: 0x0080, 0x1d90: 0x0040, 0x1d91: 0x0080,
+	0x1d92: 0x0080, 0x1d93: 0x0080, 0x1d94: 0x0080, 0x1d95: 0x0080, 0x1d96: 0x0080, 0x1d97: 0x0080,
+	0x1d98: 0x0080, 0x1d99: 0x0080, 0x1d9a: 0x0080, 0x1d9b: 0x0080, 0x1d9c: 0x0080, 0x1d9d: 0x0080,
+	0x1d9e: 0x0080, 0x1d9f: 0x0080, 0x1da0: 0x0080, 0x1da1: 0x0080, 0x1da2: 0x0080, 0x1da3: 0x0080,
+	0x1da4: 0x0080, 0x1da5: 0x0080, 0x1da6: 0x0080, 0x1da7: 0x0080, 0x1da8: 0x0080, 0x1da9: 0x0080,
+	0x1daa: 0x0080, 0x1dab: 0x0080, 0x1dac: 0x0040, 0x1dad: 0x0080, 0x1dae: 0x0080, 0x1daf: 0x0080,
+	0x1db0: 0x0080, 0x1db1: 0x0080, 0x1db2: 0x0080, 0x1db3: 0x0080, 0x1db4: 0x0080, 0x1db5: 0x0080,
+	0x1db6: 0x0080, 0x1db7: 0x0080, 0x1db8: 0x0080, 0x1db9: 0x0080, 0x1dba: 0x0080, 0x1dbb: 0x0080,
+	0x1dbc: 0x0080, 0x1dbd: 0x0080, 0x1dbe: 0x0080, 0x1dbf: 0x0080,
+	// Block 0x77, offset 0x1dc0
+	0x1dc0: 0x0080, 0x1dc1: 0x0080, 0x1dc2: 0x0080, 0x1dc3: 0x0080, 0x1dc4: 0x0080, 0x1dc5: 0x0080,
+	0x1dc6: 0x0080, 0x1dc7: 0x0080, 0x1dc8: 0x0040, 0x1dc9: 0x0080, 0x1dca: 0x0080, 0x1dcb: 0x0080,
+	0x1dcc: 0x0080, 0x1dcd: 0x0080, 0x1dce: 0x0080, 0x1dcf: 0x0080, 0x1dd0: 0x0080, 0x1dd1: 0x0080,
+	0x1dd2: 0x0080, 0x1dd3: 0x0080, 0x1dd4: 0x0080, 0x1dd5: 0x0080, 0x1dd6: 0x0080, 0x1dd7: 0x0080,
+	0x1dd8: 0x0080, 0x1dd9: 0x0080, 0x1dda: 0x0080, 0x1ddb: 0x0080, 0x1ddc: 0x0080, 0x1ddd: 0x0080,
+	0x1dde: 0x0080, 0x1ddf: 0x0080, 0x1de0: 0x0080, 0x1de1: 0x0080, 0x1de2: 0x0080, 0x1de3: 0x0080,
+	0x1de4: 0x0040, 0x1de5: 0x0080, 0x1de6: 0x0080, 0x1de7: 0x0080, 0x1de8: 0x0080, 0x1de9: 0x0080,
+	0x1dea: 0x0080, 0x1deb: 0x0080, 0x1dec: 0x0080, 0x1ded: 0x0080, 0x1dee: 0x0080, 0x1def: 0x0080,
+	0x1df0: 0x0080, 0x1df1: 0x0080, 0x1df2: 0x0080, 0x1df3: 0x0080, 0x1df4: 0x0080, 0x1df5: 0x0080,
+	0x1df6: 0x0080, 0x1df7: 0x0080, 0x1df8: 0x0080, 0x1df9: 0x0080, 0x1dfa: 0x0080, 0x1dfb: 0x0080,
+	0x1dfc: 0x0080, 0x1dfd: 0x0080, 0x1dfe: 0x0080, 0x1dff: 0x0080,
+	// Block 0x78, offset 0x1e00
+	0x1e00: 0x0080, 0x1e01: 0x0080, 0x1e02: 0x0080, 0x1e03: 0x0080, 0x1e04: 0x0080, 0x1e05: 0x0080,
+	0x1e06: 0x0080, 0x1e07: 0x0080, 0x1e08: 0x0040, 0x1e09: 0x0080, 0x1e0a: 0x0080, 0x1e0b: 0x0080,
+	0x1e0c: 0x0080, 0x1e0d: 0x0080, 0x1e0e: 0x0080, 0x1e0f: 0x0080, 0x1e10: 0x0080, 0x1e11: 0x0080,
+	0x1e12: 0x0080, 0x1e13: 0x0080, 0x1e14: 0x0080, 0x1e15: 0x0080, 0x1e16: 0x0080, 0x1e17: 0x0080,
+	0x1e18: 0x0080, 0x1e19: 0x0080, 0x1e1a: 0x0080, 0x1e1b: 0x0080, 0x1e1c: 0x0080, 0x1e1d: 0x0080,
+	0x1e1e: 0x0080, 0x1e1f: 0x0080, 0x1e20: 0x0080, 0x1e21: 0x0080, 0x1e22: 0x0080, 0x1e23: 0x0080,
+	0x1e30: 0x1000, 0x1e31: 0x1000, 0x1e32: 0x1000, 0x1e33: 0x1000, 0x1e34: 0x1000, 0x1e35: 0x1000,
+	0x1e36: 0x1000, 0x1e37: 0x1000, 0x1e38: 0x1000, 0x1e39: 0x1000, 0x1e3a: 0x1000, 0x1e3b: 0x1000,
+	0x1e3c: 0x1000, 0x1e3d: 0x1000, 0x1e3e: 0x1000, 0x1e3f: 0x1000,
+	// Block 0x79, offset 0x1e40
+	0x1e40: 0x1000, 0x1e41: 0x1000, 0x1e42: 0x1000, 0x1e43: 0x1000, 0x1e44: 0x1000, 0x1e45: 0x1000,
+	0x1e46: 0x1000, 0x1e4b: 0x0800,
+	0x1e4c: 0x0800, 0x1e4d: 0x0800, 0x1e4e: 0x0800, 0x1e4f: 0x0800, 0x1e50: 0x0800, 0x1e51: 0x0800,
+	0x1e52: 0x0800, 0x1e53: 0x0800, 0x1e54: 0x0800, 0x1e55: 0x0800, 0x1e56: 0x0800, 0x1e57: 0x0800,
+	0x1e58: 0x0800, 0x1e59: 0x0800, 0x1e5a: 0x0800, 0x1e5b: 0x0800, 0x1e5c: 0x0800, 0x1e5d: 0x0800,
+	0x1e5e: 0x0800, 0x1e5f: 0x0800, 0x1e60: 0x0800, 0x1e61: 0x0800, 0x1e62: 0x0800, 0x1e63: 0x0800,
+	0x1e64: 0x0800, 0x1e65: 0x0800, 0x1e66: 0x0800, 0x1e67: 0x0800, 0x1e68: 0x0800, 0x1e69: 0x0800,
+	0x1e6a: 0x0800, 0x1e6b: 0x0800, 0x1e6c: 0x0800, 0x1e6d: 0x0800, 0x1e6e: 0x0800, 0x1e6f: 0x0800,
+	0x1e70: 0x0800, 0x1e71: 0x0800, 0x1e72: 0x0800, 0x1e73: 0x0800, 0x1e74: 0x0800, 0x1e75: 0x0800,
+	0x1e76: 0x0800, 0x1e77: 0x0800, 0x1e78: 0x0800, 0x1e79: 0x0800, 0x1e7a: 0x0800, 0x1e7b: 0x0800,
+	// Block 0x7a, offset 0x1e80
+	0x1e9e: 0x0004,
+	// Block 0x7b, offset 0x1ec0
+	0x1ec0: 0x0004, 0x1ec1: 0x0004, 0x1ec2: 0x0004, 0x1ec3: 0x0004, 0x1ec4: 0x0004, 0x1ec5: 0x0004,
+	0x1ec6: 0x0004, 0x1ec7: 0x0004, 0x1ec8: 0x0004, 0x1ec9: 0x0004, 0x1eca: 0x0004, 0x1ecb: 0x0004,
+	0x1ecc: 0x0004, 0x1ecd: 0x0004, 0x1ece: 0x0004, 0x1ecf: 0x0004,
+	0x1ee0: 0x0004, 0x1ee1: 0x0004, 0x1ee2: 0x0004, 0x1ee3: 0x0004,
+	0x1ee4: 0x0004, 0x1ee5: 0x0004, 0x1ee6: 0x0004, 0x1ee7: 0x0004, 0x1ee8: 0x0004, 0x1ee9: 0x0004,
+	0x1eea: 0x0004, 0x1eeb: 0x0004, 0x1eec: 0x0004, 0x1eed: 0x0004, 0x1eee: 0x0004, 0x1eef: 0x0004,
+	// Block 0x7c, offset 0x1f00
+	0x1f3f: 0x0002,
+	// Block 0x7d, offset 0x1f40
+	0x1f70: 0x0002, 0x1f71: 0x0002, 0x1f72: 0x0002, 0x1f73: 0x0002, 0x1f74: 0x0002, 0x1f75: 0x0002,
+	0x1f76: 0x0002, 0x1f77: 0x0002, 0x1f78: 0x0002, 0x1f79: 0x0002, 0x1f7a: 0x0002, 0x1f7b: 0x0002,
+	// Block 0x7e, offset 0x1f80
+	0x1fbd: 0x0004,
+	// Block 0x7f, offset 0x1fc0
+	0x1fe0: 0x0004,
+	// Block 0x80, offset 0x2000
+	0x2036: 0x0004, 0x2037: 0x0004, 0x2038: 0x0004, 0x2039: 0x0004, 0x203a: 0x0004,
+	// Block 0x81, offset 0x2040
+	0x2041: 0x0004, 0x2042: 0x0004, 0x2043: 0x0004, 0x2045: 0x0004,
+	0x2046: 0x0004,
+	0x204c: 0x0004, 0x204d: 0x0004, 0x204e: 0x0004, 0x204f: 0x0004,
+	0x2078: 0x0004, 0x2079: 0x0004, 0x207a: 0x0004,
+	0x207f: 0x0004,
+	// Block 0x82, offset 0x2080
+	0x20a5: 0x0004, 0x20a6: 0x0004,
+	// Block 0x83, offset 0x20c0
+	0x20e4: 0x0004, 0x20e5: 0x0004, 0x20e6: 0x0004, 0x20e7: 0x0004,
+	// Block 0x84, offset 0x2100
+	0x212b: 0x0004, 0x212c: 0x0004,
+	// Block 0x85, offset 0x2140
+	0x217d: 0x0004, 0x217e: 0x0004, 0x217f: 0x0004,
+	// Block 0x86, offset 0x2180
+	0x2186: 0x0004, 0x2187: 0x0004, 0x2188: 0x0004, 0x2189: 0x0004, 0x218a: 0x0004, 0x218b: 0x0004,
+	0x218c: 0x0004, 0x218d: 0x0004, 0x218e: 0x0004, 0x218f: 0x0004, 0x2190: 0x0004,
+	// Block 0x87, offset 0x21c0
+	0x21c2: 0x0004, 0x21c3: 0x0004, 0x21c4: 0x0004, 0x21c5: 0x0004,
+	// Block 0x88, offset 0x2200
+	0x2200: 0x0400, 0x2201: 0x0004, 0x2202: 0x0400,
+	0x2238: 0x0004, 0x2239: 0x0004, 0x223a: 0x0004, 0x223b: 0x0004,
+	0x223c: 0x0004, 0x223d: 0x0004, 0x223e: 0x0004, 0x223f: 0x0004,
+	// Block 0x89, offset 0x2240
+	0x2240: 0x0004, 0x2241: 0x0004, 0x2242: 0x0004, 0x2243: 0x0004, 0x2244: 0x0004, 0x2245: 0x0004,
+	0x2246: 0x0004,
+	0x2270: 0x0004, 0x2273: 0x0004, 0x2274: 0x0004,
+	0x227f: 0x0004,
+	// Block 0x8a, offset 0x2280
+	0x2280: 0x0004, 0x2281: 0x0004, 0x2282: 0x0400,
+	0x22b0: 0x0400, 0x22b1: 0x0400, 0x22b2: 0x0400, 0x22b3: 0x0004, 0x22b4: 0x0004, 0x22b5: 0x0004,
+	0x22b6: 0x0004, 0x22b7: 0x0400, 0x22b8: 0x0400, 0x22b9: 0x0004, 0x22ba: 0x0004,
+	0x22bd: 0x0100,
+	// Block 0x8b, offset 0x22c0
+	0x22c2: 0x0004,
+	0x22cd: 0x0100,
+	// Block 0x8c, offset 0x2300
+	0x2300: 0x0004, 0x2301: 0x0004, 0x2302: 0x0004,
+	0x2327: 0x0004, 0x2328: 0x0004, 0x2329: 0x0004,
+	0x232a: 0x0004, 0x232b: 0x0004, 0x232c: 0x0400, 0x232d: 0x0004, 0x232e: 0x0004, 0x232f: 0x0004,
+	0x2330: 0x0004, 0x2331: 0x0004, 0x2332: 0x0004, 0x2333: 0x0004, 0x2334: 0x0004,
+	// Block 0x8d, offset 0x2340
+	0x2345: 0x0400,
+	0x2346: 0x0400,
+	0x2373: 0x0004,
+	// Block 0x8e, offset 0x2380
+	0x2380: 0x0004, 0x2381: 0x0004, 0x2382: 0x0400,
+	0x23b3: 0x0400, 0x23b4: 0x0400, 0x23b5: 0x0400,
+	0x23b6: 0x0004, 0x23b7: 0x0004, 0x23b8: 0x0004, 0x23b9: 0x0004, 0x23ba: 0x0004, 0x23bb: 0x0004,
+	0x23bc: 0x0004, 0x23bd: 0x0004, 0x23be: 0x0004, 0x23bf: 0x0400,
+	// Block 0x8f, offset 0x23c0
+	0x23c0: 0x0400, 0x23c2: 0x0100, 0x23c3: 0x0100,
+	0x23c9: 0x0004, 0x23ca: 0x0004, 0x23cb: 0x0004,
+	0x23cc: 0x0004, 0x23ce: 0x0400, 0x23cf: 0x0004,
+	// Block 0x90, offset 0x2400
+	0x242c: 0x0400, 0x242d: 0x0400, 0x242e: 0x0400, 0x242f: 0x0004,
+	0x2430: 0x0004, 0x2431: 0x0004, 0x2432: 0x0400, 0x2433: 0x0400, 0x2434: 0x0004, 0x2435: 0x0400,
+	0x2436: 0x0004, 0x2437: 0x0004,
+	0x243e: 0x0004,
+	// Block 0x91, offset 0x2440
+	0x2441: 0x0004,
+	// Block 0x92, offset 0x2480
+	0x249f: 0x0004, 0x24a0: 0x0400, 0x24a1: 0x0400, 0x24a2: 0x0400, 0x24a3: 0x0004,
+	0x24a4: 0x0004, 0x24a5: 0x0004, 0x24a6: 0x0004, 0x24a7: 0x0004, 0x24a8: 0x0004, 0x24a9: 0x0004,
+	0x24aa: 0x0004,
+	// Block 0x93, offset 0x24c0
+	0x24c0: 0x0004, 0x24c1: 0x0400, 0x24c2: 0x0400, 0x24c3: 0x0400, 0x24c4: 0x0400,
+	0x24c7: 0x0400, 0x24c8: 0x0400, 0x24cb: 0x0400,
+	0x24cc: 0x0400, 0x24cd: 0x0400,
+	0x24d7: 0x0004,
+	0x24e2: 0x0400, 0x24e3: 0x0400,
+	0x24e6: 0x0004, 0x24e7: 0x0004, 0x24e8: 0x0004, 0x24e9: 0x0004,
+	0x24ea: 0x0004, 0x24eb: 0x0004, 0x24ec: 0x0004,
+	0x24f0: 0x0004, 0x24f1: 0x0004, 0x24f2: 0x0004, 0x24f3: 0x0004, 0x24f4: 0x0004,
+	// Block 0x94, offset 0x2500
+	0x2535: 0x0400,
+	0x2536: 0x0400, 0x2537: 0x0400, 0x2538: 0x0004, 0x2539: 0x0004, 0x253a: 0x0004, 0x253b: 0x0004,
+	0x253c: 0x0004, 0x253d: 0x0004, 0x253e: 0x0004, 0x253f: 0x0004,
+	// Block 0x95, offset 0x2540
+	0x2540: 0x0400, 0x2541: 0x0400, 0x2542: 0x0004, 0x2543: 0x0004, 0x2544: 0x0004, 0x2545: 0x0400,
+	0x2546: 0x0004,
+	0x255e: 0x0004,
+	// Block 0x96, offset 0x2580
+	0x25b0: 0x0004, 0x25b1: 0x0400, 0x25b2: 0x0400, 0x25b3: 0x0004, 0x25b4: 0x0004, 0x25b5: 0x0004,
+	0x25b6: 0x0004, 0x25b7: 0x0004, 0x25b8: 0x0004, 0x25b9: 0x0400, 0x25ba: 0x0004, 0x25bb: 0x0400,
+	0x25bc: 0x0400, 0x25bd: 0x0004, 0x25be: 0x0400, 0x25bf: 0x0004,
+	// Block 0x97, offset 0x25c0
+	0x25c0: 0x0004, 0x25c1: 0x0400, 0x25c2: 0x0004, 0x25c3: 0x0004,
+	// Block 0x98, offset 0x2600
+	0x262f: 0x0004,
+	0x2630: 0x0400, 0x2631: 0x0400, 0x2632: 0x0004, 0x2633: 0x0004, 0x2634: 0x0004, 0x2635: 0x0004,
+	0x2638: 0x0400, 0x2639: 0x0400, 0x263a: 0x0400, 0x263b: 0x0400,
+	0x263c: 0x0004, 0x263d: 0x0004, 0x263e: 0x0400, 0x263f: 0x0004,
+	// Block 0x99, offset 0x2640
+	0x2640: 0x0004,
+	0x265c: 0x0004, 0x265d: 0x0004,
+	// Block 0x9a, offset 0x2680
+	0x26b0: 0x0400, 0x26b1: 0x0400, 0x26b2: 0x0400, 0x26b3: 0x0004, 0x26b4: 0x0004, 0x26b5: 0x0004,
+	0x26b6: 0x0004, 0x26b7: 0x0004, 0x26b8: 0x0004, 0x26b9: 0x0004, 0x26ba: 0x0004, 0x26bb: 0x0400,
+	0x26bc: 0x0400, 0x26bd: 0x0004, 0x26be: 0x0400, 0x26bf: 0x0004,
+	// Block 0x9b, offset 0x26c0
+	0x26c0: 0x0004,
+	// Block 0x9c, offset 0x2700
+	0x272b: 0x0004, 0x272c: 0x0400, 0x272d: 0x0004, 0x272e: 0x0400, 0x272f: 0x0400,
+	0x2730: 0x0004, 0x2731: 0x0004, 0x2732: 0x0004, 0x2733: 0x0004, 0x2734: 0x0004, 0x2735: 0x0004,
+	0x2736: 0x0400, 0x2737: 0x0004,
+	// Block 0x9d, offset 0x2740
+	0x275d: 0x0004,
+	0x275e: 0x0004, 0x275f: 0x0004, 0x2762: 0x0004, 0x2763: 0x0004,
+	0x2764: 0x0004, 0x2765: 0x0004, 0x2766: 0x0400, 0x2767: 0x0004, 0x2768: 0x0004, 0x2769: 0x0004,
+	0x276a: 0x0004, 0x276b: 0x0004,
+	// Block 0x9e, offset 0x2780
+	0x27ac: 0x0400, 0x27ad: 0x0400, 0x27ae: 0x0400, 0x27af: 0x0004,
+	0x27b0: 0x0004, 0x27b1: 0x0004, 0x27b2: 0x0004, 0x27b3: 0x0004, 0x27b4: 0x0004, 0x27b5: 0x0004,
+	0x27b6: 0x0004, 0x27b7: 0x0004, 0x27b8: 0x0400, 0x27b9: 0x0004, 0x27ba: 0x0004,
+	// Block 0x9f, offset 0x27c0
+	0x27f0: 0x0004, 0x27f1: 0x0400, 0x27f2: 0x0400, 0x27f3: 0x0400, 0x27f4: 0x0400, 0x27f5: 0x0400,
+	0x27f7: 0x0400, 0x27f8: 0x0400, 0x27fb: 0x0004,
+	0x27fc: 0x0004, 0x27fd: 0x0400, 0x27fe: 0x0004, 0x27ff: 0x0100,
+	// Block 0xa0, offset 0x2800
+	0x2800: 0x0400, 0x2801: 0x0100, 0x2802: 0x0400, 0x2803: 0x0004,
+	// Block 0xa1, offset 0x2840
+	0x2851: 0x0400,
+	0x2852: 0x0400, 0x2853: 0x0400, 0x2854: 0x0004, 0x2855: 0x0004, 0x2856: 0x0004, 0x2857: 0x0004,
+	0x285a: 0x0004, 0x285b: 0x0004, 0x285c: 0x0400, 0x285d: 0x0400,
+	0x285e: 0x0400, 0x285f: 0x0400, 0x2860: 0x0004,
+	0x2864: 0x0400,
+	// Block 0xa2, offset 0x2880
+	0x2881: 0x0004, 0x2882: 0x0004, 0x2883: 0x0004, 0x2884: 0x0004, 0x2885: 0x0004,
+	0x2886: 0x0004, 0x2887: 0x0004, 0x2888: 0x0004, 0x2889: 0x0004, 0x288a: 0x0004,
+	0x28b3: 0x0004, 0x28b4: 0x0004, 0x28b5: 0x0004,
+	0x28b6: 0x0004, 0x28b7: 0x0004, 0x28b8: 0x0004, 0x28b9: 0x0400, 0x28ba: 0x0100, 0x28bb: 0x0004,
+	0x28bc: 0x0004, 0x28bd: 0x0004, 0x28be: 0x0004,
+	// Block 0xa3, offset 0x28c0
+	0x28c7: 0x0004,
+	0x28d1: 0x0004,
+	0x28d2: 0x0004, 0x28d3: 0x0004, 0x28d4: 0x0004, 0x28d5: 0x0004, 0x28d6: 0x0004, 0x28d7: 0x0400,
+	0x28d8: 0x0400, 0x28d9: 0x0004, 0x28da: 0x0004, 0x28db: 0x0004,
+	// Block 0xa4, offset 0x2900
+	0x2904: 0x0100, 0x2905: 0x0100,
+	0x2906: 0x0100, 0x2907: 0x0100, 0x2908: 0x0100, 0x2909: 0x0100, 0x290a: 0x0004, 0x290b: 0x0004,
+	0x290c: 0x0004, 0x290d: 0x0004, 0x290e: 0x0004, 0x290f: 0x0004, 0x2910: 0x0004, 0x2911: 0x0004,
+	0x2912: 0x0004, 0x2913: 0x0004, 0x2914: 0x0004, 0x2915: 0x0004, 0x2916: 0x0004, 0x2917: 0x0400,
+	0x2918: 0x0004, 0x2919: 0x0004,
+	// Block 0xa5, offset 0x2940
+	0x296f: 0x0400,
+	0x2970: 0x0004, 0x2971: 0x0004, 0x2972: 0x0004, 0x2973: 0x0004, 0x2974: 0x0004, 0x2975: 0x0004,
+	0x2976: 0x0004, 0x2978: 0x0004, 0x2979: 0x0004, 0x297a: 0x0004, 0x297b: 0x0004,
+	0x297c: 0x0004, 0x297d: 0x0004, 0x297e: 0x0400, 0x297f: 0x0004,
+	// Block 0xa6, offset 0x2980
+	0x2992: 0x0004, 0x2993: 0x0004, 0x2994: 0x0004, 0x2995: 0x0004, 0x2996: 0x0004, 0x2997: 0x0004,
+	0x2998: 0x0004, 0x2999: 0x0004, 0x299a: 0x0004, 0x299b: 0x0004, 0x299c: 0x0004, 0x299d: 0x0004,
+	0x299e: 0x0004, 0x299f: 0x0004, 0x29a0: 0x0004, 0x29a1: 0x0004, 0x29a2: 0x0004, 0x29a3: 0x0004,
+	0x29a4: 0x0004, 0x29a5: 0x0004, 0x29a6: 0x0004, 0x29a7: 0x0004, 0x29a9: 0x0400,
+	0x29aa: 0x0004, 0x29ab: 0x0004, 0x29ac: 0x0004, 0x29ad: 0x0004, 0x29ae: 0x0004, 0x29af: 0x0004,
+	0x29b0: 0x0004, 0x29b1: 0x0400, 0x29b2: 0x0004, 0x29b3: 0x0004, 0x29b4: 0x0400, 0x29b5: 0x0004,
+	0x29b6: 0x0004,
+	// Block 0xa7, offset 0x29c0
+	0x29f1: 0x0004, 0x29f2: 0x0004, 0x29f3: 0x0004, 0x29f4: 0x0004, 0x29f5: 0x0004,
+	0x29f6: 0x0004, 0x29fa: 0x0004,
+	0x29fc: 0x0004, 0x29fd: 0x0004, 0x29ff: 0x0004,
+	// Block 0xa8, offset 0x2a00
+	0x2a00: 0x0004, 0x2a01: 0x0004, 0x2a02: 0x0004, 0x2a03: 0x0004, 0x2a04: 0x0004, 0x2a05: 0x0004,
+	0x2a06: 0x0100, 0x2a07: 0x0004,
+	// Block 0xa9, offset 0x2a40
+	0x2a4a: 0x0400, 0x2a4b: 0x0400,
+	0x2a4c: 0x0400, 0x2a4d: 0x0400, 0x2a4e: 0x0400, 0x2a50: 0x0004, 0x2a51: 0x0004,
+	0x2a53: 0x0400, 0x2a54: 0x0400, 0x2a55: 0x0004, 0x2a56: 0x0400, 0x2a57: 0x0004,
+	// Block 0xaa, offset 0x2a80
+	0x2ab3: 0x0004, 0x2ab4: 0x0004, 0x2ab5: 0x0400,
+	0x2ab6: 0x0400,
+	// Block 0xab, offset 0x2ac0
+	0x2ac0: 0x0004, 0x2ac1: 0x0004, 0x2ac2: 0x0100, 0x2ac3: 0x0400,
+	0x2af4: 0x0400, 0x2af5: 0x0400,
+	0x2af6: 0x0004, 0x2af7: 0x0004, 0x2af8: 0x0004, 0x2af9: 0x0004, 0x2afa: 0x0004,
+	0x2afe: 0x0400, 0x2aff: 0x0400,
+	// Block 0xac, offset 0x2b00
+	0x2b00: 0x0004, 0x2b01: 0x0400, 0x2b02: 0x0004,
+	// Block 0xad, offset 0x2b40
+	0x2b70: 0x0002, 0x2b71: 0x0002, 0x2b72: 0x0002, 0x2b73: 0x0002, 0x2b74: 0x0002, 0x2b75: 0x0002,
+	0x2b76: 0x0002, 0x2b77: 0x0002, 0x2b78: 0x0002, 0x2b79: 0x0002, 0x2b7a: 0x0002, 0x2b7b: 0x0002,
+	0x2b7c: 0x0002, 0x2b7d: 0x0002, 0x2b7e: 0x0002, 0x2b7f: 0x0002,
+	// Block 0xae, offset 0x2b80
+	0x2b80: 0x0004,
+	0x2b87: 0x0004, 0x2b88: 0x0004, 0x2b89: 0x0004, 0x2b8a: 0x0004, 0x2b8b: 0x0004,
+	0x2b8c: 0x0004, 0x2b8d: 0x0004, 0x2b8e: 0x0004, 0x2b8f: 0x0004, 0x2b90: 0x0004, 0x2b91: 0x0004,
+	0x2b92: 0x0004, 0x2b93: 0x0004, 0x2b94: 0x0004, 0x2b95: 0x0004,
+	// Block 0xaf, offset 0x2bc0
+	0x2bf0: 0x0004, 0x2bf1: 0x0004, 0x2bf2: 0x0004, 0x2bf3: 0x0004, 0x2bf4: 0x0004,
+	// Block 0xb0, offset 0x2c00
+	0x2c30: 0x0004, 0x2c31: 0x0004, 0x2c32: 0x0004, 0x2c33: 0x0004, 0x2c34: 0x0004, 0x2c35: 0x0004,
+	0x2c36: 0x0004,
+	// Block 0xb1, offset 0x2c40
+	0x2c4f: 0x0004, 0x2c51: 0x0400,
+	0x2c52: 0x0400, 0x2c53: 0x0400, 0x2c54: 0x0400, 0x2c55: 0x0400, 0x2c56: 0x0400, 0x2c57: 0x0400,
+	0x2c58: 0x0400, 0x2c59: 0x0400, 0x2c5a: 0x0400, 0x2c5b: 0x0400, 0x2c5c: 0x0400, 0x2c5d: 0x0400,
+	0x2c5e: 0x0400, 0x2c5f: 0x0400, 0x2c60: 0x0400, 0x2c61: 0x0400, 0x2c62: 0x0400, 0x2c63: 0x0400,
+	0x2c64: 0x0400, 0x2c65: 0x0400, 0x2c66: 0x0400, 0x2c67: 0x0400, 0x2c68: 0x0400, 0x2c69: 0x0400,
+	0x2c6a: 0x0400, 0x2c6b: 0x0400, 0x2c6c: 0x0400, 0x2c6d: 0x0400, 0x2c6e: 0x0400, 0x2c6f: 0x0400,
+	0x2c70: 0x0400, 0x2c71: 0x0400, 0x2c72: 0x0400, 0x2c73: 0x0400, 0x2c74: 0x0400, 0x2c75: 0x0400,
+	0x2c76: 0x0400, 0x2c77: 0x0400, 0x2c78: 0x0400, 0x2c79: 0x0400, 0x2c7a: 0x0400, 0x2c7b: 0x0400,
+	0x2c7c: 0x0400, 0x2c7d: 0x0400, 0x2c7e: 0x0400, 0x2c7f: 0x0400,
+	// Block 0xb2, offset 0x2c80
+	0x2c80: 0x0400, 0x2c81: 0x0400, 0x2c82: 0x0400, 0x2c83: 0x0400, 0x2c84: 0x0400, 0x2c85: 0x0400,
+	0x2c86: 0x0400, 0x2c87: 0x0400,
+	0x2c8f: 0x0004, 0x2c90: 0x0004, 0x2c91: 0x0004,
+	0x2c92: 0x0004,
+	// Block 0xb3, offset 0x2cc0
+	0x2ce4: 0x0004,
+	0x2cf0: 0x0400, 0x2cf1: 0x0400,
+	// Block 0xb4, offset 0x2d00
+	0x2d1d: 0x0004,
+	0x2d1e: 0x0004, 0x2d20: 0x0002, 0x2d21: 0x0002, 0x2d22: 0x0002, 0x2d23: 0x0002,
+	// Block 0xb5, offset 0x2d40
+	0x2d40: 0x0004, 0x2d41: 0x0004, 0x2d42: 0x0004, 0x2d43: 0x0004, 0x2d44: 0x0004, 0x2d45: 0x0004,
+	0x2d46: 0x0004, 0x2d47: 0x0004, 0x2d48: 0x0004, 0x2d49: 0x0004, 0x2d4a: 0x0004, 0x2d4b: 0x0004,
+	0x2d4c: 0x0004, 0x2d4d: 0x0004, 0x2d4e: 0x0004, 0x2d4f: 0x0004, 0x2d50: 0x0004, 0x2d51: 0x0004,
+	0x2d52: 0x0004, 0x2d53: 0x0004, 0x2d54: 0x0004, 0x2d55: 0x0004, 0x2d56: 0x0004, 0x2d57: 0x0004,
+	0x2d58: 0x0004, 0x2d59: 0x0004, 0x2d5a: 0x0004, 0x2d5b: 0x0004, 0x2d5c: 0x0004, 0x2d5d: 0x0004,
+	0x2d5e: 0x0004, 0x2d5f: 0x0004, 0x2d60: 0x0004, 0x2d61: 0x0004, 0x2d62: 0x0004, 0x2d63: 0x0004,
+	0x2d64: 0x0004, 0x2d65: 0x0004, 0x2d66: 0x0004, 0x2d67: 0x0004, 0x2d68: 0x0004, 0x2d69: 0x0004,
+	0x2d6a: 0x0004, 0x2d6b: 0x0004, 0x2d6c: 0x0004, 0x2d6d: 0x0004,
+	0x2d70: 0x0004, 0x2d71: 0x0004, 0x2d72: 0x0004, 0x2d73: 0x0004, 0x2d74: 0x0004, 0x2d75: 0x0004,
+	0x2d76: 0x0004, 0x2d77: 0x0004, 0x2d78: 0x0004, 0x2d79: 0x0004, 0x2d7a: 0x0004, 0x2d7b: 0x0004,
+	0x2d7c: 0x0004, 0x2d7d: 0x0004, 0x2d7e: 0x0004, 0x2d7f: 0x0004,
+	// Block 0xb6, offset 0x2d80
+	0x2d80: 0x0004, 0x2d81: 0x0004, 0x2d82: 0x0004, 0x2d83: 0x0004, 0x2d84: 0x0004, 0x2d85: 0x0004,
+	0x2d86: 0x0004,
+	// Block 0xb7, offset 0x2dc0
+	0x2de5: 0x0004, 0x2de6: 0x0400, 0x2de7: 0x0004, 0x2de8: 0x0004, 0x2de9: 0x0004,
+	0x2ded: 0x0400, 0x2dee: 0x0004, 0x2def: 0x0004,
+	0x2df0: 0x0004, 0x2df1: 0x0004, 0x2df2: 0x0004, 0x2df3: 0x0002, 0x2df4: 0x0002, 0x2df5: 0x0002,
+	0x2df6: 0x0002, 0x2df7: 0x0002, 0x2df8: 0x0002, 0x2df9: 0x0002, 0x2dfa: 0x0002, 0x2dfb: 0x0004,
+	0x2dfc: 0x0004, 0x2dfd: 0x0004, 0x2dfe: 0x0004, 0x2dff: 0x0004,
+	// Block 0xb8, offset 0x2e00
+	0x2e00: 0x0004, 0x2e01: 0x0004, 0x2e02: 0x0004, 0x2e05: 0x0004,
+	0x2e06: 0x0004, 0x2e07: 0x0004, 0x2e08: 0x0004, 0x2e09: 0x0004, 0x2e0a: 0x0004, 0x2e0b: 0x0004,
+	0x2e2a: 0x0004, 0x2e2b: 0x0004, 0x2e2c: 0x0004, 0x2e2d: 0x0004,
+	// Block 0xb9, offset 0x2e40
+	0x2e42: 0x0004, 0x2e43: 0x0004, 0x2e44: 0x0004,
+	// Block 0xba, offset 0x2e80
+	0x2e80: 0x0004, 0x2e81: 0x0004, 0x2e82: 0x0004, 0x2e83: 0x0004, 0x2e84: 0x0004, 0x2e85: 0x0004,
+	0x2e86: 0x0004, 0x2e87: 0x0004, 0x2e88: 0x0004, 0x2e89: 0x0004, 0x2e8a: 0x0004, 0x2e8b: 0x0004,
+	0x2e8c: 0x0004, 0x2e8d: 0x0004, 0x2e8e: 0x0004, 0x2e8f: 0x0004, 0x2e90: 0x0004, 0x2e91: 0x0004,
+	0x2e92: 0x0004, 0x2e93: 0x0004, 0x2e94: 0x0004, 0x2e95: 0x0004, 0x2e96: 0x0004, 0x2e97: 0x0004,
+	0x2e98: 0x0004, 0x2e99: 0x0004, 0x2e9a: 0x0004, 0x2e9b: 0x0004, 0x2e9c: 0x0004, 0x2e9d: 0x0004,
+	0x2e9e: 0x0004, 0x2e9f: 0x0004, 0x2ea0: 0x0004, 0x2ea1: 0x0004, 0x2ea2: 0x0004, 0x2ea3: 0x0004,
+	0x2ea4: 0x0004, 0x2ea5: 0x0004, 0x2ea6: 0x0004, 0x2ea7: 0x0004, 0x2ea8: 0x0004, 0x2ea9: 0x0004,
+	0x2eaa: 0x0004, 0x2eab: 0x0004, 0x2eac: 0x0004, 0x2ead: 0x0004, 0x2eae: 0x0004, 0x2eaf: 0x0004,
+	0x2eb0: 0x0004, 0x2eb1: 0x0004, 0x2eb2: 0x0004, 0x2eb3: 0x0004, 0x2eb4: 0x0004, 0x2eb5: 0x0004,
+	0x2eb6: 0x0004, 0x2ebb: 0x0004,
+	0x2ebc: 0x0004, 0x2ebd: 0x0004, 0x2ebe: 0x0004, 0x2ebf: 0x0004,
+	// Block 0xbb, offset 0x2ec0
+	0x2ec0: 0x0004, 0x2ec1: 0x0004, 0x2ec2: 0x0004, 0x2ec3: 0x0004, 0x2ec4: 0x0004, 0x2ec5: 0x0004,
+	0x2ec6: 0x0004, 0x2ec7: 0x0004, 0x2ec8: 0x0004, 0x2ec9: 0x0004, 0x2eca: 0x0004, 0x2ecb: 0x0004,
+	0x2ecc: 0x0004, 0x2ecd: 0x0004, 0x2ece: 0x0004, 0x2ecf: 0x0004, 0x2ed0: 0x0004, 0x2ed1: 0x0004,
+	0x2ed2: 0x0004, 0x2ed3: 0x0004, 0x2ed4: 0x0004, 0x2ed5: 0x0004, 0x2ed6: 0x0004, 0x2ed7: 0x0004,
+	0x2ed8: 0x0004, 0x2ed9: 0x0004, 0x2eda: 0x0004, 0x2edb: 0x0004, 0x2edc: 0x0004, 0x2edd: 0x0004,
+	0x2ede: 0x0004, 0x2edf: 0x0004, 0x2ee0: 0x0004, 0x2ee1: 0x0004, 0x2ee2: 0x0004, 0x2ee3: 0x0004,
+	0x2ee4: 0x0004, 0x2ee5: 0x0004, 0x2ee6: 0x0004, 0x2ee7: 0x0004, 0x2ee8: 0x0004, 0x2ee9: 0x0004,
+	0x2eea: 0x0004, 0x2eeb: 0x0004, 0x2eec: 0x0004,
+	0x2ef5: 0x0004,
+	// Block 0xbc, offset 0x2f00
+	0x2f04: 0x0004,
+	0x2f1b: 0x0004, 0x2f1c: 0x0004, 0x2f1d: 0x0004,
+	0x2f1e: 0x0004, 0x2f1f: 0x0004, 0x2f21: 0x0004, 0x2f22: 0x0004, 0x2f23: 0x0004,
+	0x2f24: 0x0004, 0x2f25: 0x0004, 0x2f26: 0x0004, 0x2f27: 0x0004, 0x2f28: 0x0004, 0x2f29: 0x0004,
+	0x2f2a: 0x0004, 0x2f2b: 0x0004, 0x2f2c: 0x0004, 0x2f2d: 0x0004, 0x2f2e: 0x0004, 0x2f2f: 0x0004,
+	// Block 0xbd, offset 0x2f40
+	0x2f40: 0x0004, 0x2f41: 0x0004, 0x2f42: 0x0004, 0x2f43: 0x0004, 0x2f44: 0x0004, 0x2f45: 0x0004,
+	0x2f46: 0x0004, 0x2f48: 0x0004, 0x2f49: 0x0004, 0x2f4a: 0x0004, 0x2f4b: 0x0004,
+	0x2f4c: 0x0004, 0x2f4d: 0x0004, 0x2f4e: 0x0004, 0x2f4f: 0x0004, 0x2f50: 0x0004, 0x2f51: 0x0004,
+	0x2f52: 0x0004, 0x2f53: 0x0004, 0x2f54: 0x0004, 0x2f55: 0x0004, 0x2f56: 0x0004, 0x2f57: 0x0004,
+	0x2f58: 0x0004, 0x2f5b: 0x0004, 0x2f5c: 0x0004, 0x2f5d: 0x0004,
+	0x2f5e: 0x0004, 0x2f5f: 0x0004, 0x2f60: 0x0004, 0x2f61: 0x0004, 0x2f63: 0x0004,
+	0x2f64: 0x0004, 0x2f66: 0x0004, 0x2f67: 0x0004, 0x2f68: 0x0004, 0x2f69: 0x0004,
+	0x2f6a: 0x0004,
+	// Block 0xbe, offset 0x2f80
+	0x2f8f: 0x0004,
+	// Block 0xbf, offset 0x2fc0
+	0x2fee: 0x0004,
+	// Block 0xc0, offset 0x3000
+	0x302c: 0x0004, 0x302d: 0x0004, 0x302e: 0x0004, 0x302f: 0x0004,
+	// Block 0xc1, offset 0x3040
+	0x3050: 0x0004, 0x3051: 0x0004,
+	0x3052: 0x0004, 0x3053: 0x0004, 0x3054: 0x0004, 0x3055: 0x0004, 0x3056: 0x0004,
+	// Block 0xc2, offset 0x3080
+	0x3084: 0x0004, 0x3085: 0x0004,
+	0x3086: 0x0004, 0x3087: 0x0004, 0x3088: 0x0004, 0x3089: 0x0004, 0x308a: 0x0004,
+	// Block 0xc3, offset 0x30c0
+	0x30cd: 0x0008, 0x30ce: 0x0008, 0x30cf: 0x0008,
+	0x30ef: 0x0008,
+	// Block 0xc4, offset 0x3100
+	0x312c: 0x0008, 0x312d: 0x0008, 0x312e: 0x0008, 0x312f: 0x0008,
+	0x3130: 0x0008, 0x3131: 0x0008,
+	0x313e: 0x0008, 0x313f: 0x0008,
+	// Block 0xc5, offset 0x3140
+	0x314e: 0x0008, 0x3151: 0x0008,
+	0x3152: 0x0008, 0x3153: 0x0008, 0x3154: 0x0008, 0x3155: 0x0008, 0x3156: 0x0008, 0x3157: 0x0008,
+	0x3158: 0x0008, 0x3159: 0x0008, 0x315a: 0x0008,
+	0x316d: 0x0008, 0x316e: 0x0008, 0x316f: 0x0008,
+	0x3170: 0x0008, 0x3171: 0x0008, 0x3172: 0x0008, 0x3173: 0x0008, 0x3174: 0x0008, 0x3175: 0x0008,
+	0x3176: 0x0008, 0x3177: 0x0008, 0x3178: 0x0008, 0x3179: 0x0008, 0x317a: 0x0008, 0x317b: 0x0008,
+	0x317c: 0x0008, 0x317d: 0x0008, 0x317e: 0x0008, 0x317f: 0x0008,
+	// Block 0xc6, offset 0x3180
+	0x3180: 0x0008, 0x3181: 0x0008, 0x3182: 0x0008, 0x3183: 0x0008, 0x3184: 0x0008, 0x3185: 0x0008,
+	0x3186: 0x0008, 0x3187: 0x0008, 0x3188: 0x0008, 0x3189: 0x0008, 0x318a: 0x0008, 0x318b: 0x0008,
+	0x318c: 0x0008, 0x318d: 0x0008, 0x318e: 0x0008, 0x318f: 0x0008, 0x3190: 0x0008, 0x3191: 0x0008,
+	0x3192: 0x0008, 0x3193: 0x0008, 0x3194: 0x0008, 0x3195: 0x0008, 0x3196: 0x0008, 0x3197: 0x0008,
+	0x3198: 0x0008, 0x3199: 0x0008, 0x319a: 0x0008, 0x319b: 0x0008, 0x319c: 0x0008, 0x319d: 0x0008,
+	0x319e: 0x0008, 0x319f: 0x0008, 0x31a0: 0x0008, 0x31a1: 0x0008, 0x31a2: 0x0008, 0x31a3: 0x0008,
+	0x31a4: 0x0008, 0x31a5: 0x0008, 0x31a6: 0x0200, 0x31a7: 0x0200, 0x31a8: 0x0200, 0x31a9: 0x0200,
+	0x31aa: 0x0200, 0x31ab: 0x0200, 0x31ac: 0x0200, 0x31ad: 0x0200, 0x31ae: 0x0200, 0x31af: 0x0200,
+	0x31b0: 0x0200, 0x31b1: 0x0200, 0x31b2: 0x0200, 0x31b3: 0x0200, 0x31b4: 0x0200, 0x31b5: 0x0200,
+	0x31b6: 0x0200, 0x31b7: 0x0200, 0x31b8: 0x0200, 0x31b9: 0x0200, 0x31ba: 0x0200, 0x31bb: 0x0200,
+	0x31bc: 0x0200, 0x31bd: 0x0200, 0x31be: 0x0200, 0x31bf: 0x0200,
+	// Block 0xc7, offset 0x31c0
+	0x31c1: 0x0008, 0x31c2: 0x0008, 0x31c3: 0x0008, 0x31c4: 0x0008, 0x31c5: 0x0008,
+	0x31c6: 0x0008, 0x31c7: 0x0008, 0x31c8: 0x0008, 0x31c9: 0x0008, 0x31ca: 0x0008, 0x31cb: 0x0008,
+	0x31cc: 0x0008, 0x31cd: 0x0008, 0x31ce: 0x0008, 0x31cf: 0x0008,
+	0x31da: 0x0008,
+	0x31ef: 0x0008,
+	0x31f2: 0x0008, 0x31f3: 0x0008, 0x31f4: 0x0008, 0x31f5: 0x0008,
+	0x31f6: 0x0008, 0x31f7: 0x0008, 0x31f8: 0x0008, 0x31f9: 0x0008, 0x31fa: 0x0008,
+	0x31fc: 0x0008, 0x31fd: 0x0008, 0x31fe: 0x0008, 0x31ff: 0x0008,
+	// Block 0xc8, offset 0x3200
+	0x3209: 0x0008, 0x320a: 0x0008, 0x320b: 0x0008,
+	0x320c: 0x0008, 0x320d: 0x0008, 0x320e: 0x0008, 0x320f: 0x0008, 0x3210: 0x0008, 0x3211: 0x0008,
+	0x3212: 0x0008, 0x3213: 0x0008, 0x3214: 0x0008, 0x3215: 0x0008, 0x3216: 0x0008, 0x3217: 0x0008,
+	0x3218: 0x0008, 0x3219: 0x0008, 0x321a: 0x0008, 0x321b: 0x0008, 0x321c: 0x0008, 0x321d: 0x0008,
+	0x321e: 0x0008, 0x321f: 0x0008, 0x3220: 0x0008, 0x3221: 0x0008, 0x3222: 0x0008, 0x3223: 0x0008,
+	0x3224: 0x0008, 0x3225: 0x0008, 0x3226: 0x0008, 0x3227: 0x0008, 0x3228: 0x0008, 0x3229: 0x0008,
+	0x322a: 0x0008, 0x322b: 0x0008, 0x322c: 0x0008, 0x322d: 0x0008, 0x322e: 0x0008, 0x322f: 0x0008,
+	0x3230: 0x0008, 0x3231: 0x0008, 0x3232: 0x0008, 0x3233: 0x0008, 0x3234: 0x0008, 0x3235: 0x0008,
+	0x3236: 0x0008, 0x3237: 0x0008, 0x3238: 0x0008, 0x3239: 0x0008, 0x323a: 0x0008, 0x323b: 0x0008,
+	0x323c: 0x0008, 0x323d: 0x0008, 0x323e: 0x0008, 0x323f: 0x0008,
+	// Block 0xc9, offset 0x3240
+	0x3240: 0x0008, 0x3241: 0x0008, 0x3242: 0x0008, 0x3243: 0x0008, 0x3244: 0x0008, 0x3245: 0x0008,
+	0x3246: 0x0008, 0x3247: 0x0008, 0x3248: 0x0008, 0x3249: 0x0008, 0x324a: 0x0008, 0x324b: 0x0008,
+	0x324c: 0x0008, 0x324d: 0x0008, 0x324e: 0x0008, 0x324f: 0x0008, 0x3250: 0x0008, 0x3251: 0x0008,
+	0x3252: 0x0008, 0x3253: 0x0008, 0x3254: 0x0008, 0x3255: 0x0008, 0x3256: 0x0008, 0x3257: 0x0008,
+	0x3258: 0x0008, 0x3259: 0x0008, 0x325a: 0x0008, 0x325b: 0x0008, 0x325c: 0x0008, 0x325d: 0x0008,
+	0x325e: 0x0008, 0x325f: 0x0008, 0x3260: 0x0008, 0x3261: 0x0008, 0x3262: 0x0008, 0x3263: 0x0008,
+	0x3264: 0x0008, 0x3265: 0x0008, 0x3266: 0x0008, 0x3267: 0x0008, 0x3268: 0x0008, 0x3269: 0x0008,
+	0x326a: 0x0008, 0x326b: 0x0008, 0x326c: 0x0008, 0x326d: 0x0008, 0x326e: 0x0008, 0x326f: 0x0008,
+	0x3270: 0x0008, 0x3271: 0x0008, 0x3272: 0x0008, 0x3273: 0x0008, 0x3274: 0x0008, 0x3275: 0x0008,
+	0x3276: 0x0008, 0x3277: 0x0008, 0x3278: 0x0008, 0x3279: 0x0008, 0x327a: 0x0008, 0x327b: 0x0004,
+	0x327c: 0x0004, 0x327d: 0x0004, 0x327e: 0x0004, 0x327f: 0x0004,
+	// Block 0xca, offset 0x3280
+	0x3280: 0x0008, 0x3281: 0x0008, 0x3282: 0x0008, 0x3283: 0x0008, 0x3284: 0x0008, 0x3285: 0x0008,
+	0x3286: 0x0008, 0x3287: 0x0008, 0x3288: 0x0008, 0x3289: 0x0008, 0x328a: 0x0008, 0x328b: 0x0008,
+	0x328c: 0x0008, 0x328d: 0x0008, 0x328e: 0x0008, 0x328f: 0x0008, 0x3290: 0x0008, 0x3291: 0x0008,
+	0x3292: 0x0008, 0x3293: 0x0008, 0x3294: 0x0008, 0x3295: 0x0008, 0x3296: 0x0008, 0x3297: 0x0008,
+	0x3298: 0x0008, 0x3299: 0x0008, 0x329a: 0x0008, 0x329b: 0x0008, 0x329c: 0x0008, 0x329d: 0x0008,
+	0x329e: 0x0008, 0x329f: 0x0008, 0x32a0: 0x0008, 0x32a1: 0x0008, 0x32a2: 0x0008, 0x32a3: 0x0008,
+	0x32a4: 0x0008, 0x32a5: 0x0008, 0x32a6: 0x0008, 0x32a7: 0x0008, 0x32a8: 0x0008, 0x32a9: 0x0008,
+	0x32aa: 0x0008, 0x32ab: 0x0008, 0x32ac: 0x0008, 0x32ad: 0x0008, 0x32ae: 0x0008, 0x32af: 0x0008,
+	0x32b0: 0x0008, 0x32b1: 0x0008, 0x32b2: 0x0008, 0x32b3: 0x0008, 0x32b4: 0x0008, 0x32b5: 0x0008,
+	0x32b6: 0x0008, 0x32b7: 0x0008, 0x32b8: 0x0008, 0x32b9: 0x0008, 0x32ba: 0x0008, 0x32bb: 0x0008,
+	0x32bc: 0x0008, 0x32bd: 0x0008,
+	// Block 0xcb, offset 0x32c0
+	0x32c6: 0x0008, 0x32c7: 0x0008, 0x32c8: 0x0008, 0x32c9: 0x0008, 0x32ca: 0x0008, 0x32cb: 0x0008,
+	0x32cc: 0x0008, 0x32cd: 0x0008, 0x32ce: 0x0008, 0x32cf: 0x0008, 0x32d0: 0x0008, 0x32d1: 0x0008,
+	0x32d2: 0x0008, 0x32d3: 0x0008, 0x32d4: 0x0008, 0x32d5: 0x0008, 0x32d6: 0x0008, 0x32d7: 0x0008,
+	0x32d8: 0x0008, 0x32d9: 0x0008, 0x32da: 0x0008, 0x32db: 0x0008, 0x32dc: 0x0008, 0x32dd: 0x0008,
+	0x32de: 0x0008, 0x32df: 0x0008, 0x32e0: 0x0008, 0x32e1: 0x0008, 0x32e2: 0x0008, 0x32e3: 0x0008,
+	0x32e4: 0x0008, 0x32e5: 0x0008, 0x32e6: 0x0008, 0x32e7: 0x0008, 0x32e8: 0x0008, 0x32e9: 0x0008,
+	0x32ea: 0x0008, 0x32eb: 0x0008, 0x32ec: 0x0008, 0x32ed: 0x0008, 0x32ee: 0x0008, 0x32ef: 0x0008,
+	0x32f0: 0x0008, 0x32f1: 0x0008, 0x32f2: 0x0008, 0x32f3: 0x0008, 0x32f4: 0x0008, 0x32f5: 0x0008,
+	0x32f6: 0x0008, 0x32f7: 0x0008, 0x32f8: 0x0008, 0x32f9: 0x0008, 0x32fa: 0x0008, 0x32fb: 0x0008,
+	0x32fc: 0x0008, 0x32fd: 0x0008, 0x32fe: 0x0008, 0x32ff: 0x0008,
+	// Block 0xcc, offset 0x3300
+	0x3300: 0x0008, 0x3301: 0x0008, 0x3302: 0x0008, 0x3303: 0x0008, 0x3304: 0x0008, 0x3305: 0x0008,
+	0x3306: 0x0008, 0x3307: 0x0008, 0x3308: 0x0008, 0x3309: 0x0008, 0x330a: 0x0008, 0x330b: 0x0008,
+	0x330c: 0x0008, 0x330d: 0x0008, 0x330e: 0x0008, 0x330f: 0x0008,
+	// Block 0xcd, offset 0x3340
+	0x3374: 0x0008, 0x3375: 0x0008,
+	0x3376: 0x0008, 0x3377: 0x0008, 0x3378: 0x0008, 0x3379: 0x0008, 0x337a: 0x0008, 0x337b: 0x0008,
+	0x337c: 0x0008, 0x337d: 0x0008, 0x337e: 0x0008, 0x337f: 0x0008,
+	// Block 0xce, offset 0x3380
+	0x3395: 0x0008, 0x3396: 0x0008, 0x3397: 0x0008,
+	0x3398: 0x0008, 0x3399: 0x0008, 0x339a: 0x0008, 0x339b: 0x0008, 0x339c: 0x0008, 0x339d: 0x0008,
+	0x339e: 0x0008, 0x339f: 0x0008, 0x33a0: 0x0008, 0x33a1: 0x0008, 0x33a2: 0x0008, 0x33a3: 0x0008,
+	0x33a4: 0x0008, 0x33a5: 0x0008, 0x33a6: 0x0008, 0x33a7: 0x0008, 0x33a8: 0x0008, 0x33a9: 0x0008,
+	0x33aa: 0x0008, 0x33ab: 0x0008, 0x33ac: 0x0008, 0x33ad: 0x0008, 0x33ae: 0x0008, 0x33af: 0x0008,
+	0x33b0: 0x0008, 0x33b1: 0x0008, 0x33b2: 0x0008, 0x33b3: 0x0008, 0x33b4: 0x0008, 0x33b5: 0x0008,
+	0x33b6: 0x0008, 0x33b7: 0x0008, 0x33b8: 0x0008, 0x33b9: 0x0008, 0x33ba: 0x0008, 0x33bb: 0x0008,
+	0x33bc: 0x0008, 0x33bd: 0x0008, 0x33be: 0x0008, 0x33bf: 0x0008,
+	// Block 0xcf, offset 0x33c0
+	0x33cc: 0x0008, 0x33cd: 0x0008, 0x33ce: 0x0008, 0x33cf: 0x0008,
+	// Block 0xd0, offset 0x3400
+	0x3408: 0x0008, 0x3409: 0x0008, 0x340a: 0x0008, 0x340b: 0x0008,
+	0x340c: 0x0008, 0x340d: 0x0008, 0x340e: 0x0008, 0x340f: 0x0008,
+	0x341a: 0x0008, 0x341b: 0x0008, 0x341c: 0x0008, 0x341d: 0x0008,
+	0x341e: 0x0008, 0x341f: 0x0008,
+	// Block 0xd1, offset 0x3440
+	0x3448: 0x0008, 0x3449: 0x0008, 0x344a: 0x0008, 0x344b: 0x0008,
+	0x344c: 0x0008, 0x344d: 0x0008, 0x344e: 0x0008, 0x344f: 0x0008,
+	0x346e: 0x0008, 0x346f: 0x0008,
+	0x3470: 0x0008, 0x3471: 0x0008, 0x3472: 0x0008, 0x3473: 0x0008, 0x3474: 0x0008, 0x3475: 0x0008,
+	0x3476: 0x0008, 0x3477: 0x0008, 0x3478: 0x0008, 0x3479: 0x0008, 0x347a: 0x0008, 0x347b: 0x0008,
+	0x347c: 0x0008, 0x347d: 0x0008, 0x347e: 0x0008, 0x347f: 0x0008,
+	// Block 0xd2, offset 0x3480
+	0x348c: 0x0008, 0x348d: 0x0008, 0x348e: 0x0008, 0x348f: 0x0008, 0x3490: 0x0008, 0x3491: 0x0008,
+	0x3492: 0x0008, 0x3493: 0x0008, 0x3494: 0x0008, 0x3495: 0x0008, 0x3496: 0x0008, 0x3497: 0x0008,
+	0x3498: 0x0008, 0x3499: 0x0008, 0x349a: 0x0008, 0x349b: 0x0008, 0x349c: 0x0008, 0x349d: 0x0008,
+	0x349e: 0x0008, 0x349f: 0x0008, 0x34a0: 0x0008, 0x34a1: 0x0008, 0x34a2: 0x0008, 0x34a3: 0x0008,
+	0x34a4: 0x0008, 0x34a5: 0x0008, 0x34a6: 0x0008, 0x34a7: 0x0008, 0x34a8: 0x0008, 0x34a9: 0x0008,
+	0x34aa: 0x0008, 0x34ab: 0x0008, 0x34ac: 0x0008, 0x34ad: 0x0008, 0x34ae: 0x0008, 0x34af: 0x0008,
+	0x34b0: 0x0008, 0x34b1: 0x0008, 0x34b2: 0x0008, 0x34b3: 0x0008, 0x34b4: 0x0008, 0x34b5: 0x0008,
+	0x34b6: 0x0008, 0x34b7: 0x0008, 0x34b8: 0x0008, 0x34b9: 0x0008, 0x34ba: 0x0008,
+	0x34bc: 0x0008, 0x34bd: 0x0008, 0x34be: 0x0008, 0x34bf: 0x0008,
+	// Block 0xd3, offset 0x34c0
+	0x34c0: 0x0008, 0x34c1: 0x0008, 0x34c2: 0x0008, 0x34c3: 0x0008, 0x34c4: 0x0008, 0x34c5: 0x0008,
+	0x34c7: 0x0008, 0x34c8: 0x0008, 0x34c9: 0x0008, 0x34ca: 0x0008, 0x34cb: 0x0008,
+	0x34cc: 0x0008, 0x34cd: 0x0008, 0x34ce: 0x0008, 0x34cf: 0x0008, 0x34d0: 0x0008, 0x34d1: 0x0008,
+	0x34d2: 0x0008, 0x34d3: 0x0008, 0x34d4: 0x0008, 0x34d5: 0x0008, 0x34d6: 0x0008, 0x34d7: 0x0008,
+	0x34d8: 0x0008, 0x34d9: 0x0008, 0x34da: 0x0008, 0x34db: 0x0008, 0x34dc: 0x0008, 0x34dd: 0x0008,
+	0x34de: 0x0008, 0x34df: 0x0008, 0x34e0: 0x0008, 0x34e1: 0x0008, 0x34e2: 0x0008, 0x34e3: 0x0008,
+	0x34e4: 0x0008, 0x34e5: 0x0008, 0x34e6: 0x0008, 0x34e7: 0x0008, 0x34e8: 0x0008, 0x34e9: 0x0008,
+	0x34ea: 0x0008, 0x34eb: 0x0008, 0x34ec: 0x0008, 0x34ed: 0x0008, 0x34ee: 0x0008, 0x34ef: 0x0008,
+	0x34f0: 0x0008, 0x34f1: 0x0008, 0x34f2: 0x0008, 0x34f3: 0x0008, 0x34f4: 0x0008, 0x34f5: 0x0008,
+	0x34f6: 0x0008, 0x34f7: 0x0008, 0x34f8: 0x0008, 0x34f9: 0x0008, 0x34fa: 0x0008, 0x34fb: 0x0008,
+	0x34fc: 0x0008, 0x34fd: 0x0008, 0x34fe: 0x0008, 0x34ff: 0x0008,
+	// Block 0xd4, offset 0x3500
+	0x3500: 0x0002, 0x3501: 0x0002, 0x3502: 0x0002, 0x3503: 0x0002, 0x3504: 0x0002, 0x3505: 0x0002,
+	0x3506: 0x0002, 0x3507: 0x0002, 0x3508: 0x0002, 0x3509: 0x0002, 0x350a: 0x0002, 0x350b: 0x0002,
+	0x350c: 0x0002, 0x350d: 0x0002, 0x350e: 0x0002, 0x350f: 0x0002, 0x3510: 0x0002, 0x3511: 0x0002,
+	0x3512: 0x0002, 0x3513: 0x0002, 0x3514: 0x0002, 0x3515: 0x0002, 0x3516: 0x0002, 0x3517: 0x0002,
+	0x3518: 0x0002, 0x3519: 0x0002, 0x351a: 0x0002, 0x351b: 0x0002, 0x351c: 0x0002, 0x351d: 0x0002,
+	0x351e: 0x0002, 0x351f: 0x0002, 0x3520: 0x0004, 0x3521: 0x0004, 0x3522: 0x0004, 0x3523: 0x0004,
+	0x3524: 0x0004, 0x3525: 0x0004, 0x3526: 0x0004, 0x3527: 0x0004, 0x3528: 0x0004, 0x3529: 0x0004,
+	0x352a: 0x0004, 0x352b: 0x0004, 0x352c: 0x0004, 0x352d: 0x0004, 0x352e: 0x0004, 0x352f: 0x0004,
+	0x3530: 0x0004, 0x3531: 0x0004, 0x3532: 0x0004, 0x3533: 0x0004, 0x3534: 0x0004, 0x3535: 0x0004,
+	0x3536: 0x0004, 0x3537: 0x0004, 0x3538: 0x0004, 0x3539: 0x0004, 0x353a: 0x0004, 0x353b: 0x0004,
+	0x353c: 0x0004, 0x353d: 0x0004, 0x353e: 0x0004, 0x353f: 0x0004,
+	// Block 0xd5, offset 0x3540
+	0x3540: 0x0002, 0x3541: 0x0002, 0x3542: 0x0002, 0x3543: 0x0002, 0x3544: 0x0002, 0x3545: 0x0002,
+	0x3546: 0x0002, 0x3547: 0x0002, 0x3548: 0x0002, 0x3549: 0x0002, 0x354a: 0x0002, 0x354b: 0x0002,
+	0x354c: 0x0002, 0x354d: 0x0002, 0x354e: 0x0002, 0x354f: 0x0002, 0x3550: 0x0002, 0x3551: 0x0002,
+	0x3552: 0x0002, 0x3553: 0x0002, 0x3554: 0x0002, 0x3555: 0x0002, 0x3556: 0x0002, 0x3557: 0x0002,
+	0x3558: 0x0002, 0x3559: 0x0002, 0x355a: 0x0002, 0x355b: 0x0002, 0x355c: 0x0002, 0x355d: 0x0002,
+	0x355e: 0x0002, 0x355f: 0x0002, 0x3560: 0x0002, 0x3561: 0x0002, 0x3562: 0x0002, 0x3563: 0x0002,
+	0x3564: 0x0002, 0x3565: 0x0002, 0x3566: 0x0002, 0x3567: 0x0002, 0x3568: 0x0002, 0x3569: 0x0002,
+	0x356a: 0x0002, 0x356b: 0x0002, 0x356c: 0x0002, 0x356d: 0x0002, 0x356e: 0x0002, 0x356f: 0x0002,
+	0x3570: 0x0002, 0x3571: 0x0002, 0x3572: 0x0002, 0x3573: 0x0002, 0x3574: 0x0002, 0x3575: 0x0002,
+	0x3576: 0x0002, 0x3577: 0x0002, 0x3578: 0x0002, 0x3579: 0x0002, 0x357a: 0x0002, 0x357b: 0x0002,
+	0x357c: 0x0002, 0x357d: 0x0002, 0x357e: 0x0002, 0x357f: 0x0002,
+	// Block 0xd6, offset 0x3580
+	0x3580: 0x0004, 0x3581: 0x0004, 0x3582: 0x0004, 0x3583: 0x0004, 0x3584: 0x0004, 0x3585: 0x0004,
+	0x3586: 0x0004, 0x3587: 0x0004, 0x3588: 0x0004, 0x3589: 0x0004, 0x358a: 0x0004, 0x358b: 0x0004,
+	0x358c: 0x0004, 0x358d: 0x0004, 0x358e: 0x0004, 0x358f: 0x0004, 0x3590: 0x0004, 0x3591: 0x0004,
+	0x3592: 0x0004, 0x3593: 0x0004, 0x3594: 0x0004, 0x3595: 0x0004, 0x3596: 0x0004, 0x3597: 0x0004,
+	0x3598: 0x0004, 0x3599: 0x0004, 0x359a: 0x0004, 0x359b: 0x0004, 0x359c: 0x0004, 0x359d: 0x0004,
+	0x359e: 0x0004, 0x359f: 0x0004, 0x35a0: 0x0004, 0x35a1: 0x0004, 0x35a2: 0x0004, 0x35a3: 0x0004,
+	0x35a4: 0x0004, 0x35a5: 0x0004, 0x35a6: 0x0004, 0x35a7: 0x0004, 0x35a8: 0x0004, 0x35a9: 0x0004,
+	0x35aa: 0x0004, 0x35ab: 0x0004, 0x35ac: 0x0004, 0x35ad: 0x0004, 0x35ae: 0x0004, 0x35af: 0x0004,
+	0x35b0: 0x0002, 0x35b1: 0x0002, 0x35b2: 0x0002, 0x35b3: 0x0002, 0x35b4: 0x0002, 0x35b5: 0x0002,
+	0x35b6: 0x0002, 0x35b7: 0x0002, 0x35b8: 0x0002, 0x35b9: 0x0002, 0x35ba: 0x0002, 0x35bb: 0x0002,
+	0x35bc: 0x0002, 0x35bd: 0x0002, 0x35be: 0x0002, 0x35bf: 0x0002,
+}
+
+// graphemesIndex: 25 blocks, 1600 entries, 1600 bytes
+// Block 0 is the zero block.
+var graphemesIndex = [1600]property{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x01,
+	0xcc: 0x02, 0xcd: 0x03,
+	0xd2: 0x04, 0xd6: 0x05, 0xd7: 0x06,
+	0xd8: 0x07, 0xd9: 0x08, 0xdb: 0x09, 0xdc: 0x0a, 0xdd: 0x0b, 0xde: 0x0c, 0xdf: 0x0d,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x14, 0xf3: 0x16,
+	// Block 0x4, offset 0x100
+	0x120: 0x0e, 0x121: 0x0f, 0x122: 0x10, 0x123: 0x11, 0x124: 0x12, 0x125: 0x13, 0x126: 0x14, 0x127: 0x15,
+	0x128: 0x16, 0x129: 0x17, 0x12a: 0x16, 0x12b: 0x18, 0x12c: 0x19, 0x12d: 0x1a, 0x12e: 0x1b, 0x12f: 0x1c,
+	0x130: 0x1d, 0x131: 0x1e, 0x132: 0x1f, 0x133: 0x20, 0x134: 0x21, 0x135: 0x22, 0x136: 0x23, 0x137: 0x24,
+	0x138: 0x25, 0x139: 0x26, 0x13a: 0x27, 0x13b: 0x28, 0x13c: 0x29, 0x13d: 0x2a, 0x13e: 0x2b, 0x13f: 0x2c,
+	// Block 0x5, offset 0x140
+	0x140: 0x2d, 0x141: 0x2e, 0x142: 0x2f, 0x144: 0x30, 0x145: 0x31, 0x146: 0x32, 0x147: 0x33,
+	0x14d: 0x34,
+	0x15c: 0x35, 0x15d: 0x36, 0x15e: 0x37, 0x15f: 0x38,
+	0x160: 0x39, 0x162: 0x3a, 0x164: 0x3b,
+	0x168: 0x3c, 0x169: 0x3d, 0x16a: 0x3e, 0x16b: 0x3f, 0x16c: 0x40, 0x16d: 0x41, 0x16e: 0x42, 0x16f: 0x43,
+	0x170: 0x44, 0x173: 0x45, 0x177: 0x02,
+	// Block 0x6, offset 0x180
+	0x180: 0x46, 0x181: 0x47, 0x183: 0x48, 0x184: 0x49, 0x186: 0x4a,
+	0x18c: 0x4b, 0x18e: 0x4c, 0x18f: 0x4d,
+	0x193: 0x4e, 0x196: 0x4f, 0x197: 0x50,
+	0x198: 0x51, 0x199: 0x52, 0x19a: 0x53, 0x19b: 0x52, 0x19c: 0x54, 0x19d: 0x55, 0x19e: 0x56,
+	0x1a4: 0x57,
+	0x1ac: 0x58, 0x1ad: 0x59,
+	0x1b3: 0x5a, 0x1b5: 0x5b, 0x1b7: 0x5c,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x5d, 0x1c2: 0x5e,
+	0x1ca: 0x5f,
+	// Block 0x8, offset 0x200
+	0x219: 0x60, 0x21a: 0x61, 0x21b: 0x62,
+	0x220: 0x63, 0x222: 0x64, 0x223: 0x65, 0x224: 0x66, 0x225: 0x67, 0x226: 0x68, 0x227: 0x69,
+	0x228: 0x6a, 0x229: 0x6b, 0x22a: 0x6c, 0x22b: 0x6d, 0x22f: 0x6e,
+	0x230: 0x6f, 0x231: 0x70, 0x232: 0x71, 0x233: 0x72, 0x234: 0x73, 0x235: 0x74, 0x236: 0x75, 0x237: 0x6f,
+	0x238: 0x70, 0x239: 0x71, 0x23a: 0x72, 0x23b: 0x73, 0x23c: 0x74, 0x23d: 0x75, 0x23e: 0x6f, 0x23f: 0x70,
+	// Block 0x9, offset 0x240
+	0x240: 0x71, 0x241: 0x72, 0x242: 0x73, 0x243: 0x74, 0x244: 0x75, 0x245: 0x6f, 0x246: 0x70, 0x247: 0x71,
+	0x248: 0x72, 0x249: 0x73, 0x24a: 0x74, 0x24b: 0x75, 0x24c: 0x6f, 0x24d: 0x70, 0x24e: 0x71, 0x24f: 0x72,
+	0x250: 0x73, 0x251: 0x74, 0x252: 0x75, 0x253: 0x6f, 0x254: 0x70, 0x255: 0x71, 0x256: 0x72, 0x257: 0x73,
+	0x258: 0x74, 0x259: 0x75, 0x25a: 0x6f, 0x25b: 0x70, 0x25c: 0x71, 0x25d: 0x72, 0x25e: 0x73, 0x25f: 0x74,
+	0x260: 0x75, 0x261: 0x6f, 0x262: 0x70, 0x263: 0x71, 0x264: 0x72, 0x265: 0x73, 0x266: 0x74, 0x267: 0x75,
+	0x268: 0x6f, 0x269: 0x70, 0x26a: 0x71, 0x26b: 0x72, 0x26c: 0x73, 0x26d: 0x74, 0x26e: 0x75, 0x26f: 0x6f,
+	0x270: 0x70, 0x271: 0x71, 0x272: 0x72, 0x273: 0x73, 0x274: 0x74, 0x275: 0x75, 0x276: 0x6f, 0x277: 0x70,
+	0x278: 0x71, 0x279: 0x72, 0x27a: 0x73, 0x27b: 0x74, 0x27c: 0x75, 0x27d: 0x6f, 0x27e: 0x70, 0x27f: 0x71,
+	// Block 0xa, offset 0x280
+	0x280: 0x72, 0x281: 0x73, 0x282: 0x74, 0x283: 0x75, 0x284: 0x6f, 0x285: 0x70, 0x286: 0x71, 0x287: 0x72,
+	0x288: 0x73, 0x289: 0x74, 0x28a: 0x75, 0x28b: 0x6f, 0x28c: 0x70, 0x28d: 0x71, 0x28e: 0x72, 0x28f: 0x73,
+	0x290: 0x74, 0x291: 0x75, 0x292: 0x6f, 0x293: 0x70, 0x294: 0x71, 0x295: 0x72, 0x296: 0x73, 0x297: 0x74,
+	0x298: 0x75, 0x299: 0x6f, 0x29a: 0x70, 0x29b: 0x71, 0x29c: 0x72, 0x29d: 0x73, 0x29e: 0x74, 0x29f: 0x75,
+	0x2a0: 0x6f, 0x2a1: 0x70, 0x2a2: 0x71, 0x2a3: 0x72, 0x2a4: 0x73, 0x2a5: 0x74, 0x2a6: 0x75, 0x2a7: 0x6f,
+	0x2a8: 0x70, 0x2a9: 0x71, 0x2aa: 0x72, 0x2ab: 0x73, 0x2ac: 0x74, 0x2ad: 0x75, 0x2ae: 0x6f, 0x2af: 0x70,
+	0x2b0: 0x71, 0x2b1: 0x72, 0x2b2: 0x73, 0x2b3: 0x74, 0x2b4: 0x75, 0x2b5: 0x6f, 0x2b6: 0x70, 0x2b7: 0x71,
+	0x2b8: 0x72, 0x2b9: 0x73, 0x2ba: 0x74, 0x2bb: 0x75, 0x2bc: 0x6f, 0x2bd: 0x70, 0x2be: 0x71, 0x2bf: 0x72,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x73, 0x2c1: 0x74, 0x2c2: 0x75, 0x2c3: 0x6f, 0x2c4: 0x70, 0x2c5: 0x71, 0x2c6: 0x72, 0x2c7: 0x73,
+	0x2c8: 0x74, 0x2c9: 0x75, 0x2ca: 0x6f, 0x2cb: 0x70, 0x2cc: 0x71, 0x2cd: 0x72, 0x2ce: 0x73, 0x2cf: 0x74,
+	0x2d0: 0x75, 0x2d1: 0x6f, 0x2d2: 0x70, 0x2d3: 0x71, 0x2d4: 0x72, 0x2d5: 0x73, 0x2d6: 0x74, 0x2d7: 0x75,
+	0x2d8: 0x6f, 0x2d9: 0x70, 0x2da: 0x71, 0x2db: 0x72, 0x2dc: 0x73, 0x2dd: 0x74, 0x2de: 0x76, 0x2df: 0x77,
+	// Block 0xc, offset 0x300
+	0x32c: 0x78,
+	0x338: 0x79, 0x33b: 0x7a, 0x33e: 0x61, 0x33f: 0x7b,
+	// Block 0xd, offset 0x340
+	0x347: 0x7c,
+	0x34b: 0x7d, 0x34d: 0x7e,
+	0x368: 0x7f, 0x36b: 0x80,
+	0x374: 0x81,
+	0x37a: 0x82, 0x37b: 0x83, 0x37d: 0x84, 0x37e: 0x85,
+	// Block 0xe, offset 0x380
+	0x380: 0x86, 0x381: 0x87, 0x382: 0x88, 0x383: 0x89, 0x384: 0x8a, 0x385: 0x8b, 0x386: 0x8c, 0x387: 0x8d,
+	0x388: 0x8e, 0x389: 0x8f, 0x38b: 0x90, 0x38c: 0x21, 0x38d: 0x91,
+	0x390: 0x92, 0x391: 0x93, 0x392: 0x94, 0x393: 0x95, 0x396: 0x96, 0x397: 0x97,
+	0x398: 0x98, 0x399: 0x99, 0x39a: 0x9a, 0x39c: 0x9b,
+	0x3a0: 0x9c, 0x3a4: 0x9d, 0x3a5: 0x9e, 0x3a7: 0x9f,
+	0x3a8: 0xa0, 0x3a9: 0xa1, 0x3aa: 0xa2,
+	0x3b0: 0xa3, 0x3b2: 0xa4, 0x3b4: 0xa5, 0x3b5: 0xa6, 0x3b6: 0xa7,
+	0x3bb: 0xa8, 0x3bc: 0xa9, 0x3bd: 0xaa,
+	// Block 0xf, offset 0x3c0
+	0x3d0: 0xab, 0x3d1: 0xac,
+	// Block 0x10, offset 0x400
+	0x42b: 0xad, 0x42c: 0xae,
+	0x43d: 0xaf, 0x43e: 0xb0, 0x43f: 0xb1,
+	// Block 0x11, offset 0x440
+	0x472: 0xb2,
+	// Block 0x12, offset 0x480
+	0x4bc: 0xb3, 0x4bd: 0xb4,
+	// Block 0x13, offset 0x4c0
+	0x4c5: 0xb5, 0x4c6: 0xb6,
+	0x4c9: 0xb7,
+	0x4e8: 0xb8, 0x4e9: 0xb9, 0x4ea: 0xba,
+	// Block 0x14, offset 0x500
+	0x500: 0xbb, 0x502: 0xbc, 0x504: 0xae,
+	0x50a: 0xbd, 0x50b: 0xbe,
+	0x513: 0xbe,
+	0x523: 0xbf, 0x525: 0xc0,
+	// Block 0x15, offset 0x540
+	0x540: 0x52, 0x541: 0x52, 0x542: 0x52, 0x543: 0x52, 0x544: 0xc1, 0x545: 0xc2, 0x546: 0xc3, 0x547: 0xc4,
+	0x548: 0xc5, 0x549: 0xc6, 0x54a: 0x52, 0x54b: 0x52, 0x54c: 0x52, 0x54d: 0x52, 0x54e: 0x52, 0x54f: 0xc7,
+	0x550: 0x52, 0x551: 0x52, 0x552: 0x52, 0x553: 0x52, 0x554: 0xc8, 0x555: 0xc9, 0x556: 0x52, 0x557: 0x52,
+	0x558: 0x52, 0x559: 0xca, 0x55a: 0x52, 0x55b: 0x52, 0x55d: 0xcb, 0x55f: 0xcc,
+	0x560: 0xcd, 0x561: 0xce, 0x562: 0xcf, 0x563: 0x52, 0x564: 0xd0, 0x565: 0xd1, 0x566: 0x52, 0x567: 0x52,
+	0x568: 0x52, 0x569: 0x52, 0x56a: 0x52, 0x56b: 0x52,
+	0x570: 0x52, 0x571: 0x52, 0x572: 0x52, 0x573: 0x52, 0x574: 0x52, 0x575: 0x52, 0x576: 0x52, 0x577: 0x52,
+	0x578: 0x52, 0x579: 0x52, 0x57a: 0x52, 0x57b: 0x52, 0x57c: 0x52, 0x57d: 0x52, 0x57e: 0x52, 0x57f: 0xc8,
+	// Block 0x16, offset 0x580
+	0x590: 0x0b, 0x591: 0x0c, 0x593: 0x0d, 0x596: 0x0e,
+	0x59b: 0x0f, 0x59c: 0x10, 0x59d: 0x11, 0x59e: 0x12, 0x59f: 0x13,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0xd2, 0x5c1: 0x02, 0x5c2: 0xd3, 0x5c3: 0xd3, 0x5c4: 0x02, 0x5c5: 0x02, 0x5c6: 0x02, 0x5c7: 0xd4,
+	0x5c8: 0xd3, 0x5c9: 0xd3, 0x5ca: 0xd3, 0x5cb: 0xd3, 0x5cc: 0xd3, 0x5cd: 0xd3, 0x5ce: 0xd3, 0x5cf: 0xd3,
+	0x5d0: 0xd3, 0x5d1: 0xd3, 0x5d2: 0xd3, 0x5d3: 0xd3, 0x5d4: 0xd3, 0x5d5: 0xd3, 0x5d6: 0xd3, 0x5d7: 0xd3,
+	0x5d8: 0xd3, 0x5d9: 0xd3, 0x5da: 0xd3, 0x5db: 0xd3, 0x5dc: 0xd3, 0x5dd: 0xd3, 0x5de: 0xd3, 0x5df: 0xd3,
+	0x5e0: 0xd3, 0x5e1: 0xd3, 0x5e2: 0xd3, 0x5e3: 0xd3, 0x5e4: 0xd3, 0x5e5: 0xd3, 0x5e6: 0xd3, 0x5e7: 0xd3,
+	0x5e8: 0xd3, 0x5e9: 0xd3, 0x5ea: 0xd3, 0x5eb: 0xd3, 0x5ec: 0xd3, 0x5ed: 0xd3, 0x5ee: 0xd3, 0x5ef: 0xd3,
+	0x5f0: 0xd3, 0x5f1: 0xd3, 0x5f2: 0xd3, 0x5f3: 0xd3, 0x5f4: 0xd3, 0x5f5: 0xd3, 0x5f6: 0xd3, 0x5f7: 0xd3,
+	0x5f8: 0xd3, 0x5f9: 0xd3, 0x5fa: 0xd3, 0x5fb: 0xd3, 0x5fc: 0xd3, 0x5fd: 0xd3, 0x5fe: 0xd3, 0x5ff: 0xd3,
+	// Block 0x18, offset 0x600
+	0x620: 0x15,
+}

vendor/github.com/clipperhouse/uax29/v2/internal/iterators/iterator.go

@@ -0,0 +1,100 @@
+package iterators
+
+import "github.com/clipperhouse/stringish"
+
+type SplitFunc[T stringish.Interface] func(T, bool) (int, T, error)
+
+// Iterator is a generic iterator for words that are either []byte or string.
+// Iterate while Next() is true, and access the word via Value().
+type Iterator[T stringish.Interface] struct {
+	split SplitFunc[T]
+	data  T
+	start int
+	pos   int
+}
+
+// New creates a new Iterator for the given data and SplitFunc.
+func New[T stringish.Interface](split SplitFunc[T], data T) *Iterator[T] {
+	return &Iterator[T]{
+		split: split,
+		data:  data,
+	}
+}
+
+// SetText sets the text for the iterator to operate on, and resets all state.
+func (iter *Iterator[T]) SetText(data T) {
+	iter.data = data
+	iter.start = 0
+	iter.pos = 0
+}
+
+// Split sets the SplitFunc for the Iterator.
+func (iter *Iterator[T]) Split(split SplitFunc[T]) {
+	iter.split = split
+}
+
+// Next advances the iterator to the next token. It returns false when there
+// are no remaining tokens or an error occurred.
+func (iter *Iterator[T]) Next() bool {
+	if iter.pos == len(iter.data) {
+		return false
+	}
+	if iter.pos > len(iter.data) {
+		panic("SplitFunc advanced beyond the end of the data")
+	}
+
+	iter.start = iter.pos
+
+	advance, _, err := iter.split(iter.data[iter.pos:], true)
+	if err != nil {
+		panic(err)
+	}
+	if advance <= 0 {
+		panic("SplitFunc returned a zero or negative advance")
+	}
+
+	iter.pos += advance
+	if iter.pos > len(iter.data) {
+		panic("SplitFunc advanced beyond the end of the data")
+	}
+
+	return true
+}
+
+// Value returns the current token.
+func (iter *Iterator[T]) Value() T {
+	return iter.data[iter.start:iter.pos]
+}
+
+// Start returns the byte position of the current token in the original data.
+func (iter *Iterator[T]) Start() int {
+	return iter.start
+}
+
+// End returns the byte position after the current token in the original data.
+func (iter *Iterator[T]) End() int {
+	return iter.pos
+}
+
+// Reset resets the iterator to the beginning of the data.
+func (iter *Iterator[T]) Reset() {
+	iter.start = 0
+	iter.pos = 0
+}
+
+func (iter *Iterator[T]) First() T {
+	if len(iter.data) == 0 {
+		return iter.data
+	}
+	advance, _, err := iter.split(iter.data, true)
+	if err != nil {
+		panic(err)
+	}
+	if advance <= 0 {
+		panic("SplitFunc returned a zero or negative advance")
+	}
+	if advance > len(iter.data) {
+		panic("SplitFunc advanced beyond the end of the data")
+	}
+	return iter.data[:advance]
+}

vendor/github.com/gofiber/fiber/v2/app.go

@@ -30,7 +30,7 @@ import (
 )
 
 // Version of current fiber package
-const Version = "2.52.9"
+const Version = "2.52.10"
 
 // Handler defines a function to serve HTTP requests.
 type Handler = func(*Ctx) error

vendor/github.com/gofiber/fiber/v2/client.go

@@ -800,9 +800,7 @@ func printDebugInfo(req *Request, resp *Response, w io.Writer) {
 func (a *Agent) String() (int, string, []error) {
 	defer a.release()
 	code, body, errs := a.bytes()
-	// TODO: There might be a data race here on body. Maybe use utils.CopyBytes on it?
-
-	return code, utils.UnsafeString(body), errs
+	return code, string(body), errs
 }
 
 // Struct returns the status code, bytes body and errors of URL.

vendor/github.com/gofiber/fiber/v2/ctx.go

@@ -351,7 +351,7 @@ func (c *Ctx) Body() []byte {
 		c.fasthttp.Request.SetBodyRaw(originalBody)
 	}
 	if err != nil {
-		return []byte(err.Error())
+		return c.app.getBytes(err.Error())
 	}
 
 	if c.app.config.Immutable {
@@ -423,7 +423,20 @@ func (c *Ctx) BodyParser(out interface{}) error {
 
 		data := make(map[string][]string)
 		for key, values := range multipartForm.Value {
-			err = formatParserData(out, data, bodyTag, key, values, c.app.config.EnableSplittingOnParsers, true)
+			processedKey := key
+			processedValues := values
+			if c.app.config.Immutable {
+				processedKey = c.app.getString([]byte(key))
+				if len(values) > 0 {
+					copied := make([]string, len(values))
+					for i, val := range values {
+						copied[i] = c.app.getString([]byte(val))
+					}
+					processedValues = copied
+				}
+			}
+
+			err = formatParserData(out, data, bodyTag, processedKey, processedValues, c.app.config.EnableSplittingOnParsers, true)
 			if err != nil {
 				return err
 			}
@@ -714,17 +727,16 @@ func (c *Ctx) GetRespHeaders() map[string][]string {
 }
 
 // Hostname contains the hostname derived from the X-Forwarded-Host or Host HTTP header.
-// Returned value is only valid within the handler. Do not store any references.
-// Make copies or use the Immutable setting instead.
+// Returned value is only valid within the handler. Do not store any references unless
+// Config.Immutable is enabled, in which case the value is copied before it is returned.
 // Please use Config.EnableTrustedProxyCheck to prevent header spoofing, in case when your app is behind the proxy.
 func (c *Ctx) Hostname() string {
 	if c.IsProxyTrusted() {
-		if host := c.Get(HeaderXForwardedHost); len(host) > 0 {
-			commaPos := strings.Index(host, ",")
-			if commaPos != -1 {
-				return host[:commaPos]
+		if hostBytes := c.fasthttp.Request.Header.Peek(HeaderXForwardedHost); len(hostBytes) > 0 {
+			if commaPos := bytes.IndexByte(hostBytes, ','); commaPos != -1 {
+				hostBytes = hostBytes[:commaPos]
 			}
-			return host
+			return c.app.getString(hostBytes)
 		}
 	}
 	return c.app.getString(c.fasthttp.Request.URI().Host())
@@ -1050,8 +1062,8 @@ func (c *Ctx) OriginalURL() string {
 // Params is used to get the route parameters.
 // Defaults to empty string "" if the param doesn't exist.
 // If a default value is given, it will return that value if the param doesn't exist.
-// Returned value is only valid within the handler. Do not store any references.
-// Make copies or use the Immutable setting to use the value outside the Handler.
+// Returned value is only valid within the handler. Do not store any references unless
+// Config.Immutable is enabled, in which case the value is copied before it is returned.
 func (c *Ctx) Params(key string, defaultValue ...string) string {
 	if key == "*" || key == "+" {
 		key += "1"
@@ -1065,7 +1077,11 @@ func (c *Ctx) Params(key string, defaultValue ...string) string {
 			if len(c.values) <= i || len(c.values[i]) == 0 {
 				break
 			}
-			return c.values[i]
+			value := c.values[i]
+			if c.app.config.Immutable {
+				return c.app.getString([]byte(value))
+			}
+			return value
 		}
 	}
 	return defaultString("", defaultValue)
@@ -1818,6 +1834,11 @@ func (c *Ctx) Subdomains(offset ...int) []string {
 		l = len(subdomains)
 	}
 	subdomains = subdomains[:l]
+	if c.app.config.Immutable {
+		for i, subdomain := range subdomains {
+			subdomains[i] = c.app.getString([]byte(subdomain))
+		}
+	}
 	return subdomains
 }
 
@@ -1859,9 +1880,9 @@ func (c *Ctx) String() string {
 	buf.WriteString(" - ")
 
 	// Add method and URI
-	buf.Write(c.fasthttp.Request.Header.Method())
+	buf.WriteString(c.app.getString(c.fasthttp.Request.Header.Method()))
 	buf.WriteByte(' ')
-	buf.Write(c.fasthttp.URI().FullURI())
+	buf.WriteString(c.app.getString(c.fasthttp.URI().FullURI()))
 
 	// Allocate string
 	str := buf.String()

vendor/github.com/gofiber/fiber/v2/middleware/filesystem/filesystem.go

@@ -144,11 +144,11 @@ func New(config ...Config) fiber.Handler {
 			path = utils.TrimRight(path, '/')
 		}
 		file, err := cfg.Root.Open(path)
-		if err != nil && errors.Is(err, fs.ErrNotExist) && cfg.NotFoundFile != "" {
+		if err != nil && (errors.Is(err, fs.ErrNotExist) || errors.Is(err, fs.ErrInvalid)) && cfg.NotFoundFile != "" {
 			file, err = cfg.Root.Open(cfg.NotFoundFile)
 		}
 		if err != nil {
-			if errors.Is(err, fs.ErrNotExist) {
+			if errors.Is(err, fs.ErrNotExist) || errors.Is(err, fs.ErrInvalid) {
 				return c.Status(fiber.StatusNotFound).Next()
 			}
 			return fmt.Errorf("failed to open: %w", err)

vendor/github.com/gofiber/fiber/v2/path.go

@@ -114,7 +114,19 @@ var (
 	parameterConstraintDataSeparatorChars = []byte{paramConstraintDataSeparator}
 )
 
-// RoutePatternMatch checks if a given path matches a Fiber route pattern.
+// RoutePatternMatch reports whether the given request path would match the
+// provided Fiber route pattern using the same rules as the router. This can be
+// handy in tests or tooling where you need to verify patterns without
+// registering them on an App instance.
+//
+// An optional Config may be passed to control matching behavior such as
+// case-sensitivity or strict routing. When no configuration is supplied the
+// default Config is used.
+//
+// Example:
+//
+//	match := fiber.RoutePatternMatch("/api/v1/users", "/api/:version/*")
+//	// match == true
 func RoutePatternMatch(path, pattern string, cfg ...Config) bool {
 	// See logic in (*Route).match and (*App).register
 	var ctxParams [maxParams]string

vendor/github.com/google/flatbuffers/go/builder.go

@@ -104,15 +104,18 @@ func (b *Builder) StartObject(numfields int) {
 // logically-equal vtables will be deduplicated.
 //
 // A vtable has the following format:
-//   <VOffsetT: size of the vtable in bytes, including this value>
-//   <VOffsetT: size of the object in bytes, including the vtable offset>
-//   <VOffsetT: offset for a field> * N, where N is the number of fields in
-//	        the schema for this type. Includes deprecated fields.
+//
+//	  <VOffsetT: size of the vtable in bytes, including this value>
+//	  <VOffsetT: size of the object in bytes, including the vtable offset>
+//	  <VOffsetT: offset for a field> * N, where N is the number of fields in
+//		        the schema for this type. Includes deprecated fields.
+//
 // Thus, a vtable is made of 2 + N elements, each SizeVOffsetT bytes wide.
 //
 // An object has the following format:
-//   <SOffsetT: offset to this object's vtable (may be negative)>
-//   <byte: data>+
+//
+//	<SOffsetT: offset to this object's vtable (may be negative)>
+//	<byte: data>+
 func (b *Builder) WriteVtable() (n UOffsetT) {
 	// Prepend a zero scalar to the object. Later in this function we'll
 	// write an offset here that points to the object's vtable:
@@ -296,8 +299,9 @@ func (b *Builder) PrependUOffsetT(off UOffsetT) {
 // StartVector initializes bookkeeping for writing a new vector.
 //
 // A vector has the following format:
-//   <UOffsetT: number of elements in this vector>
-//   <T: data>+, where T is the type of elements of this vector.
+//
+//	<UOffsetT: number of elements in this vector>
+//	<T: data>+, where T is the type of elements of this vector.
 func (b *Builder) StartVector(elemSize, numElems, alignment int) UOffsetT {
 	b.assertNotNested()
 	b.nested = true

vendor/github.com/google/flatbuffers/go/grpc.go

@@ -1,7 +1,17 @@
 package flatbuffers
 
-// Codec implements gRPC-go Codec which is used to encode and decode messages.
-var Codec = "flatbuffers"
+import "errors"
+
+var (
+	// Codec implements gRPC-go Codec which is used to encode and decode messages.
+	Codec = "flatbuffers"
+
+	// ErrInsufficientData is returned when the data is too short to read the root UOffsetT.
+	ErrInsufficientData = errors.New("insufficient data")
+
+	// ErrInvalidRootOffset is returned when the root UOffsetT is out of bounds.
+	ErrInvalidRootOffset = errors.New("invalid root offset")
+)
 
 // FlatbuffersCodec defines the interface gRPC uses to encode and decode messages.  Note
 // that implementations of this interface must be thread safe; a Codec's
@@ -15,7 +25,21 @@ func (FlatbuffersCodec) Marshal(v interface{}) ([]byte, error) {
 
 // Unmarshal parses the wire format into v.
 func (FlatbuffersCodec) Unmarshal(data []byte, v interface{}) error {
-	v.(flatbuffersInit).Init(data, GetUOffsetT(data))
+	// Need at least 4 bytes to read the root table offset (UOffsetT).
+	// Vtable soffset_t and metadata are read later during field access.
+	if len(data) < SizeUOffsetT {
+		return ErrInsufficientData
+	}
+
+	off := GetUOffsetT(data)
+
+	// The root UOffsetT must be within the data buffer
+	// Compare in the unsigned domain to avoid signedness pitfalls
+	if off > UOffsetT(len(data)-SizeUOffsetT) {
+		return ErrInvalidRootOffset
+	}
+
+	v.(flatbuffersInit).Init(data, off)
 	return nil
 }
 

vendor/github.com/klauspost/compress/README.md

@@ -27,6 +27,16 @@ Use the links above for more information on each.
 
 # changelog
 
+* Oct 20, 2025 - [1.18.1](https://github.com/klauspost/compress/releases/tag/v1.18.1)
+  * zstd: Add simple zstd EncodeTo/DecodeTo functions  https://github.com/klauspost/compress/pull/1079
+  * zstd: Fix incorrect buffer size in dictionary encodes https://github.com/klauspost/compress/pull/1059
+  * s2: check for cap, not len of buffer in EncodeBetter/Best by @vdarulis in https://github.com/klauspost/compress/pull/1080
+  * zlib: Avoiding extra allocation in zlib.reader.Reset by @travelpolicy in https://github.com/klauspost/compress/pull/1086
+  * gzhttp: remove redundant err check in zstdReader by @ryanfowler in https://github.com/klauspost/compress/pull/1090
+  * flate: Faster load+store https://github.com/klauspost/compress/pull/1104
+  * flate: Simplify matchlen https://github.com/klauspost/compress/pull/1101
+  * flate: Use exact sizes for huffman tables https://github.com/klauspost/compress/pull/1103
+
 * Feb 19th, 2025 - [1.18.0](https://github.com/klauspost/compress/releases/tag/v1.18.0)
   * Add unsafe little endian loaders https://github.com/klauspost/compress/pull/1036
   * fix: check `r.err != nil` but return a nil value error `err` by @alingse in https://github.com/klauspost/compress/pull/1028
@@ -36,6 +46,9 @@ Use the links above for more information on each.
   * flate: Fix matchlen L5+L6 https://github.com/klauspost/compress/pull/1049
   * flate: Cleanup & reduce casts https://github.com/klauspost/compress/pull/1050
 
+<details>
+	<summary>See changes to v1.17.x</summary>
+
 * Oct 11th, 2024 - [1.17.11](https://github.com/klauspost/compress/releases/tag/v1.17.11)
   * zstd: Fix extra CRC written with multiple Close calls https://github.com/klauspost/compress/pull/1017
   * s2: Don't use stack for index tables https://github.com/klauspost/compress/pull/1014
@@ -102,7 +115,8 @@ https://github.com/klauspost/compress/pull/919 https://github.com/klauspost/comp
 	* s2: Do 2 overlapping match checks https://github.com/klauspost/compress/pull/839
 	* flate: Add amd64 assembly matchlen https://github.com/klauspost/compress/pull/837
 	* gzip: Copy bufio.Reader on Reset by @thatguystone in https://github.com/klauspost/compress/pull/860
-
+   
+</details>
 <details>
 	<summary>See changes to v1.16.x</summary>
 
@@ -669,3 +683,4 @@ Here are other packages of good quality and pure Go (no cgo wrappers or autoconv
 # license
 
 This code is licensed under the same conditions as the original Go code. See LICENSE file.
+

vendor/github.com/klauspost/compress/flate/deflate.go

@@ -6,11 +6,12 @@
 package flate
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
 	"io"
 	"math"
+
+	"github.com/klauspost/compress/internal/le"
 )
 
 const (
@@ -234,12 +235,9 @@ func (d *compressor) fillWindow(b []byte) {
 
 	// Calculate 256 hashes at the time (more L1 cache hits)
 	loops := (n + 256 - minMatchLength) / 256
-	for j := 0; j < loops; j++ {
+	for j := range loops {
 		startindex := j * 256
-		end := startindex + 256 + minMatchLength - 1
-		if end > n {
-			end = n
-		}
+		end := min(startindex+256+minMatchLength-1, n)
 		tocheck := d.window[startindex:end]
 		dstSize := len(tocheck) - minMatchLength + 1
 
@@ -269,18 +267,12 @@ func (d *compressor) fillWindow(b []byte) {
 // We only look at chainCount possibilities before giving up.
 // pos = s.index, prevHead = s.chainHead-s.hashOffset, prevLength=minMatchLength-1, lookahead
 func (d *compressor) findMatch(pos int, prevHead int, lookahead int) (length, offset int, ok bool) {
-	minMatchLook := maxMatchLength
-	if lookahead < minMatchLook {
-		minMatchLook = lookahead
-	}
+	minMatchLook := min(lookahead, maxMatchLength)
 
 	win := d.window[0 : pos+minMatchLook]
 
 	// We quit when we get a match that's at least nice long
-	nice := len(win) - pos
-	if d.nice < nice {
-		nice = d.nice
-	}
+	nice := min(d.nice, len(win)-pos)
 
 	// If we've got a match that's good enough, only look in 1/4 the chain.
 	tries := d.chain
@@ -288,10 +280,7 @@ func (d *compressor) findMatch(pos int, prevHead int, lookahead int) (length, of
 
 	wEnd := win[pos+length]
 	wPos := win[pos:]
-	minIndex := pos - windowSize
-	if minIndex < 0 {
-		minIndex = 0
-	}
+	minIndex := max(pos-windowSize, 0)
 	offset = 0
 
 	if d.chain < 100 {
@@ -374,7 +363,7 @@ func (d *compressor) writeStoredBlock(buf []byte) error {
 // of the supplied slice.
 // The caller must ensure that len(b) >= 4.
 func hash4(b []byte) uint32 {
-	return hash4u(binary.LittleEndian.Uint32(b), hashBits)
+	return hash4u(le.Load32(b, 0), hashBits)
 }
 
 // hash4 returns the hash of u to fit in a hash table with h bits.
@@ -389,7 +378,7 @@ func bulkHash4(b []byte, dst []uint32) {
 	if len(b) < 4 {
 		return
 	}
-	hb := binary.LittleEndian.Uint32(b)
+	hb := le.Load32(b, 0)
 
 	dst[0] = hash4u(hb, hashBits)
 	end := len(b) - 4 + 1
@@ -432,7 +421,9 @@ func (d *compressor) deflateLazy() {
 			d.h = newHuffmanEncoder(maxFlateBlockTokens)
 		}
 		var tmp [256]uint16
-		for _, v := range d.window[s.index:d.windowEnd] {
+		toIndex := d.window[s.index:d.windowEnd]
+		toIndex = toIndex[:min(len(toIndex), maxFlateBlockTokens)]
+		for _, v := range toIndex {
 			tmp[v]++
 		}
 		d.h.generate(tmp[:], 15)
@@ -480,10 +471,7 @@ func (d *compressor) deflateLazy() {
 		prevOffset := s.offset
 		s.length = minMatchLength - 1
 		s.offset = 0
-		minIndex := s.index - windowSize
-		if minIndex < 0 {
-			minIndex = 0
-		}
+		minIndex := max(s.index-windowSize, 0)
 
 		if s.chainHead-s.hashOffset >= minIndex && lookahead > prevLength && prevLength < d.lazy {
 			if newLength, newOffset, ok := d.findMatch(s.index, s.chainHead-s.hashOffset, lookahead); ok {
@@ -503,10 +491,7 @@ func (d *compressor) deflateLazy() {
 			if prevLength < maxMatchLength-checkOff {
 				prevIndex := s.index - 1
 				if prevIndex+prevLength < s.maxInsertIndex {
-					end := lookahead
-					if lookahead > maxMatchLength+checkOff {
-						end = maxMatchLength + checkOff
-					}
+					end := min(lookahead, maxMatchLength+checkOff)
 					end += prevIndex
 
 					// Hash at match end.
@@ -603,15 +588,9 @@ func (d *compressor) deflateLazy() {
 			// table.
 			newIndex := s.index + prevLength - 1
 			// Calculate missing hashes
-			end := newIndex
-			if end > s.maxInsertIndex {
-				end = s.maxInsertIndex
-			}
+			end := min(newIndex, s.maxInsertIndex)
 			end += minMatchLength - 1
-			startindex := s.index + 1
-			if startindex > s.maxInsertIndex {
-				startindex = s.maxInsertIndex
-			}
+			startindex := min(s.index+1, s.maxInsertIndex)
 			tocheck := d.window[startindex:end]
 			dstSize := len(tocheck) - minMatchLength + 1
 			if dstSize > 0 {

vendor/github.com/klauspost/compress/flate/dict_decoder.go

@@ -104,10 +104,7 @@ func (dd *dictDecoder) writeCopy(dist, length int) int {
 	dstBase := dd.wrPos
 	dstPos := dstBase
 	srcPos := dstPos - dist
-	endPos := dstPos + length
-	if endPos > len(dd.hist) {
-		endPos = len(dd.hist)
-	}
+	endPos := min(dstPos+length, len(dd.hist))
 
 	// Copy non-overlapping section after destination position.
 	//

vendor/github.com/klauspost/compress/flate/fast_encoder.go

@@ -7,7 +7,6 @@ package flate
 
 import (
 	"fmt"
-	"math/bits"
 
 	"github.com/klauspost/compress/internal/le"
 )
@@ -151,29 +150,9 @@ func (e *fastGen) matchlen(s, t int, src []byte) int32 {
 			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
 		}
 	}
-	s1 := min(s+maxMatchLength-4, len(src))
-	left := s1 - s
-	n := int32(0)
-	for left >= 8 {
-		diff := le.Load64(src, s) ^ le.Load64(src, t)
-		if diff != 0 {
-			return n + int32(bits.TrailingZeros64(diff)>>3)
-		}
-		s += 8
-		t += 8
-		n += 8
-		left -= 8
-	}
-
-	a := src[s:s1]
+	a := src[s:min(s+maxMatchLength-4, len(src))]
 	b := src[t:]
-	for i := range a {
-		if a[i] != b[i] {
-			break
-		}
-		n++
-	}
-	return n
+	return int32(matchLen(a, b))
 }
 
 // matchlenLong will return the match length between offsets and t in src.
@@ -193,29 +172,7 @@ func (e *fastGen) matchlenLong(s, t int, src []byte) int32 {
 			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
 		}
 	}
-	// Extend the match to be as long as possible.
-	left := len(src) - s
-	n := int32(0)
-	for left >= 8 {
-		diff := le.Load64(src, s) ^ le.Load64(src, t)
-		if diff != 0 {
-			return n + int32(bits.TrailingZeros64(diff)>>3)
-		}
-		s += 8
-		t += 8
-		n += 8
-		left -= 8
-	}
-
-	a := src[s:]
-	b := src[t:]
-	for i := range a {
-		if a[i] != b[i] {
-			break
-		}
-		n++
-	}
-	return n
+	return int32(matchLen(src[s:], src[t:]))
 }
 
 // Reset the encoding table.

vendor/github.com/klauspost/compress/flate/huffman_bit_writer.go

@@ -211,7 +211,9 @@ func (w *huffmanBitWriter) flush() {
 		n++
 	}
 	w.bits = 0
-	w.write(w.bytes[:n])
+	if n > 0 {
+		w.write(w.bytes[:n])
+	}
 	w.nbytes = 0
 }
 
@@ -303,10 +305,7 @@ func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int, litE
 			w.codegenFreq[size]++
 			count--
 			for count >= 3 {
-				n := 6
-				if n > count {
-					n = count
-				}
+				n := min(6, count)
 				codegen[outIndex] = 16
 				outIndex++
 				codegen[outIndex] = uint8(n - 3)
@@ -316,10 +315,7 @@ func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int, litE
 			}
 		} else {
 			for count >= 11 {
-				n := 138
-				if n > count {
-					n = count
-				}
+				n := min(138, count)
 				codegen[outIndex] = 18
 				outIndex++
 				codegen[outIndex] = uint8(n - 11)
@@ -438,8 +434,8 @@ func (w *huffmanBitWriter) writeOutBits() {
 	w.nbits -= 48
 	n := w.nbytes
 
-	// We over-write, but faster...
-	le.Store64(w.bytes[n:], bits)
+	// We overwrite, but faster...
+	le.Store64(w.bytes[:], n, bits)
 	n += 6
 
 	if n >= bufferFlushSize {
@@ -472,7 +468,7 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
 	w.writeBits(int32(numOffsets-1), 5)
 	w.writeBits(int32(numCodegens-4), 4)
 
-	for i := 0; i < numCodegens; i++ {
+	for i := range numCodegens {
 		value := uint(w.codegenEncoding.codes[codegenOrder[i]].len())
 		w.writeBits(int32(value), 3)
 	}
@@ -650,7 +646,7 @@ func (w *huffmanBitWriter) writeBlockDynamic(tokens *tokens, eof bool, input []b
 		w.lastHeader = 0
 	}
 
-	numLiterals, numOffsets := w.indexTokens(tokens, !sync)
+	numLiterals, numOffsets := w.indexTokens(tokens, true)
 	extraBits := 0
 	ssize, storable := w.storedSize(input)
 
@@ -785,7 +781,7 @@ func (w *huffmanBitWriter) fillTokens() {
 // literalFreq and offsetFreq, and generates literalEncoding
 // and offsetEncoding.
 // The number of literal and offset tokens is returned.
-func (w *huffmanBitWriter) indexTokens(t *tokens, filled bool) (numLiterals, numOffsets int) {
+func (w *huffmanBitWriter) indexTokens(t *tokens, alwaysEOB bool) (numLiterals, numOffsets int) {
 	//copy(w.literalFreq[:], t.litHist[:])
 	*(*[256]uint16)(w.literalFreq[:]) = t.litHist
 	//copy(w.literalFreq[256:], t.extraHist[:])
@@ -795,9 +791,10 @@ func (w *huffmanBitWriter) indexTokens(t *tokens, filled bool) (numLiterals, num
 	if t.n == 0 {
 		return
 	}
-	if filled {
-		return maxNumLit, maxNumDist
+	if alwaysEOB {
+		w.literalFreq[endBlockMarker] = 1
 	}
+
 	// get the number of literals
 	numLiterals = len(w.literalFreq)
 	for w.literalFreq[numLiterals-1] == 0 {
@@ -855,8 +852,7 @@ func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode)
 			bits |= c.code64() << (nbits & 63)
 			nbits += c.len()
 			if nbits >= 48 {
-				le.Store64(w.bytes[nbytes:], bits)
-				//*(*uint64)(unsafe.Pointer(&w.bytes[nbytes])) = bits
+				le.Store64(w.bytes[:], nbytes, bits)
 				bits >>= 48
 				nbits -= 48
 				nbytes += 6
@@ -883,8 +879,7 @@ func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode)
 			bits |= c.code64() << (nbits & 63)
 			nbits += c.len()
 			if nbits >= 48 {
-				le.Store64(w.bytes[nbytes:], bits)
-				//*(*uint64)(unsafe.Pointer(&w.bytes[nbytes])) = bits
+				le.Store64(w.bytes[:], nbytes, bits)
 				bits >>= 48
 				nbits -= 48
 				nbytes += 6
@@ -906,8 +901,7 @@ func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode)
 			bits |= uint64(extraLength) << (nbits & 63)
 			nbits += extraLengthBits
 			if nbits >= 48 {
-				le.Store64(w.bytes[nbytes:], bits)
-				//*(*uint64)(unsafe.Pointer(&w.bytes[nbytes])) = bits
+				le.Store64(w.bytes[:], nbytes, bits)
 				bits >>= 48
 				nbits -= 48
 				nbytes += 6
@@ -932,8 +926,7 @@ func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode)
 			bits |= c.code64() << (nbits & 63)
 			nbits += c.len()
 			if nbits >= 48 {
-				le.Store64(w.bytes[nbytes:], bits)
-				//*(*uint64)(unsafe.Pointer(&w.bytes[nbytes])) = bits
+				le.Store64(w.bytes[:], nbytes, bits)
 				bits >>= 48
 				nbits -= 48
 				nbytes += 6
@@ -954,8 +947,7 @@ func (w *huffmanBitWriter) writeTokens(tokens []token, leCodes, oeCodes []hcode)
 			bits |= uint64((offset-(offsetComb>>8))&matchOffsetOnlyMask) << (nbits & 63)
 			nbits += uint8(offsetComb)
 			if nbits >= 48 {
-				le.Store64(w.bytes[nbytes:], bits)
-				//*(*uint64)(unsafe.Pointer(&w.bytes[nbytes])) = bits
+				le.Store64(w.bytes[:], nbytes, bits)
 				bits >>= 48
 				nbits -= 48
 				nbytes += 6
@@ -1108,7 +1100,7 @@ func (w *huffmanBitWriter) writeBlockHuff(eof bool, input []byte, sync bool) {
 		// We must have at least 48 bits free.
 		if nbits >= 8 {
 			n := nbits >> 3
-			le.Store64(w.bytes[nbytes:], bits)
+			le.Store64(w.bytes[:], nbytes, bits)
 			bits >>= (n * 8) & 63
 			nbits -= n * 8
 			nbytes += n
@@ -1137,8 +1129,7 @@ func (w *huffmanBitWriter) writeBlockHuff(eof bool, input []byte, sync bool) {
 	// Remaining...
 	for _, t := range input {
 		if nbits >= 48 {
-			le.Store64(w.bytes[nbytes:], bits)
-			//*(*uint64)(unsafe.Pointer(&w.bytes[nbytes])) = bits
+			le.Store64(w.bytes[:], nbytes, bits)
 			bits >>= 48
 			nbits -= 48
 			nbytes += 6

vendor/github.com/klauspost/compress/flate/huffman_code.go

@@ -91,7 +91,7 @@ func generateFixedLiteralEncoding() *huffmanEncoder {
 	h := newHuffmanEncoder(literalCount)
 	codes := h.codes
 	var ch uint16
-	for ch = 0; ch < literalCount; ch++ {
+	for ch = range uint16(literalCount) {
 		var bits uint16
 		var size uint8
 		switch {

vendor/github.com/klauspost/compress/flate/inflate.go

@@ -485,7 +485,7 @@ func (f *decompressor) readHuffman() error {
 	f.nb -= 5 + 5 + 4
 
 	// (HCLEN+4)*3 bits: code lengths in the magic codeOrder order.
-	for i := 0; i < nclen; i++ {
+	for i := range nclen {
 		for f.nb < 3 {
 			if err := f.moreBits(); err != nil {
 				return err
@@ -776,7 +776,7 @@ func fixedHuffmanDecoderInit() {
 	fixedOnce.Do(func() {
 		// These come from the RFC section 3.2.6.
 		var bits [288]int
-		for i := 0; i < 144; i++ {
+		for i := range 144 {
 			bits[i] = 8
 		}
 		for i := 144; i < 256; i++ {

vendor/github.com/klauspost/compress/flate/level5.go

@@ -677,10 +677,7 @@ func (e *fastEncL5Window) matchlen(s, t int32, src []byte) int32 {
 			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
 		}
 	}
-	s1 := int(s) + maxMatchLength - 4
-	if s1 > len(src) {
-		s1 = len(src)
-	}
+	s1 := min(int(s)+maxMatchLength-4, len(src))
 
 	// Extend the match to be as long as possible.
 	return int32(matchLen(src[s:s1], src[t:]))

vendor/github.com/klauspost/compress/flate/stateless.go

@@ -56,18 +56,24 @@ func NewStatelessWriter(dst io.Writer) io.WriteCloser {
 
 // bitWriterPool contains bit writers that can be reused.
 var bitWriterPool = sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return newHuffmanBitWriter(nil)
 	},
 }
 
+// tokensPool contains tokens struct objects that can be reused
+var tokensPool = sync.Pool{
+	New: func() any {
+		return &tokens{}
+	},
+}
+
 // StatelessDeflate allows compressing directly to a Writer without retaining state.
 // When returning everything will be flushed.
 // Up to 8KB of an optional dictionary can be given which is presumed to precede the block.
 // Longer dictionaries will be truncated and will still produce valid output.
 // Sending nil dictionary is perfectly fine.
 func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error {
-	var dst tokens
 	bw := bitWriterPool.Get().(*huffmanBitWriter)
 	bw.reset(out)
 	defer func() {
@@ -91,6 +97,12 @@ func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error {
 	// For subsequent loops, keep shallow dict reference to avoid alloc+copy.
 	var inDict []byte
 
+	dst := tokensPool.Get().(*tokens)
+	dst.Reset()
+	defer func() {
+		tokensPool.Put(dst)
+	}()
+
 	for len(in) > 0 {
 		todo := in
 		if len(inDict) > 0 {
@@ -113,9 +125,9 @@ func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error {
 		}
 		// Compress
 		if len(inDict) == 0 {
-			statelessEnc(&dst, todo, int16(len(dict)))
+			statelessEnc(dst, todo, int16(len(dict)))
 		} else {
-			statelessEnc(&dst, inDict[:maxStatelessDict+len(todo)], maxStatelessDict)
+			statelessEnc(dst, inDict[:maxStatelessDict+len(todo)], maxStatelessDict)
 		}
 		isEof := eof && len(in) == 0
 
@@ -129,7 +141,7 @@ func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error {
 			// If we removed less than 1/16th, huffman compress the block.
 			bw.writeBlockHuff(isEof, uncompressed, len(in) == 0)
 		} else {
-			bw.writeBlockDynamic(&dst, isEof, uncompressed, len(in) == 0)
+			bw.writeBlockDynamic(dst, isEof, uncompressed, len(in) == 0)
 		}
 		if len(in) > 0 {
 			// Retain a dict if we have more
@@ -184,7 +196,7 @@ func statelessEnc(dst *tokens, src []byte, startAt int16) {
 	// Index until startAt
 	if startAt > 0 {
 		cv := load3232(src, 0)
-		for i := int16(0); i < startAt; i++ {
+		for i := range startAt {
 			table[hashSL(cv)] = tableEntry{offset: i}
 			cv = (cv >> 8) | (uint32(src[i+4]) << 24)
 		}

vendor/github.com/klauspost/compress/fse/bitwriter.go

@@ -143,7 +143,7 @@ func (b *bitWriter) flush32() {
 // flushAlign will flush remaining full bytes and align to next byte boundary.
 func (b *bitWriter) flushAlign() {
 	nbBytes := (b.nBits + 7) >> 3
-	for i := uint8(0); i < nbBytes; i++ {
+	for i := range nbBytes {
 		b.out = append(b.out, byte(b.bitContainer>>(i*8)))
 	}
 	b.nBits = 0

vendor/github.com/klauspost/compress/fse/compress.go

@@ -396,7 +396,7 @@ func (s *Scratch) buildCTable() error {
 			if v > largeLimit {
 				s.zeroBits = true
 			}
-			for nbOccurrences := int16(0); nbOccurrences < v; nbOccurrences++ {
+			for range v {
 				tableSymbol[position] = symbol
 				position = (position + step) & tableMask
 				for position > highThreshold {

vendor/github.com/klauspost/compress/huff0/bitwriter.go

@@ -85,7 +85,7 @@ func (b *bitWriter) flush32() {
 // flushAlign will flush remaining full bytes and align to next byte boundary.
 func (b *bitWriter) flushAlign() {
 	nbBytes := (b.nBits + 7) >> 3
-	for i := uint8(0); i < nbBytes; i++ {
+	for i := range nbBytes {
 		b.out = append(b.out, byte(b.bitContainer>>(i*8)))
 	}
 	b.nBits = 0

vendor/github.com/klauspost/compress/huff0/compress.go

@@ -276,7 +276,7 @@ func (s *Scratch) compress4X(src []byte) ([]byte, error) {
 	offsetIdx := len(s.Out)
 	s.Out = append(s.Out, sixZeros[:]...)
 
-	for i := 0; i < 4; i++ {
+	for i := range 4 {
 		toDo := src
 		if len(toDo) > segmentSize {
 			toDo = toDo[:segmentSize]
@@ -312,7 +312,7 @@ func (s *Scratch) compress4Xp(src []byte) ([]byte, error) {
 	segmentSize := (len(src) + 3) / 4
 	var wg sync.WaitGroup
 	wg.Add(4)
-	for i := 0; i < 4; i++ {
+	for i := range 4 {
 		toDo := src
 		if len(toDo) > segmentSize {
 			toDo = toDo[:segmentSize]
@@ -326,7 +326,7 @@ func (s *Scratch) compress4Xp(src []byte) ([]byte, error) {
 		}(i)
 	}
 	wg.Wait()
-	for i := 0; i < 4; i++ {
+	for i := range 4 {
 		o := s.tmpOut[i]
 		if len(o) > math.MaxUint16 {
 			// We cannot store the size in the jump table

vendor/github.com/klauspost/compress/huff0/decompress.go

@@ -626,7 +626,7 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 
 	var br [4]bitReaderBytes
 	start := 6
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
 		if start+length >= len(src) {
 			return nil, errors.New("truncated input (or invalid offset)")
@@ -798,10 +798,7 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
+		endsAt := min(offset+remainBytes, len(out))
 		br := &br[i]
 		bitsLeft := br.remaining()
 		for bitsLeft > 0 {
@@ -864,7 +861,7 @@ func (d *Decoder) decompress4X8bit(dst, src []byte) ([]byte, error) {
 func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 	var br [4]bitReaderBytes
 	start := 6
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
 		if start+length >= len(src) {
 			return nil, errors.New("truncated input (or invalid offset)")
@@ -1035,10 +1032,7 @@ func (d *Decoder) decompress4X8bitExactly(dst, src []byte) ([]byte, error) {
 	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
+		endsAt := min(offset+remainBytes, len(out))
 		br := &br[i]
 		bitsLeft := br.remaining()
 		for bitsLeft > 0 {

vendor/github.com/klauspost/compress/huff0/decompress_amd64.go

@@ -58,7 +58,7 @@ func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
 	var br [4]bitReaderShifted
 	// Decode "jump table"
 	start := 6
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		length := int(src[i*2]) | (int(src[i*2+1]) << 8)
 		if start+length >= len(src) {
 			return nil, errors.New("truncated input (or invalid offset)")
@@ -109,10 +109,7 @@ func (d *Decoder) Decompress4X(dst, src []byte) ([]byte, error) {
 	remainBytes := dstEvery - (decoded / 4)
 	for i := range br {
 		offset := dstEvery * i
-		endsAt := offset + remainBytes
-		if endsAt > len(out) {
-			endsAt = len(out)
-		}
+		endsAt := min(offset+remainBytes, len(out))
 		br := &br[i]
 		bitsLeft := br.remaining()
 		for bitsLeft > 0 {

vendor/github.com/klauspost/compress/huff0/huff0.go

@@ -201,7 +201,7 @@ func (c cTable) write(s *Scratch) error {
 	for i := range hist[:16] {
 		hist[i] = 0
 	}
-	for n := uint8(0); n < maxSymbolValue; n++ {
+	for n := range maxSymbolValue {
 		v := bitsToWeight[c[n].nBits] & 15
 		huffWeight[n] = v
 		hist[v]++
@@ -271,7 +271,7 @@ func (c cTable) estTableSize(s *Scratch) (sz int, err error) {
 	for i := range hist[:16] {
 		hist[i] = 0
 	}
-	for n := uint8(0); n < maxSymbolValue; n++ {
+	for n := range maxSymbolValue {
 		v := bitsToWeight[c[n].nBits] & 15
 		huffWeight[n] = v
 		hist[v]++

vendor/github.com/klauspost/compress/internal/le/unsafe_disabled.go

@@ -37,6 +37,6 @@ func Store32(b []byte, v uint32) {
 }
 
 // Store64 will store v at b.
-func Store64(b []byte, v uint64) {
-	binary.LittleEndian.PutUint64(b, v)
+func Store64[I Indexer](b []byte, i I, v uint64) {
+	binary.LittleEndian.PutUint64(b[i:], v)
 }

vendor/github.com/klauspost/compress/internal/le/unsafe_enabled.go

@@ -38,18 +38,15 @@ func Load64[I Indexer](b []byte, i I) uint64 {
 
 // Store16 will store v at b.
 func Store16(b []byte, v uint16) {
-	//binary.LittleEndian.PutUint16(b, v)
 	*(*uint16)(unsafe.Pointer(unsafe.SliceData(b))) = v
 }
 
 // Store32 will store v at b.
 func Store32(b []byte, v uint32) {
-	//binary.LittleEndian.PutUint32(b, v)
 	*(*uint32)(unsafe.Pointer(unsafe.SliceData(b))) = v
 }
 
-// Store64 will store v at b.
-func Store64(b []byte, v uint64) {
-	//binary.LittleEndian.PutUint64(b, v)
-	*(*uint64)(unsafe.Pointer(unsafe.SliceData(b))) = v
+// Store64 will store v at b[i:].
+func Store64[I Indexer](b []byte, i I, v uint64) {
+	*(*uint64)(unsafe.Add(unsafe.Pointer(unsafe.SliceData(b)), i)) = v
 }

vendor/github.com/klauspost/compress/internal/snapref/decode.go

@@ -209,7 +209,7 @@ func (r *Reader) fill() error {
 			if !r.readFull(r.buf[:len(magicBody)], false) {
 				return r.err
 			}
-			for i := 0; i < len(magicBody); i++ {
+			for i := range len(magicBody) {
 				if r.buf[i] != magicBody[i] {
 					r.err = ErrCorrupt
 					return r.err

vendor/github.com/klauspost/compress/internal/snapref/encode.go

@@ -20,8 +20,10 @@ import (
 func Encode(dst, src []byte) []byte {
 	if n := MaxEncodedLen(len(src)); n < 0 {
 		panic(ErrTooLarge)
-	} else if len(dst) < n {
+	} else if cap(dst) < n {
 		dst = make([]byte, n)
+	} else {
+		dst = dst[:n]
 	}
 
 	// The block starts with the varint-encoded length of the decompressed bytes.

vendor/github.com/klauspost/compress/s2/README.md

@@ -1,3 +1,17 @@
+# MinLZ 
+
+I have taken the experiences from this library and created a backwards compatible compression package called MinLZ.
+
+That package will seamlessly decode S2 content, making the transition from this package fairly trivial.
+
+There are many improvements to pretty much all aspects of S2 since we have "broken free" of the Snappy format specification.
+You can read a writeup on [Design and Improvements over S2](https://gist.github.com/klauspost/a25b66198cdbdf7b5b224f670c894ed5).
+
+The only aspect not covered is custom dictionary encoding. While I do intend to fix errors in this package, 
+I do not expect to make significant improvements, since I consider MinLZ a better basis for going forward.
+
+See https://github.com/minio/minlz for all details. 
+
 # S2 Compression
 
 S2 is an extension of [Snappy](https://github.com/google/snappy).

vendor/github.com/klauspost/compress/s2/encode.go

@@ -117,8 +117,10 @@ func EstimateBlockSize(src []byte) (d int) {
 func EncodeBetter(dst, src []byte) []byte {
 	if n := MaxEncodedLen(len(src)); n < 0 {
 		panic(ErrTooLarge)
-	} else if len(dst) < n {
+	} else if cap(dst) < n {
 		dst = make([]byte, n)
+	} else {
+		dst = dst[:n]
 	}
 
 	// The block starts with the varint-encoded length of the decompressed bytes.
@@ -159,8 +161,10 @@ func EncodeBetter(dst, src []byte) []byte {
 func EncodeBest(dst, src []byte) []byte {
 	if n := MaxEncodedLen(len(src)); n < 0 {
 		panic(ErrTooLarge)
-	} else if len(dst) < n {
+	} else if cap(dst) < n {
 		dst = make([]byte, n)
+	} else {
+		dst = dst[:n]
 	}
 
 	// The block starts with the varint-encoded length of the decompressed bytes.

vendor/github.com/klauspost/compress/s2/encode_all.go

@@ -903,10 +903,7 @@ func encodeBlockDictGo(dst, src []byte, dict *Dict) (d int) {
 	// sLimit is when to stop looking for offset/length copies. The inputMargin
 	// lets us use a fast path for emitLiteral in the main loop, while we are
 	// looking for copies.
-	sLimit := len(src) - inputMargin
-	if sLimit > MaxDictSrcOffset-maxAhead {
-		sLimit = MaxDictSrcOffset - maxAhead
-	}
+	sLimit := min(len(src)-inputMargin, MaxDictSrcOffset-maxAhead)
 
 	// Bail if we can't compress to at least this.
 	dstLimit := len(src) - len(src)>>5 - 5

vendor/github.com/klauspost/compress/s2/encode_best.go

@@ -42,10 +42,7 @@ func encodeBlockBest(dst, src []byte, dict *Dict) (d int) {
 	if len(src) < minNonLiteralBlockSize {
 		return 0
 	}
-	sLimitDict := len(src) - inputMargin
-	if sLimitDict > MaxDictSrcOffset-inputMargin {
-		sLimitDict = MaxDictSrcOffset - inputMargin
-	}
+	sLimitDict := min(len(src)-inputMargin, MaxDictSrcOffset-inputMargin)
 
 	var lTable [maxLTableSize]uint64
 	var sTable [maxSTableSize]uint64

vendor/github.com/klauspost/compress/s2/encode_better.go

@@ -914,10 +914,7 @@ func encodeBlockBetterDict(dst, src []byte, dict *Dict) (d int) {
 		debug = false
 	)
 
-	sLimit := len(src) - inputMargin
-	if sLimit > MaxDictSrcOffset-maxAhead {
-		sLimit = MaxDictSrcOffset - maxAhead
-	}
+	sLimit := min(len(src)-inputMargin, MaxDictSrcOffset-maxAhead)
 	if len(src) < minNonLiteralBlockSize {
 		return 0
 	}

vendor/github.com/klauspost/compress/s2/index.go

@@ -72,7 +72,7 @@ func (i *Index) add(compressedOffset, uncompressedOffset int64) error {
 			return fmt.Errorf("internal error: Earlier uncompressed received (%d > %d)", latest.uncompressedOffset, uncompressedOffset)
 		}
 		if latest.compressedOffset > compressedOffset {
-			return fmt.Errorf("internal error: Earlier compressed received (%d > %d)", latest.uncompressedOffset, uncompressedOffset)
+			return fmt.Errorf("internal error: Earlier compressed received (%d > %d)", latest.compressedOffset, compressedOffset)
 		}
 		if latest.uncompressedOffset+minIndexDist > uncompressedOffset {
 			// Only add entry if distance is large enough.

vendor/github.com/klauspost/compress/s2/reader.go

@@ -1046,7 +1046,7 @@ func (r *Reader) ReadByte() (byte, error) {
 		return c, nil
 	}
 	var tmp [1]byte
-	for i := 0; i < 10; i++ {
+	for range 10 {
 		n, err := r.Read(tmp[:])
 		if err != nil {
 			return 0, err

vendor/github.com/klauspost/compress/s2/writer.go

@@ -47,7 +47,7 @@ func NewWriter(w io.Writer, opts ...WriterOption) *Writer {
 	w2.obufLen = obufHeaderLen + MaxEncodedLen(w2.blockSize)
 	w2.paramsOK = true
 	w2.ibuf = make([]byte, 0, w2.blockSize)
-	w2.buffers.New = func() interface{} {
+	w2.buffers.New = func() any {
 		return make([]byte, w2.obufLen)
 	}
 	w2.Reset(w)

vendor/github.com/klauspost/compress/zlib/reader.go

@@ -132,7 +132,7 @@ func (z *reader) Close() error {
 }
 
 func (z *reader) Reset(r io.Reader, dict []byte) error {
-	*z = reader{decompressor: z.decompressor}
+	*z = reader{decompressor: z.decompressor, digest: z.digest}
 	if fr, ok := r.(flate.Reader); ok {
 		z.r = fr
 	} else {

vendor/github.com/klauspost/compress/zstd/bitwriter.go

@@ -88,7 +88,7 @@ func (b *bitWriter) flush32() {
 // flushAlign will flush remaining full bytes and align to next byte boundary.
 func (b *bitWriter) flushAlign() {
 	nbBytes := (b.nBits + 7) >> 3
-	for i := uint8(0); i < nbBytes; i++ {
+	for i := range nbBytes {
 		b.out = append(b.out, byte(b.bitContainer>>(i*8)))
 	}
 	b.nBits = 0

vendor/github.com/klauspost/compress/zstd/blockdec.go

@@ -54,11 +54,11 @@ const (
 )
 
 var (
-	huffDecoderPool = sync.Pool{New: func() interface{} {
+	huffDecoderPool = sync.Pool{New: func() any {
 		return &huff0.Scratch{}
 	}}
 
-	fseDecoderPool = sync.Pool{New: func() interface{} {
+	fseDecoderPool = sync.Pool{New: func() any {
 		return &fseDecoder{}
 	}}
 )
@@ -553,7 +553,7 @@ func (b *blockDec) prepareSequences(in []byte, hist *history) (err error) {
 		if compMode&3 != 0 {
 			return errors.New("corrupt block: reserved bits not zero")
 		}
-		for i := uint(0); i < 3; i++ {
+		for i := range uint(3) {
 			mode := seqCompMode((compMode >> (6 - i*2)) & 3)
 			if debugDecoder {
 				println("Table", tableIndex(i), "is", mode)

vendor/github.com/klauspost/compress/zstd/decoder.go

@@ -373,11 +373,9 @@ func (d *Decoder) DecodeAll(input, dst []byte) ([]byte, error) {
 		if cap(dst) == 0 && !d.o.limitToCap {
 			// Allocate len(input) * 2 by default if nothing is provided
 			// and we didn't get frame content size.
-			size := len(input) * 2
-			// Cap to 1 MB.
-			if size > 1<<20 {
-				size = 1 << 20
-			}
+			size := min(
+				// Cap to 1 MB.
+				len(input)*2, 1<<20)
 			if uint64(size) > d.o.maxDecodedSize {
 				size = int(d.o.maxDecodedSize)
 			}

vendor/github.com/klauspost/compress/zstd/dict.go

@@ -194,17 +194,17 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 	hist := o.History
 	contents := o.Contents
 	debug := o.DebugOut != nil
-	println := func(args ...interface{}) {
+	println := func(args ...any) {
 		if o.DebugOut != nil {
 			fmt.Fprintln(o.DebugOut, args...)
 		}
 	}
-	printf := func(s string, args ...interface{}) {
+	printf := func(s string, args ...any) {
 		if o.DebugOut != nil {
 			fmt.Fprintf(o.DebugOut, s, args...)
 		}
 	}
-	print := func(args ...interface{}) {
+	print := func(args ...any) {
 		if o.DebugOut != nil {
 			fmt.Fprint(o.DebugOut, args...)
 		}
@@ -424,16 +424,10 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 	}
 
 	// Literal table
-	avgSize := litTotal
-	if avgSize > huff0.BlockSizeMax/2 {
-		avgSize = huff0.BlockSizeMax / 2
-	}
+	avgSize := min(litTotal, huff0.BlockSizeMax/2)
 	huffBuff := make([]byte, 0, avgSize)
 	// Target size
-	div := litTotal / avgSize
-	if div < 1 {
-		div = 1
-	}
+	div := max(litTotal/avgSize, 1)
 	if debug {
 		println("Huffman weights:")
 	}
@@ -454,7 +448,7 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 		huffBuff = append(huffBuff, 255)
 	}
 	scratch := &huff0.Scratch{TableLog: 11}
-	for tries := 0; tries < 255; tries++ {
+	for tries := range 255 {
 		scratch = &huff0.Scratch{TableLog: 11}
 		_, _, err = huff0.Compress1X(huffBuff, scratch)
 		if err == nil {
@@ -471,7 +465,7 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 
 			// Bail out.... Just generate something
 			huffBuff = append(huffBuff, bytes.Repeat([]byte{255}, 10000)...)
-			for i := 0; i < 128; i++ {
+			for i := range 128 {
 				huffBuff = append(huffBuff, byte(i))
 			}
 			continue

vendor/github.com/klauspost/compress/zstd/enc_base.go

@@ -8,7 +8,7 @@ import (
 )
 
 const (
-	dictShardBits = 6
+	dictShardBits = 7
 )
 
 type fastBase struct {
@@ -41,11 +41,9 @@ func (e *fastBase) AppendCRC(dst []byte) []byte {
 // or a window size small enough to contain the input size, if > 0.
 func (e *fastBase) WindowSize(size int64) int32 {
 	if size > 0 && size < int64(e.maxMatchOff) {
-		b := int32(1) << uint(bits.Len(uint(size)))
-		// Keep minimum window.
-		if b < 1024 {
-			b = 1024
-		}
+		b := max(
+			// Keep minimum window.
+			int32(1)<<uint(bits.Len(uint(size))), 1024)
 		return b
 	}
 	return e.maxMatchOff

vendor/github.com/klauspost/compress/zstd/enc_best.go

@@ -158,11 +158,9 @@ func (e *bestFastEncoder) Encode(blk *blockEnc, src []byte) {
 
 	// Use this to estimate literal cost.
 	// Scaled by 10 bits.
-	bitsPerByte := int32((compress.ShannonEntropyBits(src) * 1024) / len(src))
-	// Huffman can never go < 1 bit/byte
-	if bitsPerByte < 1024 {
-		bitsPerByte = 1024
-	}
+	bitsPerByte := max(
+		// Huffman can never go < 1 bit/byte
+		int32((compress.ShannonEntropyBits(src)*1024)/len(src)), 1024)
 
 	// Override src
 	src = e.hist
@@ -235,10 +233,7 @@ encodeLoop:
 				// Extend candidate match backwards as far as possible.
 				// Do not extend repeats as we can assume they are optimal
 				// and offsets change if s == nextEmit.
-				tMin := s - e.maxMatchOff
-				if tMin < 0 {
-					tMin = 0
-				}
+				tMin := max(s-e.maxMatchOff, 0)
 				for offset > tMin && s > nextEmit && src[offset-1] == src[s-1] && l < maxMatchLength {
 					s--
 					offset--
@@ -382,10 +377,7 @@ encodeLoop:
 			nextEmit = s
 
 			// Index skipped...
-			end := s
-			if s > sLimit+4 {
-				end = sLimit + 4
-			}
+			end := min(s, sLimit+4)
 			off := index0 + e.cur
 			for index0 < end {
 				cv0 := load6432(src, index0)
@@ -444,10 +436,7 @@ encodeLoop:
 		nextEmit = s
 
 		// Index old s + 1 -> s - 1 or sLimit
-		end := s
-		if s > sLimit-4 {
-			end = sLimit - 4
-		}
+		end := min(s, sLimit-4)
 
 		off := index0 + e.cur
 		for index0 < end {

vendor/github.com/klauspost/compress/zstd/enc_better.go

@@ -190,10 +190,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
 						repIndex--
 						start--
@@ -252,10 +249,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
 						repIndex--
 						start--
@@ -480,10 +474,7 @@ encodeLoop:
 		l := matched
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
 			s--
 			t--
@@ -719,10 +710,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
 						repIndex--
 						start--
@@ -783,10 +771,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
 						repIndex--
 						start--
@@ -1005,10 +990,7 @@ encodeLoop:
 		l := matched
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
 			s--
 			t--

vendor/github.com/klauspost/compress/zstd/enc_dfast.go

@@ -13,7 +13,7 @@ const (
 	dFastLongLen       = 8                       // Bytes used for table hash
 
 	dLongTableShardCnt  = 1 << (dFastLongTableBits - dictShardBits) // Number of shards in the table
-	dLongTableShardSize = dFastLongTableSize / tableShardCnt        // Size of an individual shard
+	dLongTableShardSize = dFastLongTableSize / dLongTableShardCnt   // Size of an individual shard
 
 	dFastShortTableBits = tableBits                // Bits used in the short match table
 	dFastShortTableSize = 1 << dFastShortTableBits // Size of the table
@@ -149,10 +149,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
 						repIndex--
 						start--
@@ -266,10 +263,7 @@ encodeLoop:
 		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
 			s--
 			t--
@@ -462,10 +456,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] {
 						repIndex--
 						start--
@@ -576,10 +567,7 @@ encodeLoop:
 		l := int32(matchLen(src[s+4:], src[t+4:])) + 4
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] {
 			s--
 			t--
@@ -809,10 +797,7 @@ encodeLoop:
 					// and have to do special offset treatment.
 					startLimit := nextEmit + 1
 
-					tMin := s - e.maxMatchOff
-					if tMin < 0 {
-						tMin = 0
-					}
+					tMin := max(s-e.maxMatchOff, 0)
 					for repIndex > tMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch-1 {
 						repIndex--
 						start--
@@ -927,10 +912,7 @@ encodeLoop:
 		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
 			s--
 			t--

vendor/github.com/klauspost/compress/zstd/enc_fast.go

@@ -143,10 +143,7 @@ encodeLoop:
 				// and have to do special offset treatment.
 				startLimit := nextEmit + 1
 
-				sMin := s - e.maxMatchOff
-				if sMin < 0 {
-					sMin = 0
-				}
+				sMin := max(s-e.maxMatchOff, 0)
 				for repIndex > sMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch {
 					repIndex--
 					start--
@@ -223,10 +220,7 @@ encodeLoop:
 		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
 			s--
 			t--
@@ -387,10 +381,7 @@ encodeLoop:
 				// and have to do special offset treatment.
 				startLimit := nextEmit + 1
 
-				sMin := s - e.maxMatchOff
-				if sMin < 0 {
-					sMin = 0
-				}
+				sMin := max(s-e.maxMatchOff, 0)
 				for repIndex > sMin && start > startLimit && src[repIndex-1] == src[start-1] {
 					repIndex--
 					start--
@@ -469,10 +460,7 @@ encodeLoop:
 		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] {
 			s--
 			t--
@@ -655,10 +643,7 @@ encodeLoop:
 				// and have to do special offset treatment.
 				startLimit := nextEmit + 1
 
-				sMin := s - e.maxMatchOff
-				if sMin < 0 {
-					sMin = 0
-				}
+				sMin := max(s-e.maxMatchOff, 0)
 				for repIndex > sMin && start > startLimit && src[repIndex-1] == src[start-1] && seq.matchLen < maxMatchLength-zstdMinMatch {
 					repIndex--
 					start--
@@ -735,10 +720,7 @@ encodeLoop:
 		l := e.matchlen(s+4, t+4, src) + 4
 
 		// Extend backwards
-		tMin := s - e.maxMatchOff
-		if tMin < 0 {
-			tMin = 0
-		}
+		tMin := max(s-e.maxMatchOff, 0)
 		for t > tMin && s > nextEmit && src[t-1] == src[s-1] && l < maxMatchLength {
 			s--
 			t--

vendor/github.com/klauspost/compress/zstd/framedec.go

@@ -238,10 +238,7 @@ func (d *frameDec) reset(br byteBuffer) error {
 
 	if d.WindowSize == 0 && d.SingleSegment {
 		// We may not need window in this case.
-		d.WindowSize = d.FrameContentSize
-		if d.WindowSize < MinWindowSize {
-			d.WindowSize = MinWindowSize
-		}
+		d.WindowSize = max(d.FrameContentSize, MinWindowSize)
 		if d.WindowSize > d.o.maxDecodedSize {
 			if debugDecoder {
 				printf("window size %d > max %d\n", d.WindowSize, d.o.maxWindowSize)

vendor/github.com/klauspost/compress/zstd/fse_encoder.go

@@ -149,7 +149,7 @@ func (s *fseEncoder) buildCTable() error {
 			if v > largeLimit {
 				s.zeroBits = true
 			}
-			for nbOccurrences := int16(0); nbOccurrences < v; nbOccurrences++ {
+			for range v {
 				tableSymbol[position] = symbol
 				position = (position + step) & tableMask
 				for position > highThreshold {

vendor/github.com/klauspost/compress/zstd/seqdec.go

@@ -231,10 +231,7 @@ func (s *sequenceDecs) decodeSync(hist []byte) error {
 	llTable, mlTable, ofTable := s.litLengths.fse.dt[:maxTablesize], s.matchLengths.fse.dt[:maxTablesize], s.offsets.fse.dt[:maxTablesize]
 	llState, mlState, ofState := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state
 	out := s.out
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
+	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
 
 	if debugDecoder {
 		println("decodeSync: decoding", seqs, "sequences", br.remain(), "bits remain on stream")

vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go

@@ -79,10 +79,7 @@ func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
 
 	br := s.br
 
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
+	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
 
 	ctx := decodeSyncAsmContext{
 		llTable:     s.litLengths.fse.dt[:maxTablesize],
@@ -237,10 +234,7 @@ func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmC
 func (s *sequenceDecs) decode(seqs []seqVals) error {
 	br := s.br
 
-	maxBlockSize := maxCompressedBlockSize
-	if s.windowSize < maxBlockSize {
-		maxBlockSize = s.windowSize
-	}
+	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
 
 	ctx := decodeAsmContext{
 		llTable:   s.litLengths.fse.dt[:maxTablesize],

vendor/github.com/klauspost/compress/zstd/simple_go124.go

@@ -0,0 +1,56 @@
+// Copyright 2025+ Klaus Post. All rights reserved.
+// License information can be found in the LICENSE file.
+
+//go:build go1.24
+
+package zstd
+
+import (
+	"errors"
+	"runtime"
+	"sync"
+	"weak"
+)
+
+var weakMu sync.Mutex
+var simpleEnc weak.Pointer[Encoder]
+var simpleDec weak.Pointer[Decoder]
+
+// EncodeTo appends the encoded data from src to dst.
+func EncodeTo(dst []byte, src []byte) []byte {
+	weakMu.Lock()
+	enc := simpleEnc.Value()
+	if enc == nil {
+		var err error
+		enc, err = NewWriter(nil, WithEncoderConcurrency(runtime.NumCPU()), WithWindowSize(1<<20), WithLowerEncoderMem(true), WithZeroFrames(true))
+		if err != nil {
+			panic("failed to create simple encoder: " + err.Error())
+		}
+		simpleEnc = weak.Make(enc)
+	}
+	weakMu.Unlock()
+
+	return enc.EncodeAll(src, dst)
+}
+
+// DecodeTo appends the decoded data from src to dst.
+// The maximum decoded size is 1GiB,
+// not including what may already be in dst.
+func DecodeTo(dst []byte, src []byte) ([]byte, error) {
+	weakMu.Lock()
+	dec := simpleDec.Value()
+	if dec == nil {
+		var err error
+		dec, err = NewReader(nil, WithDecoderConcurrency(runtime.NumCPU()), WithDecoderLowmem(true), WithDecoderMaxMemory(1<<30))
+		if err != nil {
+			weakMu.Unlock()
+			return nil, errors.New("failed to create simple decoder: " + err.Error())
+		}
+		runtime.SetFinalizer(dec, func(d *Decoder) {
+			d.Close()
+		})
+		simpleDec = weak.Make(dec)
+	}
+	weakMu.Unlock()
+	return dec.DecodeAll(src, dst)
+}

vendor/github.com/klauspost/compress/zstd/snappy.go

@@ -257,7 +257,7 @@ func (r *SnappyConverter) Convert(in io.Reader, w io.Writer) (int64, error) {
 			if !r.readFull(r.buf[:len(snappyMagicBody)], false) {
 				return written, r.err
 			}
-			for i := 0; i < len(snappyMagicBody); i++ {
+			for i := range len(snappyMagicBody) {
 				if r.buf[i] != snappyMagicBody[i] {
 					println("r.buf[i] != snappyMagicBody[i]", r.buf[i], snappyMagicBody[i], i)
 					r.err = ErrSnappyCorrupt

vendor/github.com/klauspost/compress/zstd/zip.go

@@ -19,7 +19,7 @@ const ZipMethodWinZip = 93
 const ZipMethodPKWare = 20
 
 // zipReaderPool is the default reader pool.
-var zipReaderPool = sync.Pool{New: func() interface{} {
+var zipReaderPool = sync.Pool{New: func() any {
 	z, err := NewReader(nil, WithDecoderLowmem(true), WithDecoderMaxWindow(128<<20), WithDecoderConcurrency(1))
 	if err != nil {
 		panic(err)

vendor/github.com/klauspost/compress/zstd/zstd.go

@@ -98,13 +98,13 @@ var (
 	ErrDecoderNilInput = errors.New("nil input provided as reader")
 )
 
-func println(a ...interface{}) {
+func println(a ...any) {
 	if debug || debugDecoder || debugEncoder {
 		log.Println(a...)
 	}
 }
 
-func printf(format string, a ...interface{}) {
+func printf(format string, a ...any) {
 	if debug || debugDecoder || debugEncoder {
 		log.Printf(format, a...)
 	}

vendor/github.com/mattn/go-runewidth/benchstat.txt

@@ -0,0 +1,43 @@
+goos: darwin
+goarch: arm64
+pkg: github.com/mattn/go-runewidth
+cpu: Apple M2
+                                   │   old.txt    │              new.txt               │
+                                   │    sec/op    │   sec/op     vs base               │
+String1WidthAll/regular-8            108.92m ± 0%   35.09m ± 3%  -67.78% (p=0.002 n=6)
+String1WidthAll/lut-8                 93.97m ± 0%   18.70m ± 0%  -80.10% (p=0.002 n=6)
+String1Width768/regular-8             60.62µ ± 1%   11.54µ ± 0%  -80.97% (p=0.002 n=6)
+String1Width768/lut-8                 60.66µ ± 1%   11.43µ ± 0%  -81.16% (p=0.002 n=6)
+String1WidthAllEastAsian/regular-8   115.13m ± 1%   40.79m ± 8%  -64.57% (p=0.002 n=6)
+String1WidthAllEastAsian/lut-8        93.65m ± 0%   18.70m ± 2%  -80.03% (p=0.002 n=6)
+String1Width768EastAsian/regular-8    75.32µ ± 0%   23.49µ ± 0%  -68.82% (p=0.002 n=6)
+String1Width768EastAsian/lut-8        60.76µ ± 0%   11.50µ ± 0%  -81.07% (p=0.002 n=6)
+geomean                               2.562m        604.5µ       -76.41%
+
+                                   │   old.txt    │                 new.txt                 │
+                                   │     B/op     │    B/op      vs base                    │
+String1WidthAll/regular-8            106.3Mi ± 0%    0.0Mi ± 0%  -100.00% (p=0.002 n=6)
+String1WidthAll/lut-8                106.3Mi ± 0%    0.0Mi ± 0%  -100.00% (p=0.002 n=6)
+String1Width768/regular-8            75.00Ki ± 0%   0.00Ki ± 0%  -100.00% (p=0.002 n=6)
+String1Width768/lut-8                75.00Ki ± 0%   0.00Ki ± 0%  -100.00% (p=0.002 n=6)
+String1WidthAllEastAsian/regular-8   106.3Mi ± 0%    0.0Mi ± 0%  -100.00% (p=0.002 n=6)
+String1WidthAllEastAsian/lut-8       106.3Mi ± 0%    0.0Mi ± 0%  -100.00% (p=0.002 n=6)
+String1Width768EastAsian/regular-8   75.00Ki ± 0%   0.00Ki ± 0%  -100.00% (p=0.002 n=6)
+String1Width768EastAsian/lut-8       75.00Ki ± 0%   0.00Ki ± 0%  -100.00% (p=0.002 n=6)
+geomean                              2.790Mi                     ?                      ¹ ²
+¹ summaries must be >0 to compute geomean
+² ratios must be >0 to compute geomean
+
+                                   │   old.txt   │                 new.txt                 │
+                                   │  allocs/op  │  allocs/op   vs base                    │
+String1WidthAll/regular-8            3.342M ± 0%   0.000M ± 0%  -100.00% (p=0.002 n=6)
+String1WidthAll/lut-8                3.342M ± 0%   0.000M ± 0%  -100.00% (p=0.002 n=6)
+String1Width768/regular-8            2.304k ± 0%   0.000k ± 0%  -100.00% (p=0.002 n=6)
+String1Width768/lut-8                2.304k ± 0%   0.000k ± 0%  -100.00% (p=0.002 n=6)
+String1WidthAllEastAsian/regular-8   3.342M ± 0%   0.000M ± 0%  -100.00% (p=0.002 n=6)
+String1WidthAllEastAsian/lut-8       3.342M ± 0%   0.000M ± 0%  -100.00% (p=0.002 n=6)
+String1Width768EastAsian/regular-8   2.304k ± 0%   0.000k ± 0%  -100.00% (p=0.002 n=6)
+String1Width768EastAsian/lut-8       2.304k ± 0%   0.000k ± 0%  -100.00% (p=0.002 n=6)
+geomean                              87.75k                     ?                      ¹ ²
+¹ summaries must be >0 to compute geomean
+² ratios must be >0 to compute geomean

vendor/github.com/mattn/go-runewidth/new.txt

@@ -0,0 +1,54 @@
+goos: darwin
+goarch: arm64
+pkg: github.com/mattn/go-runewidth
+cpu: Apple M2
+BenchmarkString1WidthAll/regular-8    	      33	  35033923 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/regular-8    	      33	  34965112 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/regular-8    	      33	  36307234 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/regular-8    	      33	  35007705 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/regular-8    	      33	  35154182 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/regular-8    	      34	  35155400 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/lut-8        	      63	  18688500 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/lut-8        	      63	  18712474 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/lut-8        	      63	  18700211 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/lut-8        	      62	  18694179 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/lut-8        	      62	  18708392 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAll/lut-8        	      63	  18770608 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/regular-8    	  104137	     11526 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/regular-8    	  103986	     11540 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/regular-8    	  104079	     11552 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/regular-8    	  103963	     11530 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/regular-8    	  103714	     11538 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/regular-8    	  104181	     11537 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/lut-8        	  105150	     11420 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/lut-8        	  104778	     11423 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/lut-8        	  105069	     11422 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/lut-8        	  105127	     11475 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/lut-8        	  104742	     11433 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768/lut-8        	  105163	     11432 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/regular-8         	      28	  40723347 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/regular-8         	      28	  40790299 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/regular-8         	      28	  40801338 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/regular-8         	      28	  40798216 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/regular-8         	      28	  44135253 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/regular-8         	      28	  40779546 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/lut-8             	      62	  18694165 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/lut-8             	      62	  18685047 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/lut-8             	      62	  18689273 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/lut-8             	      62	  19150346 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/lut-8             	      63	  19126154 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1WidthAllEastAsian/lut-8             	      62	  18712619 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/regular-8         	   50775	     23595 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/regular-8         	   51061	     23563 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/regular-8         	   51057	     23492 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/regular-8         	   51138	     23445 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/regular-8         	   51195	     23469 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/regular-8         	   51087	     23482 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/lut-8             	  104559	     11549 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/lut-8             	  104508	     11483 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/lut-8             	  104296	     11503 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/lut-8             	  104606	     11485 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/lut-8             	  104588	     11495 ns/op	       0 B/op	       0 allocs/op
+BenchmarkString1Width768EastAsian/lut-8             	  104602	     11518 ns/op	       0 B/op	       0 allocs/op
+PASS
+ok  	github.com/mattn/go-runewidth	64.455s