• Расположения управляющих потоком выполнения команд по начальным адресам, а в конце программы (или в середине, в зависимости от побочной ветви) их не использовать (автоматический переход на начало основной ветви) для сокращения длины программы. Чаще всего в этом качестве выступает В/О, но можно и условные переходы, С/П и др.
• Использование разных значений для фактического перехода по одному и тому же адресу (указано выше). Нестандартное ветвление.
• Изменение адреса перехода сдвоенной команды, в зависимости от формального адреса (указано выше). Также нестандартное ветвление.

Кстати, это правило показывает, что для обычных целых чисел, порядок которых (от нуля) совпадает с числом цифр − 1, слева дописывается такое число нулей, чтобы получилось 8 цифр. Т.е. число остается тем, что есть, что и соответствует документации. В случае, если кроме целой части есть и ещё и дробная, то же правило показывает, что дописываемые нули "вытеснят" дробную часть совсем, что часто используется в программах для сокращения: нет необходимости убирать дробную часть, т.к. косвенная адресация её сама уберёт.

Тут нужно сделать замечание. Есть предположение, что девятки не случайны, а равны 10 − 1, где 10 это знак минус (как шестнадцатеричная цифра A). Для проверки такого предположения возьмем число с цифрой вместо знака (см. Числа, у которых вместо знака стоит цифра для алгоритма получения). Например 2E.          , где двойка стоит на месте знака. При косвенной адресации: x→П9  КП→x9  П→x9. Двойка уменьшается на единицу и становится 21111111E.   . Аналогично для других чисел, например, если для 9E.           (которое после /-/) выполнить косвенную адресацию, то получим 98888888E.   .

Теперь рассмотрим ситуацию, когда само значение регистра ещё и меняется как описано в документации. Обращаю внимание, что изменения происходят не при любом косвенном обращении, а только когда значение адреса для перехода вычисляется. Например, в условном операторе Кx<04 регистр R4 будет модифицирован только когда x⩾0, т.е. когда понадобиться вычислить адрес перехода.

 123.        , что представляется как 1.23^02, перейдет в 0.0000123^+07, затем уменьшится до 0.0000122^+07 и превратиться в  00000122.   , т.е. адрес перехода = 22.
 1.23     -02, что представляется как 1.2300000^-02 уменьшится до 1.2299999^-02 превратиться в  1.2299999-02, т.е. адрес перехода = 99.
-123.        , что представляется как -1.23^+02, преобразуется в -9.9999123^+07, затем уменьшится до -9.9999122^+07, превратиться в -9.9999122.   , т.е. адрес перехода = 22.
-1.2345678-08, преобразуется в -9.9999123^-03, затем уменьшится до -9.9999122^-03, превратиться в -9.9999122-03, т.е. адрес перехода = 22.

Обратите внимание, что при уменьшении мантиссы до нуля порядок числа сохраняется. Например, если исходно было 1.^-20, то после преобразования будет 0.0000001^-13, а после уменьшения станет 0.0000000^-13, т.е.  0.      -13. Правда такой ноль, кроме необычного вида, в операциях ничем от простого нуля не отличается. Но в сочетании с другими недокументированными возможностями, которые могут объединить мантиссу и порядок от разных чисел (см. Таинственный регистр X2) это может пригодится. Таким же образом из 1.^90 получается  0.        97.

 123.        , что представляется как 1.23^+02, перейдет в 0.0000123^+07, затем увеличится до 0.0000124^+07 и превратиться в  00000124.   , т.е. адрес перехода = 24.
 1.23     -02, что представляется как 1.2300000^-02, увеличится до 1.2300001^+02 превратиться в  1.2300001-02, т.е. адрес перехода = 01.
-123.        , что представляется как -1.23^+02 преобразуется в -9.9999123^+07, затем увеличится до -9.9999124^+07, превратиться в -99999124.   , т.е. адрес перехода = 24.
-1.2345678-08, преобразуется в -9.9999123^-03, затем увеличится до -9.9999124^-03, превратиться в -9.9999124-03, т.е. адрес перехода = 24.

 123.        , что представляется как 1.23^+02, перейдет в 0.0000123^+07, затем уменьшится до 0.0000122^+07 и превратиться в  00000122.   , цикл продолжается.
 1.23     -02, что представляется как 1.2300000^-02 уменьшится до 1.2299999^-02 превратиться в  1.2299999-02, цикл продолжается.
 1.23        , преобразуется в 00000001, равно единице – цикл завершиться, а исходное число не измениться, т.е. останется  1.23        .
 1.23     -10, что представляется как 1.23^-10, преобразуется до 0.0000001^-03, равно единице – цикл завершиться, а исходное число не измениться.

Проверить "на единицу" исходное можно через регистры R7…Re. Если после КП→xR  П→xR на экране мантисса будет 00000001 (и где-то точка), то значит цикл прервется на исходном числе.

Переход так же будет на шестнадцатеричный адрес, но с этим мы уже знакомы (см. Программное адресное пространство).

К сожалению, если идёт увеличение, то число с шестнадцатеричными цифрами предварительно подвергается нормализации (справа налево, смысл как указано в списке терминов): буквы считаются как двузначные, с переносом лишней единицы в старший разряд. Например, сложение числа 9AE и 1 будет так: E = 14, значит последняя цифра 4 + 1 = 5 и 1 «в уме»; затем A = 10 + 1 в уме, будет 11, т.е. 1 и 1 в уме; далее 9 + 1 = 10. Итого 1015. Это значит, что косвенная адресация через R4…R6 всегда уберёт шестнадцатеричные цифры из числа. При этом нестандартный знак числа (см. замечание в варианте для отрицательных чисел) остается.

Для чисел вида 1.^+0H (одна цифра) никаких преобразований не производится, а значит адрес перехода всегда будет нулевым. Если идёт увеличение или уменьшение (через выбор регистра), то мантисса увеличивается или уменьшается в соответствии с правилами выше, а знак и порядок не меняется. Пример: если в регистр R0 записать  1.        0E и выполнить КП→x0, то результатом станет уменьшение мантиссы 100000000 до 09999999, т.е.  0.9999999 0E.

Для двузначных чисел порядка ситуация сложнее. Возьмем, для примера 1.^+B0 ( 1.       L0). Кстати, 1.^+AA будет автоматически переведено в 1.^+B0, как и 1.^+0A будет автоматически переведено в 1.^+10 (чем-то именно A не нравиться, для остальных цифр такого не замечено, хотя и тут можно обмануть, если для 1^.-LL набрать ВП  5  5). Так вот, по сути это число равно 1.^+110. Как видно, вместо знака порядка используется цифра, но для ПМК это тоже, что и знак, поэтому будет применено правило для отрицательных порядков, то есть допишется слева 7 (= 10 − 3 и меньше 8) нулей, что приведёт к 0.0000001^117. Т.е. в качестве адреса перехода будет 01, но само число из регистра уже лучше не извлекать, т.к. оно будет сверхчислом и на экране отображаться как ЕГГ0Г.

Если у двузначных чисел порядок отрицательный, то срабатывает правило "сумма = 160", это значит, что внутренне порядок меняется на число по модулю 160. Для примера, возьмем 1.^-C0 ( 1.       -C0). Это эквивалентно 1.^-120, а по правилу "сумма = 160", как 1.^+40. Используя правило преобразования для чисел больше единицы, получаем, что число будет преобразовано в 0.0000001^+47, соответственно адрес перехода 01, а полученное после косвенной адресации число можно просто извлечь из регистра: будет  0.0000001 47 Для сравнения, если взять 1.^-C1, то правило "сумма = 160", приведёт к 1.^+39, что не поддаётся преобразованию (9 > 7), а значит само число после косвенной адресации не измениться и останется  1.       -C1 (адрес перехода равен 00). И, да, к этому числу можно прибавить 0, чтобы увидеть  1.        39.

У правила "сумма = 160" возникает ещё один интересный побочный эффект. Детали см. в разделе Числа с отрицательной нулевой степенью.

Если идёт увеличение или уменьшение (через выбор регистра), то мантисса увеличивается или уменьшается в соответствии с правилами, уже описанными выше.

00.Сx  01.x→П0  02.КСЧ  03.КИНВ  04.Кx→П0  05.П→x0  06.Fx≥0  07.02  08.С/П

Ещё практических советов. Уменьшение шестнадцатеричной цифры для БЗ-34 было единственным способом из цифры E получить остальные цифры. В МК-61 с приходом бинарных операций стало проще, но т.к. первая цифра всё ещё не во власти этих операций, то через косвенную адресацию получается быстрее, чем через дробную часть и ввод порядка.

Особенность не уменьшения числа по окончании цикла, с учетом того, что фактически число может сильно отличаться от единицы (см. пример выше) позволяет использовать команды FLx для быстрой проверки значения регистра с одновременным переходом при удаче/неудаче.

• ввод числа (после ввода каждой цифры, в том числе и разделителя .)
• /-/
• Сx
• В↑
• FВx
• С/П
• В/О
• П→xR (R = 0…F)
• КП→xR (R = 0…F)
• пустые операторы с кодами F0…FF
• все команды, генерирующие ошибку (в силу перехода в режим вычислений), например, 27(К-), 28(К×), 29(К÷), 2B…2E, 3C и стандартные операции при генерации ошибок.

• Fx<0 (команда Кx<0 – никогда НЕ влияет на X2)
• Fx=0 (команда Кx=0 – никогда НЕ влияет на X2)
• Fx≥0 (команда Кx≥0 – никогда НЕ влияет на X2)
• Fx≠0 (команда Кx≠0 – никогда НЕ влияет на X2)
• FL0
• FL1
• FL2
• FL3

Остальные операторы НЕ копируют X в X2. А это, например, означает, что регистр X во время таких операций может содержать сверхчисло (больше или равно 10¹⁰⁰). При этом, конечно, нужно учитывать, чтобы команда сам по себе не делала такую проверку на переполнение. Например, F10ˣ делает проверку параметра перед выполнением, а Fx² – нет. Для пояснения рассмотрим такую программу:

00.КНОП  01.5  02.0  03.F10ˣ  04.Fx²  05.Fx=0  06.07  07.Сx  08.С/П

Можно увидеть, что на шаге 04 в регистре X возникает сверхчисло. Причем оператор 05.Fx=0 не выполняется, т.е. идёт переход на адрес 07 (как адрес перехода). В соответствии с таблицей выше, в этом случае копирование X в X2 не происходит, а значит, ошибки не должно возникать. В чем легко убедиться, запустив программ. Но если в программе заменить оператор на 05.Fx≠0, то условие уже будет выполняться, и будет выполняться копирование X в X2, которое приведёт к ошибке. Что также проверяется запуском программы.

Хочу отметить, что команда В/О также является X2-влияющей, т.е. если перед возвратом из подпрограммы в регистре X будет сверхчисло, то произойдёт остановка по ошибке, причем возврат успеет отработать.

Всё это не имело бы практического смысла, если бы не было команд, которые делают обратное копирование X2→X.

00.П→x9  01.П→x1  02.К∧  03.К{x}  04.Fx≠0  05.77  …  77..  78.К∨  79.x→П9

Получается, что оператор . по адресу 77 восстановит R1 в X без сдвига стека, что позволит сразу выполнить бинарную операцию. Обычно само значение из R1 "вычислено", а не храниться в регистре. Обратите внимание, что выбрана не X2-влияющая проверка с переходом.

Ещё пример – использовать оператор . как входной параметр подпрограммы, т.е. эта команда стоит первым оператором. В этом случае, например, после ввода пользователя (после команды С/П, которая всегда копирует X в X2), сначала выполняются некие вычисления, не затрагивающие X2 (в том числе сохранение этих результатов в регистры), а затем вызов подпрограммы, которая таким образом "видит" ввод пользователя.

• Восстановление X2 с отбрасыванием первой цифры

  Это выполняется после последовательности операторов x→ПR  ВП, где R – любой регистр памяти. При этом текущее содержимое регистра X теряется, без изменения стека. Вместо x→ПR может быть и команда Кx→ПR.

  Пример. Пусть нам нужно обработать ввод выбора пользователя для перемещения в некоем 3-ном лабиринте. Обычно используются клавиши 2,4,6,8,±5 (что соответствует направлению движения). Рассмотрим такую последовательность (в предположении, что выбор пользователя храниться в регистре R9 и значение 0 имеет ещё какой-то дополнительный смысл):

  00.П→x9  01.2  02.÷  03.Fx≠0  04.77  05.Fπ  06.+  07.x→П9  08.ВП  09.Fx=0  10.55  11.КП→x9

  Что здесь происходит? На шаге два мы получим одно из чисел 1, 2, 3, 4, ±2.5 или 0. Условным оператором мы не только отсекаем вариант с нулем, но делаем X→X2. Далее к полученному числу сразу прибавляем π и сохраняем в R9 для дальнейшей косвенной адресации (пусть в R4…R7 хранятся коэффициенты умножения для выполнения движения). Обращаю внимание, что тут использованы не X2-влияющие команды. После команды ВП мы "восстановим" в X то значение, что было после деления на шаге 02, только без первой цифры, т.е. ноль (для 1…4) или ±0.5, чтобы использовать это для последующего ветвления программы (умножение на коэффициент деления, а для ±0.5 можно будет взять знак числа и т.д.). Без использования ВП потребовалось бы использовать или дополнительный регистр, или дополнительные команды по манипуляции со стеком.

  Дополнительные условия. Если содержимое X2 равно нулю, то будет восстановлена единица.

  Если в момент восстановления (выполнения команды ВП) содержимое регистра X меньше нуля, то вместо удаления первой цифры у числа X2, она будет заменена на 9.
  Например, после выполнения программы

  00.Fπ  01./-/  02.Fπ  03.×  04.x→П9  05.ВП  06.С/П

  на экране будет -9.1415926    в R9 будет -π × π (команда по адресу 01 X2-влияющая).

  С учетом знаний по знакоцифрам можно провести более простое правило: эта последовательность при восстановлении X2 (если X2 не ноль) первую цифру меняет на знакоцифру числа в регистре X минус 1. Тогда для обычных чисел получается:

  • Число больше нуля, знакоцифра равна единице, значит первая цифра заменяется на ноль, т.е. удаляется.
  • Число меньше нуля, с минусом, знакоцифра равна 10 (A), значит цифра заменяется на 9

• Восстановление X2 с заменой первой цифры на цифру из числа в X

  Как правило это наиболее интересная последовательность. Она позволяет нестандартно сочетать два числа.

  Рассмотрим последовательность КНОП  ВП. При этом КНОП взята как более нейтральная, могут быть и другие не X2-влияющие команды, назовем это первой командой. Тут важно учитывать:

  1. В качестве образца первой цифры берётся содержимое X до(!) начала данной последовательности.
  2. Если вместо КНОП стоит другая не X2-влияющая команда, то она выполняется, но результат её выполнения будет потерян. При этом стек будет иметь состояние как обычно после выполнения команды.
  3. Если первая команда – это переход на другой адрес, то она выполниться и последовательность с ВП будет нарушена.
  4. Если первая команда генерит ошибку, то снова последовательность с ВП будет нарушена.
  5. Если первая команда это x→ПR, то будет выполнено по правилу, описанному выше, с отбрасыванием первой цифры.

  Пример:

  00.Fπ  01.КИНВ  02.КЗН  03.FВx  04.<->  05.КНОП  06.ВП  07.С/П

  В результате получим 1.ELE-6Г9   . Тут дробная часть понятна – это инверсия числа π которое сохраняется X2-влияющей командой по адресу 03. А интересна тут цифра 1 на первом месте, которая появилась в стеке по команде КЗН. Именно она подставляется вместо восьмерки при восстановлении.

  Интересно, что первой цифрой может быть и шестнадцатеричная, тем самым можно получить то, что в режиме вычислений трудно сделать. Например,

  00.КНОП  01.9  02.F1/x  03.5  04.×  05.КИНВ  06./-/  07.К{x}  08.КНОП  09.ВП  10./-/  11.9  12.9  13.С/П

  Будет 10(!) "минусов". --.--------99. Тут X2-влияющая команда по адресу 06 фиксирует 8.AAAAAAA (заодно добавляя минус), а оператор дробной части оставляет на первом месте тоже цифру A. Всё это последовательность с ВП успешно объединяет, а порядок -99 в конце дописывается для красоты.

  Ещё пример. Пусть нужна подпрограмма, которая из первой цифры (целой части) дробного числа в регистре X делает букву. Например, 1→E, 2→D,… 4→A. В режиме вычислений для этого подошла бы последовательность

  00.1  01.0  02.+  03.КИНВ  04.К{x}  05.ВП  06.1  07.К[x]

  С учетом специфики выполнения команды ВП в программном режиме нужно ещё скопировать X→X2 после команды К{x}, т.е.

  00.1  01.0  02.+  03.КИНВ  04.К{x}  05.В↑  06.ВП  07.1  08.К[x]

  Это +1 команда, к тому же стек будет испорчен. Рассмотрим

  00.1  01.F10ˣ  02.+  03.КИНВ  04.К{x}  05.КНОП  06.ВП

  Здесь, благодаря восстановлению единицы (шаг 0), на шаге 06, останется только одна шестнадцатеричная цифра. Так недокументированная последовательность сделала подпрограмму короче на два шага.

  Нужно понимать, что если число в X2 не нормализовано, то всё равно заменяется первая цифра. Воспользуемся знаниями косвенной адресации:

  00.КНОП  01.4  02.x→П7  03.КБП7  04.П→x7  05.КНОП  06.ВП  07.С/П

  В данном случае 4 после косвенного перехода становится 00000004, а значит замена первой цифры приведёт к  40000004.   , в чем легко убедиться, запустив программу.

  Теперь рассмотрим особенности. Если число X до начала последовательности было нулем, то вместо первой цифры устанавливается ноль. Обычно это значит, что число будет без первой цифры (начальный ноль не значащий). Но если он уже и так там был (например, число – это результат косвенной адресации с ведущими нулями), тогда никаких полезных действий не будет. Впрочем, иногда, именно это различие можно использовать, чтобы узнать, выполнялась ли косвенная адресация или нет.

  Если X2 нулевое, то тут как бы проявляется известный трюк с ВП, который 0 превращает в 1. В данном случае первая цифра числа X увеличивается на 1. Вот фрагмент:

  00.КНОП  01.0  03.<->  04.КНОП  05.ВП  06.С/П

  Если на вход этой программе дать 5, то выдаст 6. А если 9, то выдаст… A(!), потом аналогично B, C, D, E, F. Впрочем, последнее лучше тут же заменить на 0 и прочистить стек – пустышки коварны (во всяком случае, если на вход передать F, то программа однозначно будет перекручена во что-то неузнаваемое). Ещё пример:

  00.F1/x  01.КНОП  02.ВП  03.С/П

  На вход -9.          , на выходе первая цифра от обратной величины -1.          .

• ВП сразу после косвенного перехода

  Т.е. в программе делается переход через команду КБПR или переход при проверке условия, например, Кx=0R и сразу в месте, куда выполнился переход идёт команда ВП. В этом случае также идёт восстановление X2, но при этом первая цифра меняется на 7. Знак и порядок сохраняются. Аналогично тому, что и ранее, если число в X2 не нормализовано, то всё равно идёт замена первой цифры, оставляя остальные как есть. В случае X2 = 0 число будет восстановлено как 8.

  Для условных переходов это работает только если идёт переход на адрес. Если же условие выполняется (т.е. без перехода), то поведение будет как указано выше (фактически команда будет проигнорирована). Если первая после перехода не ВП, то тоже по правилам для ВП ранее. Пример.

  00.КНОП  01.1  02.0  03.x→П8  04.Fx²  05.КБП8  …  10.ВП  11.С/П

  После остановке на экране будет  70.         , т.е. восстановлено X2 = 10 (вместо 100), и первая цифра заменена на 7. Ещё пример.

  00.КНОП  01.КНОП  02.8  03.x→П9  04.КП→x9  05.П→x9  06.Fπ  07.КБП9  08.ВП  09.С/П

  По уже указанными правилам будет  70000008.   . Если заменить команду по адресу 07 на Кx=09, то ничего не измениться, т.к. условие не выполниться и будет переход. Но если заменить на Кx≠09, то уже условие выполниться, перехода не будет, и сработает старое правило, т.е. будет использована первая цифра числа в X, т.е.  30000008.   .

• Использование ВП как сложение

  Редкий случай, скорее для информации только. Последовательность КНОП  ВП  ВП. При нулевом значении X2, сначала, как и описывалось ранее, увеличит X на единицу, а второе ВП уже на величину цифры, которая была до увеличения. Последующие добавления ВП уже ничего не меняют. Пример:

  00.КНОП  01.0  02.<->  03.КНОП  04.ВП  05.ВП  06.С/П

  На вход 6, на выходе D (6 + 7 = 13). На вход D, на выходе B (13 + 14 = 27 = 16 + 11).

• Команда . перед ВП "сдвигает" захват X глубже на начало

  Обычно команда . восстанавливает в X значение X2, но ВП тоже пытается восстановить X2, но 1-ю цифру берёт ту, что было за 2 хода в до нее в X. Рассмотрим

  00.КНОП  01.1  02.5  03.Fx²  04.Fx²  05.КНОП  06..  07.ВП  08.С/П

  Результат 55, потому что 15² = 225, 225² = 50625 и «выигрывает» ВП, который восстановит X2(15), с первой цифрой 5. Если убрать второй КНОП, то результат будет 25 (2 от 225), т.е. второй Fx² будет проигнорирован, как будто команда . отодвинула ВП вглубь. Если поменять КНОП и . местами, то будет 15, т.к. . восстановит 15 и уже с ним работает ВП, как в ручном режиме. Другой пример:

  00.КНОП  01.1  02.5  03.Fπ  04.x→П9  05.КНОП  06..  07.ВП  08.С/П

  Здесь . отодвигает до x→П9, т.е. восстановится 15 с цифрой 3, т.е. 35. Если убрать КНОП, то поведение будет как у x→П9  ВП, т.е. 15 без первой цифры (5)".

01.B↑  02.ВП  03.2  04./-/  05.С/П

01.B↑  02.ВП  03.2  04.Fπ  05.Fx²  06.Fx²  07./-/  08.С/П

Ещё пример. Известно (хотя не документировано), что для запрета ввода точки при вводе порядка, сочетание команд ВП и . генерит ошибку. Более того, в отличии от остальных способов получения ошибки он отличается тем, что

1. Он самый быстрый, действует мгновенно, а не "задумываясь".
2. Он не пропускает в программном режиме лишнюю команду, как делают все остальные операции, вызывающие ошибку (ах да, это тоже не документировано).

Но это сочетание также работает с X2, т.е. игнорирует все не X2-влияющие команды. В связи с этим становится ясно, что следующий фрагмент:

01.B↑  02.Fx²  03.ВП  04.Fx²  05.Fx²  06..  07.Fx²  08.С/П

Вычисление идёт как шестнадцатеричное, остаток по модулю 16, а от него берётся последняя цифра (чтобы осталась одна). X = ((X + Y) mod 16) mod 10.
Если Y двузначное, то уже две цифры X = ((X + Y) mod 256) mod 100, а значит получается как обычное сложение, если число двузначное.
Если Y дробное, то целая часть как выше, а дробная сохраняется.

Выглядит похоже на X = (Y − X) mod 16, но не всегда понятно, когда берётся заём, а когда нет. Число A какое-то особенное для двузначных.
Для трех- и выше значных повторяется как для двузначных, т.е. 100 − A = 90, 100 − B = 105,… , 109 − E = 111.

Нарушения обычного вычитания только для нескольких чисел (выше и правее, начиная с B − 1, для двузначных ниже и левее A − 1B).
Кстати, особенность: когда из шестнадцатеричного числа вычитается его десятичный аналог, то ноль, на самом деле, не нормализованный (т.е. из 4-х значного будет 0000), и это можно использовать для получения нуля в любой степени. Пример (в ручном режиме):

1. Получим цифру E документированным образом: 1  1  КИНВ  К{x}  ВП  1  К[x], или можно нестандартным: 1  К×  ВП
2. Добавим порядок, который хотим получить: ВП  9  9
3. Затем скопируем в стек: В↑  В↑  СX
4. Выполним сложение (с нулем) и вычитание: +  -

И вот мы получили  0.        99.

Поразительное однообразие, почти все ведут себя как 10. Не ясно, чем так отличается E, но ноль получается и для многозначных чисел.
Для двузначных соответственно, т.е. C × 20 = 200, но E × 20 = 0.

Тут уже трудно поддаётся логике. На практике автор как-то использовал D. С одной стороны, это изображение, с другой – коэффициент 10 (см. таблицу H × Y), а самое основное – это проверка битового сдвига. При умножении дробной части, содержащей 1, 2, 4, 8 (как бы биты) возможен выход за диапазон, т.е. 0.5 или 1.6. Так вот, при умножении на D по указанной таблице, результат получался из одной цифры, если всё нормально, или из двух, при выходе за диапазон.

Для двухзначных результат бывает не нормализованным: обратите внимание на ведущие нули в некоторых случаях. На этом фоне 14 × E выглядит как белая ворона.

Здесь кроме случая X = 1, и некоторых двузначных это обычное деление нормализованного шестнадцатеричного числа. Пример: E ÷ 7 = 14 ÷ 7 = 2.
Правда и здесь встречаются не нормализованные числа (пример D ÷ 12, или C ÷ 11, которое на порядок меньше, чем A ÷ 11).
Встречаются и не нормализованные нули, пример: С ÷ 12, и выглядит, как указано:  0.       -01. Впрочем, в косвенной адресации мы уже встречались с подобными нулями.

Тут логики не наблюдается. Очень похожие, но разные числа: 9.099099^-01 и 9.9099099^-01 (или 9.099099 и 9.9099099). Также интересно, что ноль разделить на H вовсе не ноль.
А самое главное, тут не просто ЕГГ0Г, а плохой ЕГГ0Г, который ранее не встречался. После его появления ПМК в дальнейшем (до выключения ПМК) при выполнении многих операций всегда выдаёт ЕГГ0Г. Вот список таких операций.

• +
• -
• ×
• ÷
• <->
• Fsin
• Fcos
• Ftg
• F√
• F1/x
• Fsin⁻¹
• Fcos⁻¹
• Ftg⁻¹
• Fπ
• Fx²
• Feˣ
• Flg
• Fln
• Fxʸ
• F10ˣ
• F↻

Ошибка возникает как в режиме вычислений, так и в программном режиме. Интересно, что F↻ выдаёт ошибку, а FВx – нет.

"Синии" функции работают нормально. Видимо такой ЕГГ0Г "сводит с ума" только один микроконтроллер.

• Результат возведения в квадрат согласуется с таблицей умножения, приведенной выше.
• Излечение корня вообще по правилам – как корень из нормализованного числа.
• Обратная величина также согласуется с таблицей деления, причем здесь опять плохой ЕГГ0Г.
• Feˣ тоже как корень – всё по правилам.
• F10ˣ отображает шестнадцатеричную степень, только цифра A не любит светиться.
• Результаты логарифмов уже не понятны.
• Fx¹ это Fxʸ, для случая Y = 1. Впрочем результат от этого не становится более ясным. Кроме числа A, остальные возводятся в первую степень как какие-то суперчисла.
• К[x] похож на сложение с нулем. Причем, если бы число было ещё с дробной частью, то целая часть осталась бы без изменений, даже шестнадцатеричная.

Про более редкие операции переводов градусов/часов сказано в приложении по командам. Числа, где порядок содержит шестнадцатеричные значения, рассмотрены в разделе косвенной адресации Порядок содержит шестнадцатеричные цифры .

Случаи с двойными и более шестнадцатеричными числами (в том числе в дробной части) не рассмотрены, как очень редко встречающиеся. Там тоже можно построить подобные таблицы, но проще посмотреть результат под конкретное число.

1. Хвосты 0C-оборотней. В этом случае используются знания Еггогологии. 0С-оборотни – это числа в диапазоне 1.^400…9.9999999^499. Для получения таких чисел (точнее "хвостов") воспользуемся программой:

   00.КНОП  01.5  02.0  03.F10ˣ  04.Fx²  05.Fx²  06.Fx²  07.×  08.x→П9  09.П→x9  10.П→xc  11.ВП  12.7  13.С/П

   На вход ей передатся число (0…8.9999999], на выходе получаем "хвост" оборотня из регистра Rc. Поэтому их и называют 0C-оборотни, что сами они на экран дают ноль, а "хвост" сбрасывают в регистр Rc. Передавать на вход девятку неинтересно, т.к. на выходе получим 10, точнее цифру А, т.е. обычный минус.
   Пример, передав 1, получим 2E.          , передав 6, получим 7E.          , и т.д. Нажав /-/ получим другую знакоцифру (вычислить какую именно легко, т.к. сумма таких парных знакоцифр = 11). Кстати, если мантисса нулевая, то после /-/ будет -0 для любой знакоцифры.

   Этот способ получения знакоцифры не очень удобен, тем более, что для получения других цифр мантиссы нужно сильно "напрячься", например многократно прокрутив счётчик косвенной адресации. Есть способ лучше.

2. Использование косвенной адресации регистров R4…R6. О том, что при использовании шестнадцатеричных чисел в косвенной адресации для R4…R6 идёт их "нормализация" уже было упомянуто в Мантисса содержит шестнадцатеричные цифры .

   Так вот, если первая цифра 8-значного числа тоже шестнадцатеричная, то перенос из старшего разряда происходит в знаковый разряд, т.е. появляется знакоцифра.

   Для начала возьмем обычную цифру E (для краткости нестандартным способом), которая потом пригодится: 1  К-  ВП  x→Пe. Затем сделаем её первой (число 8-значным): ВП  7  x→П4. Получили  E0000000.   . Если теперь использовать косвенное увеличение: КП→x4  П→x4, то получим 240000001.   . Тут из цифры E сделан перенос единицы в знаковый разряд. В отличии от 0С-оборотней мы пока получили только знакоцифру два (или 9, если нажать /-/), зато остальные цифры мантиссы легко выбрать нужные (кроме шестнадцатеричных, которые косвенной адресацией нормализуются), а с помощью восстановление X2 с заменой первой цифры на цифру из числа в X можно и первую цифру сделать шестнадцатеричной. Введем простую программу:

   00.<->  01.КНОП  02.ВП  03.С/П

   Эта программа меняет у числа в X первую цифру на первую цифру из числа в Y. Соответственно, возьмем цифру E и наше новое число со знакоцифрой два и объединим их: П→xe  П→x4  В/О  С/П. Получили 2E0000001.   . Если такое число провести через косвенную адресацию: x→П4  КП→x4  П→x4, то получим 340000002.   . Таким же образом можно получить остальные знакоцифры (до 9 включительно). Кому эстетически не нравиться хвостик (в данном случае 2), его можно сбросить до нуля, уже через косвенную адресацию с использованием R0…R3.

Как видно, далеко не всё так прозрачно. 5N и 6N получаются и отрицательные и положительные. Сравнения с нулем, кстати, для всех проходят корректно (не ноль, если N не ноль).
Рассмотрим другие функции, для косвенного определения знака числа.

• F10ˣ выдаёт положительный порядок только для 9N.
• F1/x наоборот считает 9N отрицательным, а остальные положительными.
• Feˣ тоже только 9N считает отрицательным.
• F√ все считает отрицательными, т.е. даёт ошибку.
• Flg и Fln все считает отрицательными, т.е. дают ошибку.
• Fsin все считает отрицательными, т.е. результат отрицательный. Остальные тригонометрический функции ведут себя аналогично.
• К°←′" или К°←′" считают их отрицательными, а К°→′ и К°→′" не меняют знакоцифру.
• Парадоксально, но функция Fx² для чисел 5N…8N результат делает отрицательным, хоть и правильным по модулю.
• Fxʸ все считает отрицательными, если числа являются основанием (т.е. даёт ошибку), но в качестве показателя различает, считая 9N отрицательным, а остальные положительными.

• КЗН заменяет мантиссу на 1, оставляя знакоцифру, т.е. от 8N, получится 81.
• К∣x∣ отбрасывает знакоцифру, как и ожидалось.
• К[x] оставляет целую часть и ставит знак минус.
• К{x}, оставляет дробную часть вместе со знакоцифрой, если число по модулю < 1⁷ (точнее число, которому нужно меньше восьми знакомест). Для больших чисел знакоцифра удаляется.
• + в любом сочетании считает их отрицательными.
• - ведёт себя хитрее. Когда число со знакоцифрой уменьшаемое, т.е. находится в регистре Y, то ведёт себя как отрицательное, но когда вычитаемое (находится в регистре X), то наоборот, как положительное. Например, возьмем 63 (6 – знакоцифра), тогда 63 − 1 = -4, а вот 1 − 63 = -2. Отсюда следует, что вычитание двух чисел со знакоцифрами складывает их модули, но результат оставляет отрицательным, т.е. ведёт себя в точности, как сложение(!).
• ×, ÷ обрабатываются сложнее, нужна таблица (порядок операндов не важен):

  	+N	2N	3N	4N	5N	6N	7N	8N	9N	-N
  +N	+	+	+	+	+	+	+	+	−	−
  2N	+	+	+	+	+	+	+	−	−	−
  3N	+	+	+	+	+	+	−	−	−	−
  4N	+	+	+	+	+	−	−	−	−	−
  5N	+	+	+	+	−	−	−	−	−	−
  6N	+	+	+	−	−	−	−	−	−	−
  7N	+	+	−	−	−	−	−	−	−	−
  8N	+	−	−	−	−	−	−	−	−	+
  9N	−	−	−	−	−	−	−	−	+	+
  -N	−	−	−	−	−	−	−	+	+	+

  Результат, по крайней мере, согласуется с поведением функций F1/x и Fx²
• Кmax считает числа с разными знакоцифрами равными (если N одинаковый), например для 8N и 2N операция не будет делать ничего (кроме сброса X в X1), к каком бы порядке они не стояли.
  Но при этом все они меньше, чем +N, и больше, чем -N.

Тут нужно остановиться на нуле. Как указано в функции К{x}, может получится ноль со знакоцифрой. Так вот, он ведёт себя как обычный ноль. Единственное отличие – это в функциях сравнения. Такой ноль ведёт себя так, как указано ранее для чисел со знакоцифрой. В частности число 50.           операторы Fx<0, Fx≥0, Fx=0 пропустят, как удовлетворяющее условию.

П→xe  9  9  9  9  9  9  9  8  В/О  С/П Получили  E9999998.   . Затем x→П4  КП→x4  9  П→x4  В/О  С/П. Получим 299999999.    (Кстати, если нажать /-/, то получим девять девяток). Теперь снова сделаем над ним операцию x→П4  КП→x4  П→x4. Мы увидим довольно симпатичный не нормализованный ноль 300000000.   , которому можно поставить любую первую цифру (но не знакоцифру), как сделано только что по программе. Кстати, если бы мы так сделали с девятью девятками, то получили бы -00000000.   .

Фактически, таким образом можно получать почти любые мантиссы (кроме шестнадцатеричных) с нужной знакоцифрой.

Например, хотим получить 321, где 3 – знакоцифра. Используя короткую программу, указанную в начале раздела, у числа  10000019.   , заменим первую цифру на E, получим  E0000019.   . После косвенного увеличения станет 240000020.   . Снова заменим на E, получим 2E0000020.   . Повторное косвенное увеличение приведёт к 340000021.   . Теперь, после замены первой цифры на ноль, останется 321.         .

Ещё пример. Хочу получить π/2 (для работы с тригонометрическими функциями), и знакоцифру девять. π/2 = 1.5707963. Начнем с  15707962.   , заменим первую цифру на E, получим  E5707962.   . После косвенного увеличения станет 245707963.   . Нажмем /-/, получим 945707963.    и сделаем замену первой цифра на 1: 915707963.   . Осталось только ВП  7  /-/  x→П1, и мы получили, что хотели 91.5707963   . Можно проверить тригонометрические функции на нем, например синус о него даёт -1.

На самом деле можно получить числа со знакоцифрам и шестнадцатеричными цифрами в мантиссе. Сначала получим, как указано в начале 240000001.   , а затем применим следующий алгоритм:

1. Ставим первой шестнадцатеричную цифру (E из Re) по минипрограмме.
2. Если все цифры мантиссы уже шестнадцатеричные, то завершаем.
3. Уменьшаем с помощью ВП  1  /-/ порядок на единицу.
4. У полученного значения через косвенную адресацию в R7…Rd убираем дробную часть. При этом вместо первой цифры будет вписано знакоцифра − 1, а наша шестнадцатеричная цифра отодвинется. Переходим на п.1.

По такому алгоритму и цифре E легко получается 2EEEEEEEE.   .

Понятно, что в пункте 1 алгоритма можно вписать любую цифру (кроме E). И начать с числа с любой знакоцифрой. Таким образом можно получить практически любую мантиссу с любой знакоцифрой (кроме цифр F или ведущих нулей).

Более того, такие знакоцифры влияют и на остальное. Возьмем, для примера Восстановление X2 с отбрасыванием первой цифры . На самом деле указанная там последовательность при восстановлении вместо первой цифры записывает знакоцифру − 1, что для положительного числа равно нулю, т.е. отбрасывание цифры. А вот если знакоцифра есть, то эта последовательность запишет её минус один вместо первого знака. Отсюда же понятно, почему для отрицательных запишет 9, это знак минус, как цифра A (= 10) минус один. Причем знакоцифра останется на месте.

На практике автор не использовал такие числа просто в силу того, что в момент активного использования ПМК не обладал этими знаниями. И хотя нестандартность поведения многих функций с такими числами определяется только реакцией на знак числа, всё равно можно предположить, что и это можно использовать для оптимизации.

Если вы думаете, что мантисса может быть только единица, то обрадую, что можно и другие. Для исследования чисел с разными мантиссами приведем программу, которая регистры R1…Re заполняет числами с нулевой отрицательной степенью, а на месте первой цифры будет стоять номер регистра (да, да, для последнего это будет E.^-00).

Тут тоже используются недокументированные возможности. Большую часть (адреса с 00 по 17) это получение (документированное) той же 1^.-00, что мы сделали руками, только без ЕГГ0Га. Причем не через E0, а через L0 (просто число 13 нужно для цикла по оставшимся регистрам R2…Re). Из-за особенностей поведения ВП в программном режиме X нужно копировать в X2. Первый раз нам помогает /-/ по адресу 08, второй раз уже явно делаем В↑ по адресу 12. А вот с 18 адреса начинается "шаманство". Фрагмент программы 18…21 увеличивает текущую цифру (в шестнадцатеричном смысле). Эта особенность была рассказана в разделе про регистр X2 и команду ВП. А фрагмент 22…25 (тот же раздел) подставляет эту цифру в число из R1. Потом с помощью регистра Re мы сохраняем это в нужном месте и повторяем.

Обозначим такое число с необычной степенью как N. В общем случае, нулевая степень (пусть с минусом) в математическом смысле ничего не меняет, т.е. число должно быть как бы без степени. И большинство операций так его и воспринимаю, но есть исключения. Пройдемся по всем операциям/функциям, использую значения регистров, внесенные программой выше.

Для двух и более значных операндов, выполняется как обычно. Примеры:
2.^-00 + 51 = 53: П→x2  5  1  + =  53.         .
21 − 3.^-00 = 18: 2  1  П→x3  - =  18.         .
e^π − 3.^-00 = 20.14069: Fπ  Feˣ  П→x3  - =  20.14069    .
E1 + 2^.-00 = 43: 1  1  К-  ВП  КНОП  П→x2  + =  43.         .

Если дробное число (целая часть нулевая), то выполняется как обычно. Примеры:
0.5 + 4.^-00 = 4.5: 0  .  5  П→x4  + =  4.5         .
E.1^-01 + 4.^-00 = 5.41: 0  .  9  Fx²  К-  ВП  КНОП  П→x4  + =  5.41        .

Сами с собой числа N правила умножения на 10 не придерживаются и выполняются как обычно.
5^.-00 + 2.^-00 = 7: П→x5  П→x2  + =  7.          .
2^.-00 − 3.^-00 = -1: П→x2  П→x3  - = -1.          .

Так же как обычно работает, если второй операнд нулевой.
9.^-00 + 0 = 9: П→x9  0  + =  9.          . Для сравнения:
9.^-00 + 1 = 9: П→x9  1  + =  19.         .

Если число в X больше единицы, но имеет порядок не меньше 60, то число N снова воспринимается, как число в степени -160.
1.^62 × 7^.-00 = 7.^-98: П→x7  6  2  F10ˣ  × =  7.       -98.
1.^60 × 7^.-00 = 7.^-100: П→x7  6  0  F10ˣ  × =  0.          .
-1.^99 × 7^.-00 = -7.^-61: П→x7  9  9  F10ˣ  /-/  × = -7.       -61.

Если число в X меньше единицы, но имеет порядок меньше -40, то умножение снова проводится как обычно:
1.^-43 × 6^.-00 = 6.^-43: П→x6  4  3  /-/  F10ˣ  × =  6.       -43.
1.^-40 × 6^.-00 = 6.^-200: П→x6  4  0  /-/  F10ˣ  × =  0.          .
-1.^-99 × 6^.-00 = -6.^-99: П→x6  9  9  /-/  F10ˣ  /-/  × = -6.       -99.

Напомню, если число N находится в регистре X, то происходит обычное умножение, но если в Y тоже N (может другое), то будет как выше степень -160.
3^.-00 × 7^.-00 = 2.1^-159: П→x3  П→x7  × =  0.          .
Для проверки 01.П→x3  02.П→x7  03.×  04.8  05.0  06.F10ˣ  07.×  08.С/П =  2.1      -79.

Для деления ситуация похожая. Необычность возникает, только когда делят на N (N в регистре X). Если число в регистре Y по модулю в диапазоне 1 ⩽ Y < 10 (сюда же попадают шестнадцатеричные цифры), то в операциях деления N выглядит как число со степенью -160.
8^.-00 ÷ 2 = 4: П→x8  2  ÷ =  4.          .
18 ÷ 2^.-00 = 9: 1  8  П→x2  ÷ =  9.          .
0.8 ÷ 2^.-00 = 0.4: 0  .  8  П→x2  ÷ =  4.       -01.
8 ÷ 2^.-00 = 4^.160: 8  П→x2  ÷ =  ЕГГ0Г.      .
Для проверки составим программу: 00.Сx  01.8  02.П→x2  03.÷  04.7  05.0  06.F10ˣ  07.÷  08.С/П
После В/0  С/П на экране будет  4.        90.

Единственное исключение – это когда в Y тоже число N. Тогда деление снова проходит как обычно.
8^.-00 ÷ 2^.-00 = 4: П→x8  П→x2  ÷ =  4.          .

• F√. При взятии корня вычисляется как обычно, но результат делится на 10⁴⁸, т.е. степень числа будет -48. Пример:
  √(4.^-00) = 2.^-48: П→x4  F√ =  2.       -48.
  √(E.^-00) = 3.7416573^-48: П→xe  F√ =  3.7416573-48.

• F1/x. Обратная величина считает число N числом в степени -160.
  1 ⁄ (2^.-00) = 5.^159: П→x2  F1/x =  ЕГГ0Г.      .
  Для проверки составим программу: 00.П→x2  01.F1/x  02.7  03.0  04.F10ˣ  05.÷  06.С/П
  После В/0  С/П на экране будет  5.        89.

• Тригонометрические функции рассмотрим только на нескольких значениях.

  Для Fsin только в радианах будут отличия:

  X	Р	ГРД	Г
  1.^-00	8.4147098^-01	1.5707317^-02	1.7452405^-02
  1	8.4147103^-01	1.5707317^-02	1.7452405^-02

• Для Fcos тоже:

  X	Р	ГРД	Г
  2.^-00	4.4721363^-01	9.9950656^-01	9.9939082^-01
  2	-4.1614688^-01	9.9950656^-01	9.9939082^-01

• Для Ftg тоже:

  X	Р	ГРД	Г
  3.^-00	3	4.7158802^-02	5.2407778^-02
  3	-1.4254648^-01	4.7158802^-02	5.2407778^-02

• Для Fsin⁻¹ все отличаются:

  X	Р	ГРД	Г
  1.^-00	7.853981^-01	50.000003	45.000002
  1	1.5707963	100	90
  2.^-00	1.1071486	70.483276	63.434949
  2	ЕГГ0Г	ЕГГ0Г	ЕГГ0Г

• Для Fcos⁻¹ все отличаются:

  X	Р	ГРД	Г
  1.^-00	7.8539812^-01	49.999997	44.999998
  1	0	00	00
  2.^-00	4.6364761^-01	29.516724	26.565051
  2	ЕГГ0Г	ЕГГ0Г	ЕГГ0Г

• Ftg⁻¹ для чисел N всегда даёт ноль:

  X	Р	ГРД	Г
  1.^-00	0	0	00
  1	7.853981^-01	50.000003	45.000002
  8.^-00	0	0	00
  8	1.4464413	92.083315	82.874983

• Fx² вычисляет как обычно, но порядок числа при этом уменьшается на 160. При нормализации получается ноль:
  2^.00² = 4^.-160: П→x2  Fx² даёт  0.          .
  8^.00² = 6.4^-159: П→x8  Fx² даёт  0.          .
  Но небольшая проверка показывает истинную картину: 00.П→x8  01.Fx²  02.7  03.0  04.F10ˣ  05.×  06.С/П
  После В/0  С/П на экране будет  6.4      -89.

• Feˣ вычисляется как обычно.

• Flg выдаёт так:

  X	Flg
  1^.-00	0
  2^.-00	-43.128418
  3^.-00	-42.952326
  4^.-00	-42.827388
  5^.-00	-42.730478
  6^.-00	-42.651297
  7^.-00	-42.58435
  8^.-00	-42.526358
  9^.-00	-42.475205
  A^.-00	-42.429448
  B^.-00	-1.6057671
  C^.-00	-1.0267076
  D^.-00	-6.1309386^-01
  E^.-00	-3.0288357^-01

• Fln тоже начиная с B.^-00 выдаёт другой порядок:

  X	Fln
  1^.-00	0
  2^.-00	-99.306853
  3^.-00	-98.901388
  4^.-00	-98.613706
  5^.-00	-98.390562
  6^.-00	-98.208241
  7^.-00	-98.05409
  8^.-00	-97.920559
  9^.-00	-97.802776
  A^.-00	-97.697415
  B^.-00	-3.6974155
  C^.-00	-2.3640818
  D^.-00	-1.4117008
  E^.-00	-6.974152 ^-01

• F10ˣ выдаёт ошибку не из-за переполнения, а как обычно: порядок вне диапазона. Хотя отрицательные значения как результат возведения в степень конечно удивляют.

  X	F10ˣ
  1^.-00	ЕГГ0Г
  2^.-00	-13.02585
  3^.-00	-36.051703
  4^.-00	-59.077562
  5^.-00	-7.0398713
  6^.-00	-6.4318666
  7^.-00	-5.5095304
  8^.-00	-3.9441377
  9^.-00	-7.0326326^-01
  A^.-00	ЕГГ0Г
  B^.-00	ЕГГ0Г
  C^.-00	ЕГГ0Г
  D^.-00	ЕГГ0Г
  E^.-00	1

• Fxʸ ведёт себя тоже нестандартно. Если число N показатель степени, т.е. в регистре Y, то нормально работает только если число в X не меньше числа e (экспонента), а иначе даёт единицу.

  Fxʸ	1.^-00	1	2.^-00	2	3^.-00	3
  1	1	1	1	1	1	1
  2	1	2	1	4	1	7.9999993
  2.7182817	1	2.7182817	1	7.3890551	1	20.085531
  2.7182818	2.7182818	2.7182818	7.3890557	7.3890557	20.085535	20.085535
  3	2.9999994	2.9999994	8.9999984	8.9999984	26.999992	26.999992

  Если N основание, т.е. в регистре X, то ситуация печальней.
  1.^-00 работает как обычно, т.е. даёт единицу при любом показателе.
  2^.-00 быстро скатывается в ошибку:

  Fxʸ	2	2.29	2.30	2.31	2.32
  2.^-00	5.5355546^-87	1.7215634^-99	0(=6.3773317^-100)	ЕГГ0Г(=2.3624032^-100)	ЕГГ0Г(просто ошибка аргумента)

  Для остальных показателей и степеней выдаёт ошибку, кроме степени 1. Причем опять идёт изменение уровня начиная с B^.-00.

  Fxʸ	1
  2.^-00	7.4401479^-44
  3.^-00	1.1160242^-43
  4.^-00	1.4880297^-43
  5.^-00	1.8600371^-43
  6.^-00	2.2320432^-43
  7.^-00	2.6040517^-43
  8.^-00	2.9760592^-43
  9.^-00	3.3480707^-43
  A.^-00	3.7200738^-43
  B.^-00	2.478751^-02
  C.^-00	9.4035621^-02
  D.^-00	2.437284^-01
  E.^-00	4.9787053^-01

• К[x] считает числа N дробными, и выдаёт ноль.

• К{x} считает также, и соответственно, не меняет их, даже шестнадцатеричные.

• Кmax работает как обычно, причем она, например, числа 8 и 8^.-00 считает равными.

• К|x| тоже работает как обычно, т.е. если отрицательное, то минус уберёт, а мантиссу и порядок не трогает.

• КЗН тоже работает как обычно, т.е. даёт ±1.

• Набор функций К°→′, К°→′", К°←′", К°←′, которые обычно редко используются, здесь помогают расширить диапазон мантисс для чисел N. Дело в том, что они также считают такие числа дробными, но в отличии от остальных функций при обработке не трогают порядок. Это значит, что число по-прежнему остается с нулевой отрицательной степенью (если конечно в результате не понизится порядок). Пример:
  П→x3  К°→′"  К°←′  К°←′ выдаст  2.9999999-00, если чуть изменить: П→x3  К°→′"  К°←′"  К°←′", то уже  2.9945599-00
  Или П→xe  К°←′  К°←′  /-/ даст --.16     -00.

  Понятно, что таким образом набор мантисс ограничен, но всё-таки позволяет разнообразить набор чисел N.

• Логические функции, как обычно, вообще не обращают внимание на порядок и делают свою обычную работу, убирая всё лишнее.

Для тех, кто не хочет идти по ссылке (или высматривать мелкий шрифт скана) опишем игру. Это трехмерный лабиринт (3 этажа размером 7×4), где каждая ячейка на этаже может быть или свободна, или занята – "стена". Цель игры – находясь в некоторой начальной точке лабиринта пройти весь (выход в левой нижней точке на третьем этаже – влево) и собрать максимальное количество сокровищ. Для понимания адресации вот план 1-го этажа из публикации в журнале:

Сверху нумерация колонок, слева – строк (для битовой арифметики), а затемненные ячейки   обозначают стенки. Причем крестиком сразу показано положение игрока (для примера) в точке 1.0000008. Именно так расшифровываются координаты:

• Целая часть – номер этажа.
• Степень дробной части (количество нулей) – положение по горизонтали (колонка).
• Цифра в дробной части – положение по вертикали (строка).

С учетом этого выход из лабиринта (который предопределен) – влево от точки 3.8.

У игрока есть ограниченные ресурсы:

• Еда (в оригинале вода, но так как храниться в регистре Re, то удобнее называть еда). Тратиться при любом ходе.
• Динамит или гранаты (для запоминания храниться в регистре Rd или в обозначении ПМК  Г.          ) – используется для пробивания стенок (их уничтожения).
• Просто сокровища (хранится, аналогично, в Rc). Именно их нужно набрать побольше. В данной модификации реально набрать не меньше десяти (за одну игру).

Ресурс можно пополнить, поискав его (т.е. его может и не быть). Поэтому далее будем называть их кладами. При это на 1-м этаже будет еда (+9, в оригинале +10), на 2-м – динамит (+4) и только на 3-м сокровища (+1). Особенность – как только нашли, то на всех этажах в той же ячейке кладов уже нет.

Управление игрока – задание команды на движение, или поиск кладов, или подрыв стены (последней ячейки, где не удалось пройти). Каждая команда расходует еду (подрыв, понятно, ещё и динамит). Код направления движения определяется положением цифр на клавиатуре относительно центра: 2,4,6,8,±5 – вниз/влево/вправо/вверх и выше/ниже этажом. Подрыв стены нулем (в оригинале число Fπ, но обычно при неудаче прохода выдаёт 0, так что сразу и удобнее его использовать для команды подрыва). Поиск – число 10 (в оригинале ноль, но 1/0 как бы намекает на найдем/нет).

Если движение прошло успешно, то по окончании отображается новая координата игрока (в кодировке, как описано выше). Если нет – ноль. Выход из лабиринта определяется числом 11 (в оригинале трамвай 11-го маршрута).

При поиске клада: если не найдено – ноль. Если найдено, то показывает новое количество ресурса, а в регистре Y букву типа клада и позицию, где нашли, например:  E.00002     . При этом (как в оригинале) с разбойником, который защищал клад, можно бороться (В↑) или пропустить (0), затем С/П. Если боремся, то в результате общее количество (с учетом найденных кладов) данного ресурса может как увеличиться, так и уменьшиться.

При успешном подрыве – новое положение игрока, т.е. подрыв подразумевает сразу ход в новую ячейку (в оригинале для этого приходилось делать отдельный ход). При неудаче – ноль.

Несколько отличий демонстрационной программы от оригинала уже было сказано, но приведем весь список:

• Для подрыва используется два динамита (всё-таки программа сложнее ☺). На самом деле, изменен способ отображения нехватки еды/динамита, и чтобы их отличить используется такое "увеличение". Соответственно добавляется не по два, а по четыре, и вначале даётся не два, а четыре.
• При нехватке динамита или еды вместо ЕГГ0Г отображается соответственно -1 или -2 (еда или динамит).
• Подрыв определяется числом ноль (а не π), причем игрок сразу делает ход в новую ячейку (иначе зачем подрыв?).
• Поиск определяется числом 10, а не ноль. Кроме буквы типа показывается и положение клада на этаже (в оригинале только буква). Например  E.00002.
• Стенки удаляются, а не делается "xor". Хотя можно сделать в коде и так (поменяв К∨ на К⊕), но ставить новые стенки для затруднения прохода на мой взгляд нецелесообразно.
• Блокируется неожиданный "телепорт" из N.0000008 в N.0000001 при движении вправо (сказываются особенности округления). В оригинале автор в примере в нескольких местах поставил стенки, чтобы это не проявлялось.
• Блокируется подрыв "капитальных" стен. Это которые по краям лабиринта (слева, справа, сверху, снизу в том числе подвал и крыша). В оригинале это можно делать, что приводило к непредсказуемым результатам.
• Не портиться стек возврата. В оригинале при ЕГГ0Г не отрабатывала команда В/О, что забивало стек возврата. Хотя на работу самой программы это и не сказывалось.
• Начальное значение счётчиков (кроме сокровищ) заполняются автоматически программой. Не требуется вводить в начале игры. Понятно, что и "начало" сделано по-другому.
• И главное – ПМК сам(!) генерит как лабиринт, так и расположение кладов (в оригинале нужно было самому разработать, закодировать и вбить лабиринт) при каждой новой игре, причем начальное положении игрока обеспечивается "не в стенке". Получается, что в отличии от оригинала у игрока нет плана лабиринта и кладов. С учетом этого было принято решение немного увеличить начальный объем еды (36 против исходных 30), т.к. план неизвестен и придётся многократно упираться в стенки при изучении. Также подрыв стены совмещен с ходом на новое место.

Распределение регистров во многом совпадает с оригиналом.

• R0 – план кладов.
• R1…R3 – план 1…3 этажей.
• R4…R7 – специальные числовые константы для преобразования движения в битовую операцию: 2; 10; 0.1; 0.5 (точнее вместо 0.1 другое число, но смысл тот же). Т.е. берётся дробная часть положения игрока (положение на этаже) и производится умножение на указанные величины, как бы сдвигая бит вниз (2), влево (10), вправо (⅒) и вверх (½). В оригинале это всё вычисляется программно, но я предпочел убрать в регистры памяти, чтобы освободить большего место для команд. Хотя это и привело к дефициту регистров памяти.
• R8, R9 – содержат вспомогательные константы для адресов перехода и др., которые так же не меняются между играми. Детальное значение ниже по ходу изложения.
• Ra – текущее положение игрока в кодировке, указанной в описательной части.
• Rb – будущее положение игрока (куда он не смог пройти). Так же этот регистр (всего один!) используется как рабочий для всевозможных вычислений, поэтому при "не ходах" там может быть совсем другое значение, но в любом случае подрыв контролирует и это.
• Rc, Rd, Re, как было указано выше, используются для хранения ресурсов (сокровища/динамит/еда).

Итак, начнем с… начала. Как начинается игра (предполагая что глобальные константы вбиты, как и сама программа)? А вот так: задаётся начальное положение игрока на плане, например  1.0000001   , затем БП  48  С/П. Тут же фрагментик:

Положение игрока запоминается в Rb (как бы куда хотим пойти). Начальное количество динамита берем 6, а не 4, т.к. два придётся потратить на удаление возможной стенки в месте игрока – мы же ещё не знаем лабиринт. 36 (6²) – как начальное количество еды. А вот с регистром R0 проводим хитрые манипуляции. Благодаря особенностям косвенной адресации при первом обращении ноль превратится в -99999999, что соответствует регистру R3, затем в -99999998 – R2 и так пока не дойдет до R0, где -99999996 перепишется новым сгенерированным значением (уже положительным!), это и отслеживаем в цикле. Цикл возвращается на адрес 55, который и записан в R8 (точнее -55, но на адресацию это не влияет, а почему минус объясню позже). Сами операнды для К∨ получаются из КСЧ через функции F10ˣ и Fxʸ, которые "размазывают" цифры мантиссы случайного числа на все разряды и делают его более случайным. Причем испытания показали, что выгодней сделать FВx и Fxʸ вместо повтора КСЧ и F10ˣ для второго операнда (таки циклиться датчик, а эти операции его "сбивают"). Любители усложнения лабиринта (больше стенок и меньше кладов), могут заменить К∨ на К⊕

Следующий фрагмент, это снова начало…, но уже в программном виде (я отображаю фрагменты так, чтобы было понятнее позднее что и как):

Да, такой вот маленький фрагмент, поэтому явно требуются пояснения.

Для начала хочу обратить внимание, что в R7 у нас записано 0.5, что при косвенной адресации даёт нулевой адрес (не меняя R7), а это значит, что мы всегда можем быстро вернуться на начало через Кx≠07, или подобное. Поэтому С/П и располагается в самом начале.

Но, есть и другой момент. Можно расположить в конце адресного пространства подпрограмму без В/О, т.к. благодаря побочной ветви адресного пространства этот В/О "сыграет". Более того, могу сразу сказать, что несмотря на наличие четырёх логических подпрограмм программа содержит всего этот один В/О. Две подпрограммы удалось наложить на хвост другой, а начальный В/О смог "сыграть" в двух разных адресных побочных ветвях.

Иногда разницу в методах возврата используют для различения ситуации. Например, в оригинале в начале стоит Cx, куда возвращается управление при неудаче, или на +01 при удаче. Но мне удалось сэкономить даже на этой команде. Позднее поясню как.

Прежде, чем продолжить код инициализации, который мы бросили, хочу привести основную подпрограмму, которая делает битовую проверку. Сначала приведем формализацию: на входе ожидается в регистре X план этажа для проверки (битовая маска). В регистре Y положение игрока (бит). После исполнения: значение Y безусловно запишется в регистр Rb. Если битовая проверка прошла успешно (совпадение), то значение из Y также попадет в регистр Ra, в Y останется дробная часть (положение на этаже), а само значение будет уже в X. Если битовая проверка не успешна, то вернет ноль в регистрах X и Y. Посмотрим, как это делается.

Если с битовым умножением и копированием Y в Rb всё ясно, то вот Кmax явно использован "недокументировано". При неудаче ноль из регистра Y будет "недокументировано" скопирован как "самое большое число" в X. Т.е. при неудаче будет ноль (что от подпрограммы и требуется). А если битовая операция успешная (есть дробная часть), то ничего не произойдёт (т.е. исходный Y останется в X, а дробная часть в Y). И результат будет скопирован в Ra.

На самом деле эта подпрограмма полезна ещё в другом случае. Если (на входе) в одном из регистров X или Y число состоит из одной цифры, то эта процедура безусловно даст на выходе ноль. Эта возможность тоже используется в программе, поэтому назовем её также процедурой очистки.

Но внимательный читатель спросит, а где же В/О? А он расположен по адресу... ноль! Так вот, тут используется побочная ветвь адресного пространства, но только не после 105 адреса, а после F9-го. Да, адрес F9 = 47, а значит если подпрограмма начинается не с адреса 41 (как будто), а с того же адреса, но как F3, то после адреса F9 (47) управление перейдет на 00, т.е. на ту самую В/О.

Здесь уже уже можно раскрыть, что константа с регистре R9 (он используется для вызова этой подпрограммы) заканчивается на F3 (можно и на ED). Точнее в R9 храниться  4. 3     -08 (или  4.EГ     -08, кому как больше нравиться). Зачем вначале идёт 4 и такой порядок будет пояснено позднее (хотя если читали весь документ, то об этом уже упоминалось). Главное, что такой "довесок" не меняет косвенной адресации. Упомяну только, что после "использования" в косвенной адресации значение в R9 станет не нормализованным  0.00004 3-03, зато сразу покажет адрес перехода.

Продолжим код инициализации (начальной генерации лабиринта). Точнее он уже закончился и плавно переходит в подпрограмму, которая "взрывает" стенки. В чем смысл такого "слияния"? Во-первых не требуются какие либо БП, во-вторых, нам всё равно нужно обеспечить, чтобы в точке высадки стенок не было, т.е. как бы убрать её (даже если её там не было). Вот поэтому и было вначале на две динамита больше. Итак:

Тут вроде понятно, что из ресурса динамита (Rd) убирается два, проверяется что что-то осталось (не отрицательное) и остаток сохраняется обратно. Если динамита не осталось, то переходит на начало, с этой "-2", что по смыслу программы и нужно для сигнализации, что динамита нет. Причем сохранение остатка делается после проверки, чтобы не было -2, -4, -6 и т.д. Продолжим.

Напомню, что координаты взламываемой стены находятся в Rb. Вначале проверяем, что это значение в пределах регистров R1…R3 (т.е. < 4), причем R0 тоже пройдет проверку, но это не страшно и вот почему. На самом деле в Rb число меньше единицы может быть или в виде одной цифры (например, хотели с первого этажа 1.0002 пойти вниз и получили 0.0002) или просто ноль (есть такой путь при попытке выхода за границы этажа). Главное, что число будет из одной цифры, т.е. со второго разряда цифр нет, а значит в этом случае план этажа извлечется из плана кладов R0, потому что косвенная адресация через Rb будет равна нулю (да, последние две цифры мантиссы будут нулевыми, даже для числа 1.^-07, что можно посмотреть в главе по косвенной адресации). Затем операция К∨ ничего не изменит (нет цифр у второго операнда) и вернет обратно в R0 значение неизменным. А если число больше или равно 4, то мы перейдем на процедуру очистки (зануления) через регистр R9. С учетом работы остальной части программы (это можно потом прикинуть) для Rb >= 4 число в Rb либо состоит из одной цифры (взлом левой стенки) и процедура очистки безусловно сработает, либо это "крыша" (Rb = 4.{…}). Но в R4 у нас тоже константа из одной цифры, а значит процедура очистки тоже сработает.

Для R1…R3 это операция установит бит из Rb в плане этажа. В этом случае в X у нас план этажа, в Y точка взлома, которую мы тут устанавливаем. В этом случае основная процедура успешно пройдет битовую проверку (мы же только что этот бит поставили) и завершиться, записав новое расположение в регистре Ra. Т.е. мы сразу сделаем ход в новое место.

Итак. Инициализация закончена. Игрок в точке высадки, стенки там нет. Мы познакомились с основной процедурой из регистра R9, она же процедура очистки и процедурой взлома стены (с адреса 63), которая тщательно проверяет все варианты. Теперь можно вернуться на точку остановки (начальный С/П) и начать самый частый (основной) код:

Тут, очевидно, уменьшается еда, похожим образом, как динамит, учитывая, что будет выдано -1 при неудаче. Обращаю внимание, что если исключить наш случай, когда регистров просто не хватает, тут всё равно делается экономия на команде. Всё-таки x→ПR  П→xR – это две команды, а <-> – только одна. Но это конечно при условии, что запомненное значение не понадобиться ещё раз. Далее.

Вот и проверка команды на взлом стены. "Но позвольте, зачем сначала деление, а только потом проверка на ноль?" спросите вы. Ответ в том, что нам не хватает регистров (кстати, обратите внимание, что рабочий регистр Rb с последней попытки хода пока не задействован, и взлом будет на его основе). Поэтому выбор пользователя (точнее получается уже полвыбора ☺) мы запоминаем в регистре… X2. Да, да, вспомните, ведь проверка условий при успехе запоминает X в X2. А дальше посмотрим, как мы это используем:

Ага, вот и выбор пользователя преобразован в номер регистра для коэффициента умножения. Для прояснения, приведу таблицу с возможным выбором игрока (ноль уже исключили), и то, что попало в регистр Rb:

Вариант ±5 не будет использовать регистр Rb, как мы увидим позднее.

Обратите внимание, что мы на самом деле сложили не с тройкой, а с числом π. Почему? Дело в том, что команда Fπ не X2-влияющая, к тому же при косвенной адресации дробная часть значения не имеет (вспоминаем – всё это из главы по косвенной адресации). Т.е. для нас всё равно, будет в Rb число 7 или 7.1415926, при КП→xb он всё равно извлечет 0.5 (значение в R7).

А самое главное, это то, что останется после команды ВП. Вспомним из главы про X2, что сочетание этой команды с предшествующей командой сохранения в регистр "съест" первую цифру числа из X2 (важно ещё то, что в результате сложения с π значение в X не отрицательное) и восстановит его в X. А что у нас в X2? Это значение во второй колонке таблицы выше. Т.е. он для всех вариантов из таблицы оставит ноль, и только от ±2.5 оставит ±0.5. Вот сколько может сделать одна недокументированная команда! Далее обработка варианта с вверх/вниз (±0.5):

Что он делает? Он преобразует движение между этажами ±0.5 в ±1 (тоже, кстати, трюк вместо умножения на 2) и переходит на некий адрес EA. Другие движения будут обработаны с адреса D4 (если кто не знает, при наборе программы и вводе таких адресов вместо цифр нажимаются кнопки с соответствующими буквами). Что за странные адреса, спросите вы? А дело в том, что в конце всё это закончиться на основной процедуре, которая расположена по нестандартным адресам, а значит и текущую ветвь выполнения нужно "завернуть". D4 – тот же адрес 22, т.е. как раз окончание этого кода, а EA равно 38. Точнее, адресу 38 соответствует адрес F0, но такое не ввести, поэтому мы заменяем аналогом (трюк). Ладно, займемся этим адресом, когда туда дойдем, а сейчас продолжим движение по этажу (или проверку клада), но сначала таинственное пропускание вперед:

Так, пришла пора раскрыть, что же находится в регистре R6, которое почти 0.1. Там храниться число D.^-02 ( Г.       -02). Дело в том, что в операции умножения, если D находится слева (в X), то оно ведёт себя как 10 (кто забыл, просмотрите главу про шестнадцатеричную арифметику), а для степени -02 получается как 0.1 (10 × 10⁻² = 10⁻¹). А когда справа (в Y), то гораздо хитрее. Это "хитрее" нам понадобится позднее, поэтому пока загоняем число в стек, чтобы оно было "справа" (я мысленно стек представляю как X1–X–Y–Z–T, если кто-то по другому, то "справа" поменяйте на другое).

Ну вот, наконец-то умножение дробной части числа Ra (положение на этаже) на коэффициент движения (не забыли, что у нас в Rb?). Тут же проводится отсечка варианта поиска клада. Дело в том, что в R8 (вариант 10 / 2 + 3) число отрицательное (-55, если кто забыл, и вот оказывается для чего минус), а значит поиск уходит на адрес 77. Но это не всё. Тут мы опять используем регистр X2 (через X2-влияющую операцию сравнения). Мы сохраняем новое положение игрока на этаже в X2, но не потому что нет регистра, а для экономии команд: x→Пb  П→xb это две команды, а ., всего одна, а сравнение всё равно нужно делать. Именно поэтому сравнение делается не сразу после КП→xb, а после умножения, чтобы запомнить в X2 итог.

Так, теперь, после получения нового значения на этаже нам нужно проверить, что в результате мы не вышли за границы этажа. Изучим такую проверку подробнее.

Рассмотрим для начала левую границу. Как мы можем за нее попасть? Только если перед этим было число M.N (M=1,2,3; N=1,2,4,8), а затем мы N умножили на 10. Понятно, что потом мы "дробную" часть приплюсуем к этажу M. В данном случае она очень даже не дробная, но в результате сложения итоговых вариантов не так много, и самое главное, они будет в диапазоне 2…11 и состоять только из одной цифры (кроме 11). А одна цифра бинарную конъюнкцию (К∧) "не переживет" в процедуре очистки. Вариант c 11 (влево от 3.8) – это исключение, поэтому он и выбран как выход из лабиринта. Причем будет выполнена операция 1 1 ∧ КП→xb. Т.е. даже регистр Rb (b = 11, кто забыл) выбран не случайно (трюк с подтасовкой регистров)! В общем, левая граница "защитилась" автоматически.

Правая граница. Там значение дробной части становится порядка 1.^-08 и при сложении с номером этажа просто потеряется (точности не хватит на 9 цифр), опять же оставляя только одну целую часть, которая будет 1…3 и конъюнкцию не переживет. Исключение составляет 8.^-08 (округление до 1.^-07), но и его мы победим позднее.

Верх и низ. При переходе верхней границы (1 × 0.5) получается число, оканчивающиеся на 5, а при переход нижней (8 × 2), число из двух цифр. Вот тут нам и пригодится таинственное D.^-02 из R6. Используя знания шестнадцатеричной арифметики можно узнать, что при умножении (D.^-02 как раз осталось справа) на число 1, 2, 4 или 8 результат будет содержать только одну цифру, а на 5 и тем более 16 уже больше. Это поясняет последующий код:

Здесь кроме того, что указано, применяется ещё один трюк. После умножения будет число с одной или более цифрой. Как же вычислить одна или больше? Приходит на помощь операция К∨ при том, что в регистре Y остался ноль ещё после команды ВП по адресу 15 (какой автор предусмотрительный, даже давний ноль у него при деле ☺). В результате будет 8. – всё хорошо или 8.{с чем-то} – плохо, а после К{x} либо ноль, либо 0.{что-то}. Вот это плохое "что-то" последняя команда и отправит на процедуру очистки. Для очистки важно, чтобы в одном из регистров X или Y было число с одной цифрой – число ноль в Y вполне подходит (да, в логических бинарных операциях второй операнд не исчезает, но это таки документировано). Продолжим далее.

Первое что мы делаем, это восстанавливаем X2 (новое положение на этаже) ещё с команды сравнения по адресу 17, т.к. все команды в промежутке были не X2-влияющие. А потом корректируем значение на маленькую величину порядка 4^.-08. Это не изменит итог ни для кого, кроме 8.^-08. В этом случае оно тоже станет очень маленьким. Вот где заблокирован "телепорт" и вот зачем в R9 к адресу переход были добавлены четвёрка вначале и порядок -08. Далее проще:

Мы к нашему новому значению на этаже прибавляем номер этажа (целая часть Ra), заталкиваем новые координаты в Y, а в X оставляем план этажа. На самом деле в Rb могло получится не только 1…3, но и другое, поэтому идёт переход на основную процедуру (она идёт следом с адреса 41 = F3, и мы её уже смотрели), которая отбросит все нестандартные этажи (одна цифра в числе), а также случай, когда битовая карта этажа просто не совпадет с положением игрока. Обращаю внимание, что основная процедура запомнит в Rb полное значение нового положения, т.е. если даже по этажу не пройти, мы запомним точку, куда хотели попасть. В случае удачи эта процедура автоматически обновит содержимое Ra.

Вспомним про адрес перехода 38 = EA, куда мы попадаем при движении между этажами. Оказывается – банальный плюс, но с учетом раннего ±1 и извлеченного Ra, это "то, что доктор прописал" (вверх/вниз). Так вариант с движение вверх/вниз плавно влился в текущий кусок кода (очередной трюк).

Ну вот основная часть кода рассмотрена, остался поиск клада (и разбойник!). Там тоже не всё так просто.

Тут мы для проверки битов (возможности взять клад) пользуемся основной процедурой. При этом в регистр Y ставим содержимое Ra, чтобы при удаче, оно же и сохранилось в Ra (это факт действия основной процедуры). Понятно, что если кладов уже нет (убран бит в нужном месте), то по нулю уходим на начало. Далее убираем бит клада из маски в регистре R0.

А теперь мы приведем код, который из номера этажа получит шестнадцатеричную цифру, из соответствия 1 = E, 2 = D, 3 = C. В оригинале автор использовал для этого заранее сохраненную константу "E" и цикл с уменьшением её через регистр R0. Мы сделаем тоже самое без использования дополнительных регистров и короче, пользуясь недокументированными возможностями.

Тут снова придётся вспомнить раздел про регистр X2 и команду ВП, которая восстанавливает его. Сначала с помощью сложения с 10 (константа из R5) мы номер этажа загоняем во второй разряд. Тут порядок операндов важен, т.к. последний П→x и будет содержаться в X2. Затем с помощью инверсии и отсеканию целой части (первой цифры) мы получим, что нужная буква находится в первом разряде. Но в X вроде ещё что-то есть? Так вот, восстановление X2 через ВП, сделает так, что при восстановлении X2 только первая цифра останется из X, т.е. 2.00004 восстановиться в D.00004. То, что нам нужно. Ещё нужно помнить, что перед ВП должна быть любая не X2-влияющая команда, которая будет выполнена, но результат проигнорирован. Обычно для этих целей используется КНОП, но мы используем КСЧ. Дело в том, что основная процедура может использовать Кmax с нулем в Y, а это "сбрасывает" датчик случайных чисел. Для последующих игр (вдруг захочется пройти другой лабиринт) желательно "оживить" датчик случайных чисел ("с паршивой овцы хоть шерсти клок" – даже из игнорируемой команды пытаемся получить эффект). Идем далее.

Сохраняем полученную букву с дробной частью в Rb и оставляем его в стеке для информации игроку. Потом не только извлекаем старое значение ресурса, но и заодно отсекаем дробную часть от буквы (при косвенной адресации), чтобы потом преобразовать её в нужную добавку. Тут нужно пояснить, что именно происходит для вычислении "добавки", в зависимости от значения регистра X (C, D или E). При вычитании срабатывают правила шестнадцатеричной арифметики.

Код борьбы с разбойником полностью взят из оригинала. Главное, чтобы переключатель Р-ГРД-Г был в положении Р. Окончательное значение ресурса сохраняется.

Вот собственно и всё, финальный В/О по адресу A5 (или 00) "сыграет", чтобы "сбить" программу с малой побочной ветви и вернуть в нормальное русло.

Начальные значения констант (которые не меняются между играми):

• R4 = 2
• R5 = 10
• R6 = D.^-02 ( Г.       -02
• R7 = 0.5
• R8 = -55 (с минусом)
• R9 = 4.F3^-08 ( 4. 3     -08

Вот последовательность для ввода констант:
5  5  /-/  x→П8
4  4  7  3  В↑  8  0  8  К∨  К{x}  ВП  7  /-/  x→П9
1  0  x→П5
2  x→П4
F1/x  x→П7
2  2  КИНВ  К{x}  ВП  1  К[x]  ВП  2  /-/  x→П6

Положение переключателя Р-ГРД-Г должно быть в Р. Перед первой игрой (или каждой, если не хотите аккумулировать сокровища) регистр Rc нужно обнулить.

И напомню порядок начала игры: задаётся начальное положение игрока на плане, например 1.0000001 – можно быстро получить как П→x9  F10ˣ (кто-то можета подумать, что автор даже это предусмотрел, но нет, это, но только это, случайно так совпало). Затем БП  48  С/П

• Адрес перехода храниться в регистре для сокращения длины команды при косвенном обращении. Для R7 это команды по адресам 05, 46, 66, и 80. Для R8 – команда по адресу 62. Для R9 – команды по адресам 32, 71, 76, 79.
• Использовании константы в двух смыслах. R5 – как коэффициент умножения по адресу 26, так и для "сдвига" во второй разряд по адресу 86. R7 – тоже как коэффициент умножения, но и как адрес перехода. R8 – кроме косвенной адресации используется отрицательным для проверки хода поиска клада по адресу 27. R9 – кроме косвенной адресации используется для корректировки округления по адресу 34.
• Цикличность адресного пространства. В процедуре после команды по адресу 47 нет команды В/О, и последняя команда в программе также не В/О, которая "удачно" расположена по нулевому адресу, для этих случаев.
• Использование хвоста одной процедуры для другой: основная подпрограмма, которая вызывается из многих мест, идёт сразу после окончания вычисления нового положения (адрес 41).
• "Слияние" окончания одной процедуры с другой для исключению команды перехода. В данном случае окончание инициализации и начало взлома стены по адресу 63. А также слияние двух веток вычисления (этажной и межэтажной) по адресу 38.
• Регистр X2. Несколько раз. Сохранение по адресу 10, чтобы извлечь по адресу 15, уже после того, как значение поучаствовало в операции сложения (экономия регистра), причем с применением не X2-влияющей π вместо тройки. Сохранение по адресу 27 и восстановление по адресу 33 (экономия одной команды). Сохранение по адресу 85 и нестандартное восстановление по адресу 90 (экономия нескольких команд).
• Использование ВП. Совмещение восстановления X2 с неявное операцией взятия дробной части по адресу 15. Объединение X2 и шестнадцатеричной цифры по адресу 90.
• Использование знаний косвенной адресации. Кроме значений в регистре R7 … R9, это "игнорирование" дробной части после сложения по адресам 13 или 38, и умышленное "отрубание" её по адресу 92. А также необычное использование регистра R0 в цикле по адресу 62 с отрицательным счётчиком.
• КЗН как команда умножения на 2 по адресу 19.
• К∨ для проверки, что число содержит более одной цифры по адресу 30. Тут следует сравнить с оригиналом, где автор для проверки выхода за границы верх/низ использовал конъюнкцию квадрата нового положения и числа π, проверяя нулевой бит (and 1) во втором разряде (после возведения в квадрат 5² = 25 и 16² = 256 его содержат, а 1² = 1, 2² = 4, 4² = 16, 8² = 64 – нет). Вроде, это выглядит как альтернатива, вместо команд П→x6  ×  К∨ использовать Fπ  Fx²  К∧, при условии, чтобы π было "справа" (чтобы правильно пройти процедуру очистки, благодаря отрезанию первой цифры и тому, что биты 2 и 3 у числа π не пересекаются: для 3.14… это 1 и 4). Это даже можно сделать, длина программы не измениться, даже R6 можно сделать обычным 0.1. Но тут есть подводный камень: процедура очистки также запомнит число "справа" в Rb, а для процедуры подрыва и проверки выхода за границу Rb такое количество цифр в числе недопустимо (процедура очистки вместо очистки внесёт в Ra что-то случайное). Вот так, иногда приходится использовать недокументированные возможности для корректности поведения алгоритма (без увеличения длины программы).
• Использование шестнадцатеричной арифметики. Содержимое регистра R6 используется то как 0.1 по адресу 26, то как увеличения количества значащих цифр по адресу 29. Операция вычитания по адресу 95 приводит цифры C, D, E к более удобным 1, 2, 3.
• Использование Кmax в нестандартном случае для "просвечивания" нуля из Y по адресу 45. Тут нужно заметить, что процедура по адресу 41 может быть реализована разными способами. Например и так: <->  x→Пb  К∧  К{x}  Кx≠07  П→xb  x→Пa. Но при этом в стеке останется план этажа/кладов при неудаче. А этой подсказки хотелось бы избежать, т.к. многие команды игры подразумевают дополнительную информацию в регистре Y после остановки. При том порядке что у нас, план этажа/кладов безвозвратно теряется из стека в любом случае (удача или нет).

Как не странно, даже такую "плотную" программу можно ещё улучшить. Например, если потребовать в начале каждой игры после ввода начального положения нажатия В↑ перед C/П. Тогда начало можно переместить на адрес 44, где уже есть команда x→Пb, и убрать её с адреса 48. При этом, кстати, будет реализован редкий трюк, связанный с исполнением одних и тех же команд, но в разных адресных ветках вычисления (и с разными целями и результатом). А потом, например, использовать сэкономленную команду для начального обнуления количества сокровищ, например x→Пс по адресу 54.