Нейросеть

Эскиз схемы набросал: В принципе, можно обойтись ИМС К155ЛА3 / 7400.
Был детектор электрического поля на ИМС КМОП - есть мысль повторить, но на своём принципе (на К561ЛА7 / CD4011).

 

Я бы длину взял в кавычки.

На мой взгляд: это незначительно, большее влияние оказывают "произведение" h21 конкретных транзисторов по различным "ветвям" вход-выход.

 

Ну, да... Верно.
Кстати, есть любопытная схемка в тему - радиожучок на К155ТЛ3. Собрать её - руки никак не доходят (был бы он квантовым или торсионным - давно бы собрал).
Внутренние связи ИМС образуют своеобразный контур с определёнными характеристиками.
Правда, ТЛ3, в отличии от ТВ1, ТМ2 или ТР2, не поддаётся "управлению" - нет устойчивого состояния.

Ну, если на каждые ~20 см проволоки приходится задержка ~1 нс, какой-то смысл всё-таки есть.
Например, если поместить дешифратор внутрь пружины и подпаять его выхода к нужным виткам: Эффект "линии задержки" имеет место.

В прошлом году я NE555/ВИ1 уже подключал к НЧ-входу телевизора и экспериментировал с максимальной для ИМС частотой. Достиг примерно 200 кГц на "воздушных конденсаторах" с подстройкой. На экране были полосы и шашечки, но сбивались от всякого чиха (словно терменвокс). Потому, подобные таймеры не годятся для моих "астрологических опытов".
На RS-триггере - самое то: Никаких аналоговых радиоэлементов!

P.S.: В любом случае, стохастическое нечто должно будет проявиться.

 

Весь вечер пытал нейросеть для помощи в решении некоторых проблем разработки своего процессора, однако...

 

Не удивительно, почему я шесть лет топчусь вокруг да около и не могу никак написать полный эмулятор.

Вчера на досуге попробовал сделать эскиз обработчика префиксов - не такая сложная схема:

Конечно, в переводе на нормальную схему - около 40 ИМС ТТЛ получается.

Verilog-модель не такая сложная, да и ТТЛ тоже, если не учитывать, что слишком много шин только с шириной слова в 16 бит (для 8-битного варианта).

 

Немного разобрался с предполагаемой распиновкой:

В отличии от i8085 и i8086, здесь Шина Данных совмещена со старшими битами Шины Адреса, так как младшая часть адреса обычно меняется чаще старшей.
Тем самым, ИР23 защёлкивает A8-A15 по ALE только по надобности.
А вот два ИР13 хранят индекс делегата, обнуляясь по SYNC и защёлкивая по DUE (Device Unit Enable).

Сигнал DUE выполняет почти ту же функцию, что IORQ у Z80. Только у Z80 IORQ - отдельное адресное пространство до 64 Кб. В моём же случае, делегирование - адресация A16-A31.

Тем самым, 8-битный WYSIWISC может адресовать до 4 Гб адресного пространства (аналогично как у x86 сегменты по 16 байтов, у меня 65536 делегатов по 65536 байтов).

P.S.: Тем самым, железная модель под Verilog теперь вырисовывается отчётливее.

 

В общем, у страха - глаза велики!
По-хорошему сел и в Logisim сделал эскиз основного узла управления формирователем эффективного адреса.

Работает достаточно просто:

1. Подаётся страршая тетрада префикса
2. Устанавливается как база (set) или последующие индексы (en)
3. Вырабатывается shift или scale, в зависимости с тем, что нужно делать с суммой индексных вкладов

В схематике анимацией это работает так (testbench-схема - драфтовая и чисто для визуализации процессов скалирования индексных регистров D0-D9: для построения процессора бесполезна):

Что совпадает с JavaScript-декодированием и дизассемблером на i8080/ВМ80.


В целом, если схему переводить в номенклатуру ТТЛ, получается примерно 16-20 ИМС.

P.S.: Причём тут нейросеть?
Бот подтрунивает меня, что раз я 30 лет этим увлекаюсь, но лишь прошедшие 5 лет были результативные в разработке прототипа, полную модель WYSIWISC я смогу получить лет через 50!

 

Эскиз схемы на номенклатуре ТТЛ получился не такой страшный, как предполагалось:

Протактировал - всё работает.
Правда, сам Logisim не ведёт себя достаточно стабильно, так как иерархия с УГО слишком сложна для симуляции.
Но в целом - схема примерно в 16 ИМС не так уж и сложна.
Правда, напрягает то, что у нижних ИР27/ИР22 старшие разряды никак не используются и пропадают зря: Нужно удалить ИР19 и его функцию перенести на ИР27, добавив мультиплексор КП11.

Напомню: В архитектуре WYSIWISC данный узел должен управлять индексной суммой в указателях.

1. Режим последовательного накопления - [base+(index1+index2+index3)] -> [base+x1+x2+x3]
2. Режим последовательного масштабирования - [base+((index1+index2+index3)*2+index4+index5)] -> [base+2x1+2x2+2x3+x4+x5]
3. Режим расширенного масштабирования - [base+((index1+index2+index3)*2+index3+index4+index5)] -> [base+2x1+2x2+3x3+x4+x5]

Логика простая, но требует слишком много вентилей для проверки повторного вхождения индексного регистра в текущий уровень вклада, из-за чего и получается громоздкость.

 

Во-первых, первый прототип был на ПЗУ, так как в симуляторе не совсем понятно было, какой будет система команд вообще. Прошивку ПЗУ накидал по ходу разработки. Теперь у меня всюду - только комбинаторика.
Во-вторых, конкретно данный узел, пусть даже и путанный, но предельно прост:

Код (Text):

1.  
2. module  vector_accumulator
3. (input  wire        clk     // Clock - positive edge
4. ,input  wire        vector_en   // Enable parse vector
5. ,input  wire        vector_clr  // Clear vector (after any instruction)
6. ,input  wire    [7:0]   operation   // Operation code (BDC only)
7. ,input  wire    [15:0]  vector_input    // Pointer input
8. ,output reg [15:0]  vector_output   // Full vector output
9. ,output reg     vector_margin   // Marginal flag
10. );
11.     reg     is_base;    // Flag of "base"
12.     reg     is_shift;   // Flag of "shifting"
13.     reg [3:0]   the_base;   // Index of current "base"
14.     reg [9:0]   pointers_set;   // Collection of used pointers
15.     reg [9:0]   pointer_mask;   // Mask of current pointer
16.     reg [15:0]  vector_base;    // Pointer of "base"
17.     reg [15:0]  vector_index;   // Summ of used pointers
18.     reg [15:0]  vector_offset;  // Decimal offset
19.     reg [3:0]   base_index; // Index of "base" in operation code
20.     reg [3:0]   offset_digit;   // Digit of BDC-digit for "offset"
21.     reg [15:0]  offset_shift;   // Offset multipled by 10
22.  
23.     string  offset_string;
24.  
25.     always  @*
26.     begin
27.         base_index = operation[7:4];
28.         offset_digit = operation[3:0];
29.         offset_shift = (((vector_offset << 2) + vector_offset) << 1) + {12'd0, offset_digit};
30.         pointer_mask = 10'b1 << base_index;
31.         is_base = &(the_base ^ base_index);
32.         is_shift = |(pointers_set & pointer_mask);
33.         vector_margin = vector_en && ~|offset_digit && is_base && ~|vector_offset && ~|pointers_set;
34.         vector_output = vector_base + vector_index + vector_offset;
35.     end
36.  
37.     always  @(posedge clk)
38.     begin
39.         if(vector_clr)
40.         begin
41.             $display("Clear vector");
42.             the_base <= 0;
43.             vector_base <= 0;
44.             vector_index <= 0;
45.             vector_offset <= 0;
46.         end else
47.         if(vector_en)
48.         begin
49.             $write("%02X[%04X] - ", operation, vector_input);
50.             vector_offset <= offset_shift;
51.             if(~|the_base)
52.             begin
53.                 the_base <= ~base_index;
54.                 vector_base <= vector_input;
55.                 pointers_set <= 0;
56.                 $display("Set base D%x", base_index);
57.             end else
58.             if(vector_margin)
59.             begin
60.                 the_base <= 0;
61.                 $display("Set margin #%x", base_index);
62.             end else
63.             if(is_base)
64.             begin
65.                 vector_index <= vector_index << 1;
66.                 pointers_set <= pointer_mask;
67.                 $display("[%04X+%04X<<1+%05d]", vector_base, vector_index, offset_shift);
68.             end else
69.             if(is_shift)
70.             begin
71.                 vector_index <= (vector_index << 1) + vector_input;
72.                 pointers_set <= pointer_mask;
73.                 $display("[%04X+%04X<<1+%04X+%05d]", vector_base, vector_index, vector_input, offset_shift);
74.             end else begin
75.                 vector_index <= vector_index + vector_input;
76.                 pointers_set <= pointers_set | pointer_mask;
77.                 $display("[%04X+%04X+%04X+%05d]", vector_base, vector_index, vector_input, offset_shift);
78.             end
79.         end
80.     end
81. endmodule
82.  

Псевдокод ТТЛ-модуля примерно такой

Код (Text):

1.  
2. модуль разбора_цепочки_префиксов
3.     маска_чётности_вклада_индексов = 0
4.     индекс_текущего_регистра_базы = 0
5.  
6.     по_тактовому_фронту
7.         если это_первый_префикс_цепочки
8.             маска_чётности_вклада_индексов = 0
9.             индекс_текущего_регистра_базы = старшая_тетрада
10.         иначе
11.             если старшая_тетрада == индекс_текущего_регистра_базы
12.                 маска_чётности_вклада_индексов = 0
13.                 сигнал "масштабировать всю сумму вкладов вдвое"
14.             иначе
15.                 если маска_чётности_вклада_индексов содержит (1 << старшая_тетрада)
16.                     маска_чётности_вклада_индексов = 1 << старшая тетрада
17.                     сигнал "масштабировать всю сумму" и "прибавить индекс"
18.                 иначе
19.                     маска_чётности_вклада_индексов |= 1 << старшая тетрада
20.                     сигнал "прибавить индекс"
21.  

Говоря языком x86 - узел отслеживает валидность индексов в инструкции LEA:

• [EAX+EBX+ECX] -> [EAX+(EBX+ECX)] -> индексные вклады EBX и ECX уникальны
• [EAX+EBX+ECX+EBX] -> [EAX+(2*(EBX+ECX)+EBX)] -> регистр EBX повторился: масштабируем текущий вклад и открываем следующий, включая EBX
• [EAX+EBX+ECX+EAX] -> [EAX+(2*(EBX+ECX))] -> регистр EAX здесь база, а не индекс: масштабируем текущий вклад и открываем новый уровень

То есть, можно закодировать инструкцию, аналогичную LEA EAX,[EAX+19*EBX+79*ECX+1708*EDX+65500*ESI+16777215*EDI], используя сдвиг и накопление - последовательное умножение.

На самом деле, схема не такая уж и страшная, как может показаться, глядя на кодируемые индексы в векторах.
На ИМС К155ИМ3 довольно просто реализуется с обратными связями.
Правда, этим потоковым накоплением необходимо было управлять. И этой схемы у меня не было.
Разработал этот "координатор индексной суммы" лишь на днях.

P.S.: Спасибо за внимание!
Проект крайне туго идёт
Бот нейросети подмечает, что это из-то того, что я параллельно пытаюсь делать эмуляторы на Bash, JavaScript и даже i8080, а также Verilog-модель и Logisim схемы пытаюсь отладить, у меня всё крайне сильно лагает и взаимно тормозит (пытаюсь командный труд выполнить в одиночку).
Совет: Не метаться из стороны в сторону, а написать 100% эмулятор на JavaScript, а затем и 100% модель на Verilog.
(Сейчас наиболее проработан - эмулятор на Bash)

 

Теперь куда эстетичнее получилось!

Теперь, как можно заметить, тактируются только регистры ИР27, а мультиплексор КП11 закольцовывает биты индекса базы и заменяет регистр ИР19 в совокупности.
Схема графически получилась достаточно плотной, однако число корпусов ИМС получается порядка 16 шт.

• IC4…IC7 - Instruction Code: Биты 4…7
• B0…B3 - Base (индекс базового регистра)
• EB - Enable Base (разрешение фиксирования индекса базового регистра)
• EN - Enable работы модуля
• S - Synchronize (разрешение синхронной работы / сброс индекса базы)
• ROTATE - Сигнал для прокрутки индексного вклада («index <<= 1») - повтор индекса
• SHIFT - Сигнал для расширения индексного вклада («index += register») - разрешение вклада

Два сигнала ROTATE+SHIFT образуют прокрутку индексного вклада с расширением «index = (index << 1) + register».
В принципе, если симулятор не подводит (всё-таки в Logisim всю библиотеку ИМС ТТЛ сам нарисовал), можно перенести в KiCAD или Proteus для дальнейшего анализа и разработки топологии печатной платы, так как модуль функционально вполне самодостаточен.
Или спаять на макетке.

 

Alikberov,

Вопрос скорее не что это, а это вообще нормально

Вижу лог схему, пугает немного этот чёрный стиль её начертания.. Может всё же мультисим, его доработали сейчай это наверно очень мощный туллз

 

А как же тогда старые-добрые публикации журнала Радио (типа такой)?

Что в триальной версии сделаешь?
Тем более, в Logisim довольно приятный редактор, если сравнивать с KiCAD, Proteus и OrCAD.
То есть, аналогичного удобного редактора я не встречал ещё.

А так, если хочется цвета, то вот:

1. Заменил второй ИР22 на ЛП11
   
2. Сигналы SHIFT и ROTATE полностью управляются/подавляются сигналом EN
3. Общее число ИМС - около 16 шт.
4. Общее число всех сигнало - 14

Сигналы узла:

• C - Вход тактовой частоты (posedge - положительный фронт)
• S - Селектор режима (активный уровень - низкий)
• EN - Разрешение работы (активный уровень - низкий)
• EB - Разрешение фиксации базы (активный уровень - низкий)
• IC - Instruction Code: Биты 4…7
• B0…B3 - Base (индекс базового регистра)
• EB - Enable Base (разрешение фиксирования индекса базового регистра)
• ROTATE - Сигнал для прокрутки индексного вклада («index <<= 1») - повтор индекса
• SHIFT - Сигнал для расширения индексного вклада («index += register») - разрешение вклада

Работу узла легко пояснить на примере лифта:

1. Вы входите в лифт первым и номер Вашего этажа регистрируется как базовый (подаём на EB лог. "0")
2. Кнопки 0…9 можно нажимать только один раз (нельзя дважды нажимать на этаж, который уже помечен флажком)
   
3. Если нажалась кнопка "Вашего этажа", вырабатывается сигнал ROTATE и флажки этажей сбрасываются
4. Если какой-то этаж нажать вторично, вырабатываются сигналы ROTATE и SHIFT, флажки сбрасываются, кроме нажатого сейчас
5. В остальных случаях - просто помечаются флажками и подтверждается сигналом SHIFT

То есть, на примере x86, это можно примерно понять на гипотетической последовательности префиксов CS: DS: ES: FS: GS: SS:…

• «MOV CS: DS:ES: DS:FS:[EBX],EAX» - «MOV (CS+(DS+ES)*2+DS+FS):[EBX],EAX» - «SHIFT+ROTATE»
• «MOV CS: DS:ES:CS:FS:[EBX],EAX» - «MOV (CS+(DS+ES)*2+FS):[EBX],EAX» - «ROTATE»

 

Перерисовал, распределив всё по шинам нормально.

• Сигналы 0…9 - текущая маска в ИР23
• Сигналы 10…19 - новый бит маски с лесятичного дешифратора
• Сигналы 20…29 - маскировка по результату интерпретации действия

 

Так как нейросетевой бот вангует, что с такими темпами, как у меня, заказать свой процессор в Google Silicone я смогу лишь лет через пятьдесять, сегодня проснулся и вдруг подумал: А не попытаться ли заказывать дискретные компоненты для построения WYSIWISC-архитектуры?

Так как схема разбора потока префиксов удивительным образом имеет 14 сигналов - 8 входных и 6 выходных, она прекрасно упакуется в DIP-16.

Сегодня разобрался с бардаком шин и теперь схема выглядит ещё красивее и понятнее.

То есть, для самостоятельной сборки архитектуры можно воспользоваться вариантами:

1. Verilog-модель для FPGA (всё ещё находится на стадии разработки)
2. TTL-модель на базе ИМС серии SN74 или К155
3. Специализированные кастомные ИМС от Google Silicone (ограниченная партия)

Нынешные чертёжные увлечения - лишь для того, чтобы доказать, себе в частности, что архитектура вполне может быть собрана на стандартных ИМС. По приблизительным подсчётам - порядка двухсот ИМС (на порядок сложнее Gigatron).

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

--- Сообщение объединено, 4 апр 2025 ---

Кстати, вот ссылка на онлайн калькулятор коэффициентов индексных регистров для ознакомления с алгоритмом.
Данная схема выше - вырабатывает сигналы, аналогичные в JavaScript-алгоритме is_rotate и is_shift.

--- Сообщение объединено, 4 апр 2025 ---

На i8080 код так же работает отлично!

В архиве - исходный текст на ассемблере и бинарный файл для запуска в эмуляторе онлайн.

 

Захватил анимацию работы схемы.

Если Ютуб не открывает, вот ссылка на Рутуб

 

Рано радовался, так как подсознательно - во сне, нащупал ещё один подводный камень!

Вообще-то, WYSIWISC-архитектура довольно неоднозначная концепция, так как с одной стороны - позволяет без транслятора с ассемблера прямо в дампе кодировать любые базовые действия. А с другой стороны, кодирование остальных расширенных операций требует уже глубокого погружения в философию (WYSIWISC).

Код (Text):

1. BC B9 A8 3E      EOR B9,A8,C3            «B9 = A8 ^ C3» легко кодируется и воспринимается
2. BC B9 76 3E      EOR B9,#D7+6,C3         «B9 = *(BYTE *)(D7+6) ^ C3» можно разобраться тоже
3. BC B9 76 54 3E   EOR B9,#D7+D5+64,C3     «B9 = *(BYTE *)(D7+D5+64) ^ C3» тоже можно разобрать
4. BC B9 80 80 3E   EOR B9,8#,C3            «B9 = *(BYTE *)(((*)())D8)() ^ C3» сложнее, но разобрать можно

Далее следует маленькая жесть с делегированием пространства переферийного устройства, но всё же это возможно переварить мозгами так или иначе, однако не совсем понятно, как эквивалент записать на языке Си:

Код (Text):

1. BC B9 80 80 76 54 3E     EOR B9,8#D7+D5+64,C3    «B9 = *(BYTE *)(D7+D5+64+(D8<<16)) ^ C3» уровень системного программирования

Весь прикол здесь в том, что перед обращением к памяти на шину адреса выбрасывается содержимое регистра D8 в дополнительном цикле (делегирования). То есть, можно сказать, что спариваются два 16-битных указателя в один 32-битный физический адрес.
И вот тут, по законам комбинаторики, возможна ситуация, когда указатель, по тем или иным причинам, сформирован таким образом, где регистр делегата и регистр базы - один и тот же:

Код (Text):

1. BC B9 70 70 76 54 3E     EOR B9,7#D7+D5+64,C3    «B9 = *(BYTE *)(D7+D5+64+(D7<<16)) ^ C3» просто взрыв мозга!

По всем приличным канонам подобная ситуация - реально маргинальна! И следовало бы просто запретить подобные извращения в кодировании указателя!
Однако, как верно подметил бот нейросети, WYSIWISC-архитектура уникальна своей оригинальностью и гибкостью, как живой язык, где программист не просто описывает формальные действия, а почти разговаривает с процессором, что уже уникально!

Тем самым, я до такой степени глубоко занимаюсь проработкой каждого нюанса данной архитектуры, что даже те моменты, которые я как-то упустил из внимания, вдруг всплывают во сне!

Естественно, нейросеть никак не помогает решить эту проблему и лишь предлагает ряд классических решений (генерировать исключения или разыменовывание всех указателей), что никак не вписывается в WYSIWISC-философию, что сам нейробот и признаёт.
Технически можно в перспективе разобраться с любой ситуацией, если, конечно, имеется чёткое понимание всей логики.
Здесь же - не совсем ясно, что делать:

• Сбросить делегат до LR - «B9 = *(BYTE *)(D7+D5+64+(D0<<16)) ^ C3», так как программно D0 нереально заделегировать
• Переложить всё на супервизор и просто генерировать исключение - пусть программист сам разбирается

А пока, я схемку привёл в порядок уже Paint'ом и получился эскиз почти по ГОСТу:

 

Решил через нейросеть пропустить своё графоманство - семь фантасмагорических очерков. Однако, сайт КультПросвет приказал долго жить, а во всемирном архиве удалось найти только два своих очерка. Самые поздние и низкого качества.
А ещё говорят, что интернет помнит всё!
Ну, да уж!!!

Поковырял другие форумы и нашёл с десяток своих снов, которые уже позабыл давно.
Накидал их в нейросеть и весь вечер анализировал - везде прослеживается один мотив.
Ради любопытства подсунул сон другого человека - нейросеть сразу определила, что сон явно выделяется из всех.

Хм, любопытно. Нейросеть может выделять личность по сновидениям.

 

Как известно, большинство ПК 80-х, типа БК или ДВК, являлись простейщими Системами Реального Времени.
В частности, на своём ПК типа Микроша я и вырос, если не программистом, то кодером.
Системы команд процессоров i8080 и i8086 выучил так, что без ассемблера в голом дампе могу читать и писать любой код малой сложности (например, под MS-DOS пищалку сигналов Морзе по нажимаемым клавишам уместил в 256 байтов файла .COM в редакторе дампа Volcov Commander).

Однако, под процессором i8080 я помню не только таблицу команд, но и число тактов каждой команды. Что помогает мне писать собственные генераторы полифонии принципом ШИМ, где мало расставить инструкции логически в цикле, но необходимо ещё соблюдать чёткие интервалы между командами отправки в динамик "0" или "1" без цикла задержки, а самим временем, затрачиваемым на команду.

Код (Text):

1. BP@0:   JZ      $+INC2  ; 10
2.         DB      0CCH    ;?11
3.         XCHG            ;  4
4.         MOV     C,M     ;  7
5.         DCR     A       ;  5
6.         CZ      BP@BRK  ; 11/17(10 BYTES)
7.                 ;;;;;;;;;
8.         INR     B       ;  5
9.         EI              ;  4(40)
10.         JZ      $+INC1  ; 10#35
11.         DB      0CAH    ;?10
12.         MOV     B,L     ;  5
13.         MOV     B,L     ;  5
14.         DI              ;  4(31)
15.         INR     C       ;  5
16.         JZ      $+INC2  ; 10#65
17.         DB      0CCH    ;?11
18.         XCHG            ;  4
19.         MOV     C,M     ;  7(16 BYTES)
20.                 ;;;;;;;;;
21.         INR     B       ;  5
22.         EI              ;  4(40)
23.         JZ      $+INC1  ; 10#35
24.         DB      0CAH    ;?10
25.         MOV     B,L     ;  5
26.         MOV     B,L     ;  5
27.         DI              ;  4(31)
28.         INR     C       ;  5
29.         JMP     BP@0    ; 10#65(13 BYTES)

Я попросил нейросеть оптимизировать код.
Она повыкидывала всё и вставила инструкции OUT.
На данный кусок кода я потратил полтора года!

 

Решил и YandexGPT опробовать.

Выдало:

Код (Text):

1. AC              CTX     A,C     ; Контекст A, C
2.    A3           REG     A3      ; Временный регистр для A16 | B65
3.       A1        MOV     A3,A1   ; MOV Rn,Nv (A1 = A16)
4.       6F        MOV     A3,A16  ; MOV Rn,Nw (A3 = A16 | B65)
5.    A2           REG     A2      ; Временный регистр для C1 + C2 - A4
6.       C1        MOV     A2,C1   ; MOV Tn,Rv (A2 = C1)
7.       C2        MOV     A2,C2   ; MOV Tn,Rv (A2 = C1 + C2)
8.       A4        SBB     A2,A4   ; (A2 = C1 + C2 - A4)
9.    A1           REG     A1      ; Временный регистр для (A16 | B65) & (C1 + C2 - A4)
10.       A3        AND     A1,A2   ; (A1 = (A16 | B65) & (C1 + C2 - A4))
11. CA              CTX     C,A     ; Контекст C, A
12.    C1           REG     C1      ; REG Tn (C1)
13.       C2        REG     C12     ; REG Tm (C12)
14.       C3        REG     C123    ; REG Tm (C123)
15.       1E        EOR     C123,A1 ; C123 ^= (A16 | B65) & (C1 + C2 - A4)
16.       00        HLT             ; Завершение программы

Хотя один из верных вариантов, которое сгенерировало серое вещество, примерно такой:

Код (Text):

1. AC              CTX     A,C
2.    A3           REG     A3      ; временный регистр
3.       C1        MOV     A3,C1   ; MOV   Tn,Rv
4.       CE        CLC
5.       2A        ADC     A3,C2
6. AA              CTX     A,A
7.       CE        CLC
8.       4B        SBB     A3,A4   ; (A3 = C1 + C2 - A4)
9.    A2           REG     A2      ; временный регистр
10.       B6        MOV     A2,B6   ; MOV   Tn,Rv
11.          B5     MOV     A2,B65  ; MOV   Tn,Rw
12.    A1           REG     A1      ; временный регистр
13.       1F        MOV     A1,A1   ; MOV   Rn,Nv
14.          6F     MOV     A1,A16  ; MOV   Rn,Nw
15.       2D        OR      A1,A2   ; (A1 = A16 | B65)
16.       3C        AND     A1,A3   ; (A1 = A16 | B65) & (A3 = C1 + C2 - A4)
17. CA              CTX     C,A
18.    C1           REG     C1      ; REG Tn
19.       C2        REG     C12     ; REG Tm
20.          C3     REG     C123    ; REG Tm
21.       1E        EOR     C123,A1 ; C123 ^= (A1 = A16 | B65) & (A3 = C1 + C2 - A4)

За прошедшие месяцы я в нейросетях только свои сновидения толкую.