Sync TON mutation docs and remove legacy data

Author: mysteryon88

examples/foo.fc

@@ -6,7 +6,7 @@
 This file intentionally exercises a broad slice of func.rules.
 The code is small enough to compile quickly, but rich enough to
 generate mutants for operator swaps, stdlib helper swaps, method
-specifiers, send/reserve modes, and muton-style statement rewrites.
+specifiers, send/reserve modes, and statement rewrites.
 
 THROW_IF
 THROW_UNLESS
@@ -54,7 +54,7 @@ cell make_sample_cell() inline_ref {
         .end_cell();
 }
 
-int muton_ops(int a, int b) impure {
+int coverage_ops(int a, int b) impure {
     int cond = a != b;
     int count = 2;
     int steps = 0;
@@ -223,7 +223,7 @@ int muton_ops(int a, int b) impure {
 () main() impure {
     cell sample = make_sample_cell();
     int score = inline_sum(2, 3) + ref_sum(9, 4) + noisy_method() + default_method();
-    int changed = muton_ops(score, 6);
+    int changed = coverage_ops(score, 6);
     stdlib_ops(sample);
     throw_unless(33, changed != 0);
     throw_if(34, changed == 0);

examples/foo.tolk

@@ -148,7 +148,7 @@ get fun currentCounter(): int {
     return 0;
 }
 
-fun mutonOps(flag: bool): int {
+fun coverageOps(flag: bool): int {
     var a = 10;
     var b = 6;
     var steps = 0;

examples/tolk-bench

@@ -1,14 +1,14 @@
 # UniversalMutator + TON (Tact / FunC / Tolk)
 
-Это форк `universalmutator`, в который добавлена поддержка трех TON-языков:
+This is a fork of `universalmutator` with support for three TON languages:
 
-- `tact` для файлов `.tact`
-- `func` для файлов `.fc` и `.func`
-- `tolk` для файлов `.tolk`
+- `tact` for `.tact` files
+- `func` for `.fc` and `.func` files
+- `tolk` for `.tolk` files
 
-## Как запускать именно этот форк
+## How to run this fork
 
-У пакета уже есть `console_scripts` в `setup.py`. После установки форка доступны такие команды:
+The package already defines `console_scripts` in `setup.py`. After installing the fork, these commands are available:
 
 - `mutate`
 - `analyze_mutants`
@@ -18,9 +18,9 @@
 - `prune_mutants`
 - `intersect_mutants`
 
-### Вариант 1: editable install для разработки
+### Option 1: editable install for development
 
-Это лучший режим, если ты активно правишь код форка.
+This is the best setup if you actively modify the fork itself.
 
 PowerShell:
 
@@ -32,21 +32,21 @@ python -m pip install -e . --no-build-isolation
 mutate --help
 ```
 
-Что это дает:
+What this gives you:
 
-- CLI появляется сразу
-- используются текущие файлы из репозитория
-- после правок не нужно пересобирать wheel
+- the CLI is available immediately
+- the current repository files are used directly
+- no wheel rebuild is needed after code changes
 
-Если CLI не нужен, можно запускать напрямую модуль:
+If you do not need the CLI, you can run the module directly:
 
 ```sh
 python -m universalmutator.genmutants --help
 ```
 
-### Вариант 2: собрать wheel и поставить свою версию как обычный пакет
+### Option 2: build a wheel and install it as a regular package
 
-Это режим для полноценного локального CLI-пакета.
+This is the setup for a full local CLI package.
 
 PowerShell:
 
@@ -59,13 +59,13 @@ python -m pip install --force-reinstall dist\*.whl
 mutate --help
 ```
 
-Если `python -m build` пишет `No module named build`, сначала поставь:
+If `python -m build` prints `No module named build`, install it first:
 
 ```sh
 python -m pip install build
 ```
 
-Для этого форка wheel локально собирается командой:
+For this fork, the wheel is built locally with:
 
 ```sh
 python -m build --wheel --no-isolation
@@ -85,10 +85,9 @@ python -m universalmutator.genmutants \
   --comby \
   --noCheck \
   > examples/func2_all/check.out 2>&1
-
 ```
 
-## Установка компиляторов TON
+## Installing TON compilers
 
 ### Tact
 
@@ -111,26 +110,26 @@ npm i -g @ton-community/func-js
 func-js -h
 ```
 
-## Генерация мутантов
+## Mutant generation
 
-Смысл такой:
+The basic model is:
 
-- `mutate` генерирует мутантов
-- для каждого мутанта для `tact` / `tolk` / `func` compile-check запускается автоматически через language handler
-- если команда возвращает `0`, мутант считается `VALID`
-- `--cmd` нужен только если хочется принудительно переопределить команду проверки
-- `--cmd` имеет приоритет над встроенными TON handler-ами и подходит для нестандартного компилятора, обёртки или локального скрипта
-- В regex-режиме многострочные блок-комментарии `/* ... */`, `{- ... -}` и пустые строки глобально пропускаются для всех языков
+- `mutate` generates mutants
+- for each mutant in `tact` / `tolk` / `func`, compile-check runs automatically through the language handler
+- if the command returns `0`, the mutant is considered `VALID`
+- `--cmd` is only needed if you want to force a custom validation command
+- `--cmd` has priority over the built-in TON handlers and is useful for a custom compiler, wrapper, or local script
+- in regex mode, multiline block comments `/* ... */`, `{- ... -}`, and empty lines are globally skipped for all languages
 
-## Изменения ядра (mutator.py)
+## Core changes (`mutator.py`)
 
-- В regex-режиме мутатор пропускает пустые строки и блок-комментарии `/* ... */` и `{- ... -}` для всех языков, чтобы не мутировать комментарии и не раздувать шум.
-- Для FunC добавлен быстрый фильтр в regex-режиме: если строка содержит `store_uint` или `store_int` и выражение с длинной суммой чисел (5+ числовых литералов), то числовые мутации из `universal.rules` вида `(\D)(\d+)(\D)` пропускаются. Это ускоряет генерацию и уменьшает пачку `INVALID` на выражениях длины битов. Фильтр включается только при наличии `func.rules` и не влияет на другие языки или `--comby`.
+- In regex mode, the mutator skips empty lines and block comments `/* ... */` and `{- ... -}` for all languages, to avoid mutating comments and inflating noise.
+- For FunC, a fast regex-mode filter was added: if a line contains `store_uint` or `store_int` and also contains a long numeric sum expression (5+ numeric literals), numeric mutations from `universal.rules` of the form `(\D)(\d+)(\D)` are skipped. This speeds up generation and reduces the number of `INVALID` mutants on bit-width expressions. The filter is enabled only when `func.rules` is active and does not affect other languages or `--comby`.
 
-### Изменения генератора (genmutants.py)
+### Generator changes (`genmutants.py`)
 
-- При `--swap` строки для перестановки теперь исключают пустые строки и строки-комментарии (`//`, `;;`, `#`), а также строки внутри блок-комментариев `/* ... */` и `{- ... -}`. Это делает свапы более осмысленными и уменьшает число мусорных `INVALID`.
-- Также `--swap` не переставляет одинаковые строки (включая случаи, когда совпадает содержимое после `strip()`), чтобы не генерировать бессмысленные мутанты вроде перестановки `}` с `}`.
+- With `--swap`, lines considered for swapping now exclude empty lines, comment lines (`//`, `;;`, `#`), and lines inside block comments `/* ... */` and `{- ... -}`. This makes swaps more meaningful and reduces noisy `INVALID` mutants.
+- `--swap` also avoids swapping identical lines, including cases where `strip()` produces the same content, so it does not generate pointless mutants such as swapping `}` with `}`.
 
 ### 2026-04-28 update: mutator/comby sync
 
@@ -142,69 +141,69 @@ func-js -h
 - `universalmutator/mutator.py`: import of `Comby` is now lazy and happens only inside `mutants_comby()`. This removes the top-level hard dependency during module import, but does not replace the external `comby` binary requirement for actual `--comby` runs.
 - `universalmutator/genmutants.py`: TON extensions `.tact`, `.fc`, `.func`, `.tolk` are mapped to Comby matcher `.generic` in `--comby` mode. Comby does not support TON-specific matcher names directly, so this avoids failures like `The matcher ".fc" is not supported`. Other languages keep their previous matcher behavior.
 
-## Команды
+## Commands
 
 ### `mutate`
 
-Генерирует мутантов и кладёт их в `--mutantDir`. При необходимости можно добавить `--cmd` или `--noFastCheck`.
+Generates mutants and writes them to `--mutantDir`. Add `--cmd` or `--noFastCheck` if needed.
 
 ```sh
 mutate examples/tolk-bench/contracts_Tolk/01_jetton/jetton-wallet-contract.tolk --mutantDir tmp/tolk-jetton-wallet-mutants
 ```
 
 ### `analyze_mutants`
 
-Прогоняет тесты на каждом мутанте. Создаёт `killed.txt` и `notkilled.txt` в текущей директории.
+Runs tests against each mutant. Creates `killed.txt` and `notkilled.txt` in the current directory.
 
 ```sh
 analyze_mutants examples/tolk-bench/contracts_Tolk/01_jetton/jetton-wallet-contract.tolk "cd /d examples\tolk-bench && npx jest --runInBand tests/01_jetton/JettonWallet.spec.ts" --mutantDir tmp/tolk-jetton-wallet-mutants --timeout 180
 ```
 
-Полезные флаги: `--show`, `--verbose`, `--resume`, `--noShuffle`, `--numMutants N`, `--prefix name`.
+Useful flags: `--show`, `--verbose`, `--resume`, `--noShuffle`, `--numMutants N`, `--prefix name`.
 
 ### `check_covered`
 
-Фильтрует мутантов по покрытым строкам. Формат `coverfile` — список номеров строк (по одному номеру на строку). Для TSTL-отчётов есть `--tstl`.
+Filters mutants by covered lines. `coverfile` is a list of line numbers, one per line. For TSTL coverage reports, use `--tstl`.
 
 ```sh
 check_covered examples/tolk-bench/contracts_Tolk/01_jetton/jetton-wallet-contract.tolk tmp/covered_lines.txt tmp/covered_mutants.txt --mutantDir tmp/tolk-jetton-wallet-mutants
 ```
 
 ### `prioritize_mutants`
 
-Ранжирует список мутантов по структурной дистанции. На вход принимает файл со списком имён мутантов.
+Ranks a mutant list by structural distance. Input is a file containing mutant names.
 
 ```sh
 prioritize_mutants tmp/covered_mutants.txt tmp/prioritized.txt --mutantDir tmp/tolk-jetton-wallet-mutants --sourceDir examples/tolk-bench/contracts_Tolk/01_jetton
 ```
 
 ### `show_mutants`
 
-Показывает диффы для мутантов из списка.
+Shows diffs for mutants from a list.
 
 ```sh
 show_mutants tmp/prioritized.txt --mutantDir tmp/tolk-jetton-wallet-mutants --sourceDir examples/tolk-bench/contracts_Tolk/01_jetton
 ```
 
-Флаг `--concise` делает вывод компактным.
+The `--concise` flag makes the output more compact.
 
 ### `prune_mutants`
 
-Фильтрует список мутантов по правилам из конфигурации. Формат правил — строки вида `field: value`, доступны `orig`, `mutant`, `change`, `source`, `line` и их варианты с `!` или `_RE`.
+Filters a mutant list using a configuration file. Rule format is `field: value`; supported fields include `orig`, `mutant`, `change`, `source`, `line`, and their `!` / `_RE` variants.
 
 ```sh
 prune_mutants tmp/prioritized.txt tmp/pruned.txt tmp/prune.cfg --mutantDir tmp/tolk-jetton-wallet-mutants --sourceDir examples/tolk-bench/contracts_Tolk/01_jetton
 ```
 
 ### `intersect_mutants`
 
-Берёт пересечение двух списков мутантов.
+Takes the intersection of two mutant lists.
 
 ```sh
 intersect_mutants tmp/covered_mutants.txt tmp/prioritized.txt tmp/intersection.txt
 ```
 
-Для smoke-теста можно пересекать любые два существующих списка, например:
+For a smoke test, you can intersect any two existing lists, for example:
 
 ```sh
 intersect_mutants tmp/all_mutants.txt tmp/prioritized.txt tmp/intersection.txt