
=======================================================================================================================
=======================================================================================================================
================================================= MISSING TRANSLATION =================================================
=======================================================================================================================
=======================================================================================================================


=== campaign/and_gate/meta.txt ===

$28388869498626* Right now the elephant is dominating all the other test subjects from Earth. Adjusting for brain size, you are also doing well.



=== campaign/binary_programming/meta.txt ===

$35877580485177*
Since both you and the dolphin built a computer, the competition for who gets to represent Earth at the Galactic Federation will go on until one of you drops out. 

The next milestone is writing a program to solve the maze.



=== campaign/binary_racer/meta.txt ===

$17561499905402* This level is my favorite pastime. Converting decimal into binary under time pressure.



=== campaign/binary_search/meta.txt ===

$20948899837760*
In this level you win when you output my the secret code I am thinking of. No output will fail the level, so you could just try all numbers.

Also, I will set the input to 1 after a guess that was too high and 0 otherwise, you might be able to use this to find my code faster.



=== campaign/bit_inverter/hint_solution.txt ===

$64992550674018* It is, in fact, just an XOR gate



=== campaign/bit_inverter/meta.txt ===

$38198768813364* Bit Inverter

$53559965601096* Create a conditional value inverter. When [color=#e49f44][b]Invert[/b][/color] is [T], output the opposite of [color=#e49f44][b]Value[/b][/color]. Otherwise just output [color=#e49f44][b]Value[/b][/color] as is.

$66258723258123* We are experimenting with how backgrounds influence cognitive function in Earthlings.

$76209391067704* This level is exactly the same as the XOR gate level you solved before. Remember no matter what I tell you the goal of the level is, the real truth is in the truth table.



=== campaign/bit_inverter/ui.txt ===

$29875779381032* Value

$41975883966377* Current output

$42809920196772* Invert

$62797002040657* Desired output



=== campaign/bit_switch/hint_solution.txt ===

$16488212881433* Lower circuit

$42664577834105* Which means the lower circuit is subtly wrong, with both switches outputting [Z] when the inputs both are [F]

$47029050705615* Incorrect output

$52307576546100* Upper circuit/XOR



=== campaign/bit_switch/meta.txt ===

$25663924496537*

Alternatively to thinking of the output as being disconnected, it can be thought of as outputting neither [F] or [T], but a third state we call "Z state" [Z].

Connecting two outputs to a wire will produce the following states:

Output 0 [F][F][F][T][T][T][Z][Z][Z]
Output 1 [F][T][Z][T][F][Z][F][T][Z]
   State [F][E][F][T][E][T][F][T][Z]

Note that short circuit [E] can not meaningfully be thought of as a fourth output state, as it breaks the circuit. It is included in the table for completeness anyway.



=== campaign/byte_less_s/hint_0.txt ===

$41958293329044* Comparing 2 signed numbers is similar to comparing 2 unsigned numbers



=== campaign/byte_mux/meta.txt ===

$66984132947598*
Even though he did not pass our tests we decided to keep the dog. Unlike most Earthlings he is fluffy and can follow simple instructions. 

We might want to team you two up, since you complement each other's shortcomings well.



=== campaign/byte_nand/meta.txt ===

$66454601163361* Don't worry, if you can't build a computer you will either be released into the wild or be put in a zoo with lots of space.



=== campaign/byte_not/meta.txt ===

$60317070264440* Therefore the number of arms on a creature is clearly the main predictor of intelligence. Did you know there are sea creatures from your planet with four times as many arms as you and they are doing better in tests?

$70777086019982* Tool making and usage is key in the early evolutionary stages of developing intelligence.

$79214241606407* Our previous model of brain size being the main predictor of intelligence was naive.



=== campaign/conditional_jumps/meta.txt ===

$38613585637577*
Good news for you, the dolphin already dropped out.

He had a hard time programming with his flippers. 

We will keep the tests going though, to test how far humans can go.



=== campaign/counter/meta.txt ===

$51274378991709* Counting is so fundamental even insects do it. From counting, species can evolve to compare and do arithmetic. And before you know it, you have apes building computers.



=== campaign/decoder_3/ui.txt ===

$23707304171214* Make sure output is always [F] when the disable bit is [T]



=== campaign/dependency/meta.txt ===

$57043666310618* I am not sure it benefits the students, but teachers love it.

$60783049086609* In our education system we traditionally teach by tricking students into doing the wrong thing and then teasing them.



=== campaign/hex_racer/meta.txt ===

$11327399415058* This level is my second favorite pastime. Converting hexadecimal to binary under time pressure.



=== campaign/introduction/meta.txt ===

$26182817405385*
Congratulations, you have been abducted.

We are testing you on our spaceship.

Build a functional computer and your species may join the Galactic Federation.



=== campaign/mod_4/meta.txt ===

$71000564779980*
The length of our week is 4 days. Our weekdays are named Zero's day, One's day, Two's day and Three's day. I hear some Earthlings number their Two's day incorrectly?

It doesn't really surprise me.

$76392666043520* Anyway new year is coming up and we want you to calculate the weekday of everyone's birthday. We will give you the date and all you have to do is return the weekday within 8 cycles.



=== campaign/nand_gate/meta.txt ===

$36846418389807* All the animal species of Earth are going through the same test, to see if you have the intelligence to learn to build a computer.



=== campaign/nor_gate/meta.txt ===

$37240300421781*
Most creatures on Earth are aggressive and cannot focus.

To succeed you must learn to think logically, while not destroying things.



=== campaign/overture_1_registers/test.si ===

$85392755740261* Output should not be enabled.



=== campaign/overture_2_alu/test.si ===

$84026509534190* Output should not be enabled.



=== campaign/overture_3_immediates/test.si ===

$63497936956369* Output should not be enabled.



=== campaign/overture_4_program/test.si ===

$19443898128380* Output should not be enabled.



=== campaign/overture_5_conditionals/test.si ===

$17521915837347* Output should not be enabled.



=== campaign/overture_6_budget/default.isa ===

$45432635426071* Move a value to %a from %b.



=== campaign/overture_6_budget/label.txt ===

$15531830527231* r3

$17025449350330* r5

$47858891143005* r2

$57877356797542* DoneCount

$59383212597903* r0

$76878335565401* r4

$78214997465973* Counter

$89909032864119* r1



=== campaign/overture_6_budget/meta.txt ===

$35331465118106* Overture

$59797408403606*
The only purpose of this optional level is to let you experiment with how much you can optimize Overture. Unlike previous levels, this level does not require you to complete exactly one instruction per cycle.
  

$59818810946218* By default, this level only checks that you write the correct values to output. You may opt in to having your register state checked as well, which is very useful for debugging, but this is optional. To have your register state be checked, send the number of instructions you finished each cycle to the component labeled "DoneCount".

$84590049728141* Note that if you change the RAM type to DRAM, you can set the pipeline depth of the RAM. If you for example set the depth to 2, loads and stores will take two cycles, but the delay of the RAM will be divided by 3.



=== campaign/overture_6_budget/test.si ===

$45858569181521* Your have read {.input_index} inputs, but you were supposed to have read {.emulator_input_index}.



=== campaign/overture_6_budget/ui.txt ===

$22306447815263* Optimize Overture



=== campaign/overture_conditions/hint_1.txt ===

$71744044447857* To check all bits are [F], we split the value into bits and apply a big NOR gate

$78036114842982* Next, for value < 0, we check if a binary number is negative



=== campaign/overture_conditions/hint_2.txt ===

$16809493892244* To check if a binary number is negative, we just check if the sign bit is [T]

$70638453446538* The rest of the conditions are just combinations of value = 0 and value < 0



=== campaign/overture_conditions/hint_solution.txt ===

$19520914707885* [left]value ≥ 0 means NOT (value < 0)[/left]

$44207156733924* [left]value ≤ 0 means (value < 0) OR (value = 0)[/left]

$75072852663289* [left]value > 0 means NOT (value ≤ 0)[/left]



=== campaign/rng/meta.txt ===

$18488351703350* Do you know how we deterministic robots can be creative and produce original thoughts? The answer is random number generators.



=== campaign/score/meta.txt ===

$78375324732864*
Useful energy, known as exergy, is finite and if we consume it all, we will be at the heat death of the universe. This is why efficiency is important.

In our society, we find inefficiency ugly and efficiency beautiful.

In fact, we measure beauty in units of energy.

$85893273691863* Objective beauty



=== campaign/sort/meta.txt ===

$53593011909329* Delicious order

$79528307974753* We are updating the galactic encyclopedia of food, inserting human foods. As we don't have an alphabet, entries in the encyclopedia are ordered by deliciousness.



=== campaign/symphony_8_io_devices/meta.txt ===

$78454657849319* IO Devices



=== campaign/xnor/meta.txt ===

$85674599929809* Most Earthlings were giant reptiles last we were here. None of them were intelligent or polite enough to join the Galactic Federation.



=== model/board/prototype_list.nim ===


# com_level_delay_gate's name
$13161432526100* Level And Delay Component


# com_push_button's name
$20020953885936* Push Button


# com_probe_wire_asm's description
$27381538627533* Will disassemble input according to the ISA spec of the architecture


# com_probe_wire_asm's name
$53494192640542* Disassembling probe


# com_push_button's description
$57617462098732* Output [T] while the button is pressed


# com_level_delay_gate's description
$64425234668581* Used for creating level maps. Has an extra pin that outputs the best delay of the level.

$87754378235471* Output



=== model/isa_spec/assemble.nim ===

$48895355188042* Expect a number literal after '@'

$51466436379956* Can only pad forward, current address is at: {address}



=== model/isa_spec/isa_spec.nim ===

$18247681204565* Expected ')' after assertion

$23037984432484* Expected ':' after 'when'-condition

$42907704133778* Expected a ')' after the pattern parameter list

$43708359021513* Pattern must have a body

$45247724910259* Operand value outside of {n}-bit unsigned range

$47258389995911* Expected ',' between pattern parameters

$48639756889210* The width of the instruction cannot be 0

$56352157276583* Operand value outside of {n}-bit signed range

$61772889138477* Expected a '(' before the pattern parameter list

$90809893168338* Immediate operand must have size constraint, e.g. %a:U8(immediate).



=== model/translations.nim ===

$11567406591202* 1 byte

$14036822471924* {days} days ago

$16391754618645* {size} KB

$17901039729248* {months} months ago

$18300496139706* 1 month ago

$18683857303458* {size} bytes

$21685594109067* Just now

$42553566189409* {minutes} minutes ago


# Quadrillion
$49300594926837* Q

$70945526841433* {years} years ago

$84076931764831* 1 day ago

$86244493049244* {hours} hours ago


# Trillion
$87907122406742* T

$95018143828198* 1 year ago

$98363990684104* 1 hour ago

$98703677236827* 1 minute ago



=== presenter/board_ui/popup/dialogue/unlock.nim ===

$43462148240207* Instructions per cycle


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$66101029228279* Programming



=== presenter/board_ui/popup/ide/editor.nim ===


# IDE tab name
$11106925604855* Files



=== presenter/board_ui/popup/ide/tab_list.nim ===

$84832818424728* Files



=== presenter/board_ui/popup/instruction_overture.nim ===

$43723329256095* REG {nr}

$67413863640193* Never move [color=#DD6576][bold]REG 0[/bold][/color] to counter

$89662716409733* Always move [color=#DD6576][bold]REG 0[/bold][/color] to counter



=== presenter/level_tree_ui.nim ===

$55841332003989* DECREASE DELAY TO PASS



=== presenter/utilities.nim ===

$42649958199625* The level map was updated and your progress is out of order. Complete this <level> to fix it.

$51332486391182* The critical path is inside this <custom component>.


=======================================================================================================================
=======================================================================================================================
================================================= OUTDATED TRANSLATION ================================================
=======================================================================================================================
=======================================================================================================================


=== asset/manual/Assembly/Assembly programming/doc.txt ===

$29435797471674*
[large]Обзор[/large]
Цель языка ассемблера — дать понятные человеку мнемоники инструкциям, которые выполняет компьютер.

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

Синтаксис инструкции начинается с сокращённого слова, называемого "[color=#9966ff]мнемоникой[/color]", которое описывает инструкцию. За ним следует список [color=#66ccff]операндов[/color], например:[box][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]4[/color][/box]

Программы на ассемблере в основном представляют собой просто списки инструкций.

[large]Операнды[/large]

Существует несколько типов [color=#66ccff]операндов[/color].

[b]Регистры[/b]
В приведённом выше примере [color=#66ccff]r1[/color] заменяется на 1 в сгенерированном машинном коде.

[b]Числа[/b]
В приведённом выше примере [color=#66ccff]4[/color] вставляется непосредственно в машинный код.

[b]Метки[/b]
Для инструкций перехода обычно требуется ссылаться на смещения в сгенерированном машинном коде. Эти смещения могут быть автоматически рассчитаны с помощью меток: [box][color=#9966ff]jmp[/color] [color=#66ccff]my_label[/color]
...
[color=#66ccff]my_label:[/color][/box]
Метки всегда объявляются путём добавления имени на строке с двоеточием после него.

[large]Другие возможности[/large]

[b]Комментарии[/b]
Всё, что находится на той же строке после [highlight];[/highlight], считается комментарием и игнорируется ассемблером, например:
[box][color=#eeeeee]mov r1, 123 [/color][color=#999999]; Пересылка 123 в регистр 1[/color]
[/box]

[b]Необработанные(raw) данные[/b]
Вы можете вставлять данные напрямую между ассемблерными инструкциями, например так:
[highlight]U8 123[/highlight]
Здесь мы вставляем байт 123. [highlight]U8[/highlight] означает "беззнаковое 8-битное значение", но ассемблер также поддерживает [highlight]U16[/highlight], [highlight]U32[/highlight] и [highlight]U64[/highlight].
Вы также можете вставлять значения ASCII-символов, например так:
[highlight]"Hello"[/highlight]

[b]const[/b]
Создайте новые имена для ваших регистров или других типов операндов вот так:
[highlight]const ROTATION = r0[/highlight]
В этом примере [highlight]ROTATION[/highlight] становится альтернативным именем для r0. Создание локальных имён для ваших регистров может сделать ваш код проще для чтения.

[b]Include[/b]
Вы можете подключать другие файлы ассемблера, например, подключая "std_lib.asm" из родительского каталога:
[highlight]include ../std_lib[/highlight]

Подключение другого файла ассемблера вставит его ассемблерный код туда, где размещено подключение. Вы также можете использовать метки и имена 'set', определённые в подключённом файле, если они открыты в своём файле с помощью префикса 'pub', например так:
[highlight]pub print:[/highlight]

Чтобы получить доступ к открытому имени или метке, поставьте имя файла и точку перед именем, например так:
[highlight]jmp std_lib.print[/highlight]

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



=== asset/manual/Assembly/Language creation/Fields/doc.txt ===

$57024194971618*
Секция [highlight][fields][/highlight] определяет разные типы полей, которые можно использовать в описаниях инструкций, а также допустимые значения для этих полей. Поля отделяются пустыми строками. Каждое поле начинается с имени поля на первой строке, за которым следуют одно или несколько допустимых значений. Значения — это битовые шаблоны, и все значения внутри одного поля должны иметь одинаковую длину в битах.

[b]Значения по умолчанию[/b]
Некоторые архитектуры, например aarch64, позволяют ставить необязательный символ "#" перед непосредственными значениями. Это можно реализовать с помощью полей. Обратите внимание, что имена полей можно заключать в кавычки.

[box]pound
"#" 0
"" 0[/box]

[b]Зарезервированные имена полей[/b]
Существуют два зарезервированных имени:
* [highlight]label[/highlight] — ссылка на метки в ассемблере (например: [highlight]mylabel:[/highlight]).
* [highlight]immediate[/highlight] — ссылка на непосредственные значения (Непосредственно)



=== asset/manual/Assembly/Language creation/Patterns/doc.txt ===

$29662258275697*
Раздел [highlight][patterns][/highlight] — это место, где мы определяем макросы текстовых замен, чтобы уменьшить дублирование в определениях инструкций. Шаблоны структурированы так, чтобы максимально близко соответствовать инструкциям, с добавленной в начале сигнатурой шаблона:
* Сигнатура шаблона
* Необязательный формат ассемблера
* Необязательные виртуальные операнды
* Необязательная битовая маска вывода

[large]Сигнатура[/large]
[box][patterns]

@null

@concat(`0`, `1`, `bits`)
`0`  `1`
`bits`
[/box]
Сигнатура объявляет имя шаблона ([highlight]@null[/highlight], [highlight]@concat[/highlight]), сколько параметров принимает шаблон ([highlight]`0`[/highlight], [highlight]`1`[/highlight], [highlight]`bits`[/highlight]) и куда эти параметры вставляются, чтобы сформировать неполную инструкцию, которую потом можно использовать в настоящей инструкции.

Самое важное: в простейшем случае сигнатура шаблона требует только имени, начинающегося с [highlight]@[/highlight], и идентификатора. Список параметров (если он есть) заключается в пару круглых скобок [highlight]()[/highlight], а сами параметры — это строки в одинарных кавычках [highlight]`[/highlight], разделённые запятыми [highlight],[/highlight].

[large]Тело шаблона[/large]
Тело шаблона (после подстановки параметров) образует неполную инструкцию. Её можно использовать в определениях других инструкций или шаблонов, но нельзя напрямую в ассемблерном коде. Тело полностью необязательно. Если оно присутствует, то:
- первая строка — синтаксис инструкции ([highlight]`0`  `1`[/highlight]),
- последняя строка — битовая маска вывода ([highlight]`bits`[/highlight]),
- всё между ними — виртуальные операнды.

Описание (description) здесь избыточно и не допускается. Условные подопределения не реализованы из-за технических ограничений.

[large]Вызов шаблонов[/large]
[b]Внутри инструкции[/b]
Инструкция может использовать шаблоны, передавая им аргументы и обрабатывая их как обычные поля.

Приведённый выше шаблон полезен для определения инструкций с неупорядоченными мнемониками. Например:
[box][instructions]

%a(reg)  %op(@concat(IS,NOT,#xFF)|@concat(IS,NOT,#xFF))  %b(reg)
%op %a\[3:] %b\[3:]
\# Check if %a and %b reference the same object
[/box]по сути раскрывается в
[box][instructions]

%a(reg)  IS  NOT  %b(reg)
\#xFF %a\[3:] %b\[3:]
\# Проверить если %a и %b ссылка на один объект

%a(reg)  NOT  IS  %b(reg)
\#xFF %a\[3:] %b\[3:]
\# Проверить если %a и %b ссылка на один объект
[/box]и принимает оба варианта как корректные инструкции:
[box]r0 IS NOT r1
r0 NOT IS r1
[/box]
Аргументы шаблона **не** заключаются в одинарные кавычки [highlight]``[/highlight], но по-прежнему разделяются запятыми [highlight],[/highlight]. Чтобы включить в аргумент специальные символы, заключите его в двойные кавычки [highlight]""[/highlight].
[box]%a(reg)  %op(@concat(",","\"",#xFF))  %b(reg)
%op %a\[3:] %b\[3:]
[/box]
раскрывается в
[box]%a(reg)  ,  "  %b(reg)
\#xFF %a\[3:] %b\[3:]
[/box]

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

Хотя нарезка битов обязательна для явных ссылок на обычные операнды ([highlight]%a\[3:][/highlight], [highlight]%b\[3:][/highlight]), её можно опустить — в этом случае ширина ссылки берётся из битовой маски вывода вызванного шаблона ([highlight]%op[/highlight]).

[b]Внутри другого шаблона[/b]
Мы можем определить ещё один шаблон [highlight]`@unordered`[/highlight], чтобы сократить два вызова [highlight]`@concat`[/highlight] и сделать намерение понятнее:
[box][patterns]

@concat(`0`, `1`)
`0`  `1`

@unordered(`0`, `1`, `bits`)
%a(@concat(`0`,`1`)|@concat(`1`,`0`))
%a
`bits`

[instructions]

%a(reg)  %op(@unordered(IS,NOT,#xFF))  %b(reg)
%op %a\[3:] %b\[3:]
\# Проверить если %a и %b ссылаются на один объект

%a(reg)  %op(@unordered(LESS,NOT,#xFE))  %b(reg)
%op %a\[3:] %b\[3:]
\# Провеить если %a перед %b
[/box]

Обратите внимание: хотя синтаксис шаблонов напоминает функции в языках программирования, на самом деле это простые макросы текстовых замен без управления потоком выполнения (ветвлений, циклов, прыжков). Поэтому шаблон может вызывать только те шаблоны, которые определены **до** него. Рекурсия любого вида невозможна.

[large]Пустой шаблон[/large]
Очень полезный и часто используемый шаблон — обозначение необязательности, то есть части синтаксиса инструкции может и не быть. Хотя вы можете определить такой шаблон самостоятельно, для удобства предусмотрена встроенная конструкция.
[box][patterns]

@null

@as_is(`0`)
`0`

[instructions]

\#0%op(|@as_is(.0))
\#x00

\#0%op(@null|@as_is(.0))
\#x00

\#0%op(|@null||@as_is(.0))
\#x00
[/box]
— все три определения полностью эквивалентны и принимают как [highlight]#0[/highlight], так и [highlight]#0.0[/highlight].

[large]Зачем это нужно[/large]
Мотивация возникла из-за того, насколько повторяющимися могут быть некоторые ISA. Возьмём, например, систему префиксов x86: инструкция может иметь до 4 префиксов (LOCK/REP/BND, переопределение сегмента, переопределение размера операнда и переопределение размера адреса), и они могут идти в любом порядке. Попробуем описать это без шаблонов (только первые два префикса):
[box][instructions]

adc  al , %i(S8 immediate)
\#x14 %i\[7:]

%a(pf_0)  adc  al , %i(S8 immediate)
%a\[7:0] #x14 %i\[7:]

%b(pf_1)  adc  al , %i(S8 immediate)
%b\[7:0] #x2e #x14 %i\[7:]

%a(pf_0)  %b(pf_1)  adc  al , %i(S8 immediate)
%a\[7:0] %b\[7:0] #x14 %i\[7:]

%b(pf_0)  %a(pf_1)  adc  al , %i(S8 immediate)
%a\[7:0] %b\[7:0] #x14 %i\[7:]
[/box]
Получается, что каждую инструкцию x86 нужно писать по 5 раз только для того, чтобы сказать: «эта инструкция может принимать до 2 префиксов в любом порядке». Количество комбинаций делает такой подход непрактичным как для человека, пишущего определения, так и для компилятора, который их разбирает.

Шаблоны были введены, чтобы сделать описание инструкций короче и понятнее. Кроме того, они сообщают компилятору, что разбор инструкции с помощью шаблонов можно выполнять «лениво», что даёт прирост скорости и экономию памяти.
[box][patterns]
@as_is(`0`, `bits`)
`0`
`bits`

@concat(`0`, `1`, `bits`)
`0`  `1`
`bits`

@pf
%pf(|as_is(%a(pf_0),%a\[7:0])|as_is(%b(pf_1),%b\[7:0])|@concat(%a(pf_0),%b(pf_1),%a\[7:0] %b\[7:0])|@concat(%b(pf_1),%a(pf_0),%a\[7:0] %b\[7:0]))
%pf

[instructions]

%pf(@pf)  adc  al , %i(S8 immediate)
%pf #x14 %i\[7:]

%pf(@pf)  add  al , %i(S8 immediate)
%pf #x04 %i\[7:]
[/box]



=== asset/manual/Assembly/Language creation/doc.txt ===

$41184546203403*
[large]Обзор[/large]

Вот пример простого описания языка ассемблера:

[box][fields]
register
r0 000
r1 001
r2 010
r3 011

[instructions]
mov %a(register), %b(register)
00aaabbb
\# Переместить значение из %b в %a

mov %a(register), %b(immediate)
01000aaa bbbbbbbb
\# Переместить байт %b в %a

jmp %a(label)
10000000 aaaaaaaa
\# Перейти по адресу %a[/box]

Обратите внимание, что описание разделено на две основные секции: [highlight][fields][/highlight] и [highlight][instructions][/highlight].

[large]Секция [fields][/large]
Поля позволяют давать имена битовым шаблонам. Обычно они используются для регистров. Подробнее читайте [link="Assembly/Language creation/Fields"]здесь[/link].

[large]Секция [instructions][/large]
Каждое определение инструкции состоит из трёх строк:

[box][color=#66ff99]mov %a(register), %b(register)[/color]
[color=#66ccff]00aaabbb[/color]
[color=#9966ff]# Переместить значение из %b в %a[/color][/box]

Когда вы пишете инструкции на своём языке ассемблера, ассемблер просматривает список определений сверху вниз, находит первую подходящую [color=#66ff99]синтаксическую строку[/color] и генерирует соответствующий [color=#66ccff]машинный код[/color].

[b]Строка синтаксиса[/b]
Это смесь фиксированного текста и операндов. Каждый операнд начинается с символа `%`, за ним идёт имя, которое используется в других строках. После имени в скобках указывается тип операнда: `label`, `immediate` (Непосредственно) или пользовательское поле, которое вы определили в секции [b][fields][/b].

[b]Строка машинного кода[/b]
В этой строке используются `0` и `1`, а также первые буквы имён операндов из строки синтаксиса. Цифры `0` и `1` вставляются буквально, а буквы операндов заменяются на соответствующие биты из значения операнда.

Подробнее читайте [link="Assembly/Language creation/Instructions"]здесь[/link].

[large]Другие секции[/large]
Кроме [b][fields][/b] и [b][instructions][/b] существуют ещё две необязательные секции: [b][link="Assembly/Language creation/Settings"][settings][/link][/b] и [b][link="Assembly/Language creation/Patterns"][patterns][/link][/b].
\#cd1661566e9db0add2f62846d0821c7f



=== asset/manual/Circuits/Auto size/doc.txt ===

$65852115931553*
Функция Автоматический размер даёт вам больше гибкости при создании пользовательских компонентов. Например, эта схема — это счётчик, который работает с любым размером и имеет настраиваемый шаг увеличения:
[image="example.png"]

Обратите внимание, что некоторые метки размера имеют другой цвет фона. Это потому, что для них включено автоматическое определение размера. Вы можете включить автоматическое определение размера с помощью этой кнопки.
[image="setting.png"]

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

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



=== asset/manual/Circuits/Circular dependency/doc.txt ===

$57134685411828*
Циклическая зависимость возникает в том случае, когда вход компонента зависит от его собственного выхода.

[center][image="circular_dependency.png"][/center]

Данный симулятор не допускает циклических зависимостей и вместо этого выдаёт ошибку.

Исключение составляют оранжевые пины — они не влияют на выход в том же такте. Поэтому такие пины не могут вызывать циклическую зависимость.

[center][image="delay_line.png"][/center]



=== asset/manual/Circuits/Short circuit/doc.txt ===

$20065838867866*
В электронике, если два компонента выводят разные значения на один и тот же провод, возникает короткое замыкание.

[center][image="short_circuit.png"][/center]

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

[center][image="switch.png"][/center]

В этом симуляторе пины, которые можно отключать, имеют серый цвет.



=== asset/manual/Circuits/The foundry/doc.txt ===

$43200267887776*
Откройте Мастерскую, нажав на эту кнопку [image="../../../dialogue/manual/foundry_icon.png"] в верхней левой панели.

Мастерская позволяет вам создавать собственные пользовательские компоненты. Логика, которую вы размещаете, определяет поведение компонента, а разметка определяет его форму.

Размещённые вами компоненты ввода и вывода становятся пинами на компоненте.

Пробники, размещённые внутри пользовательских компонентов, будут отображаться на их разметке и могут показывать значения внутри. Пробники можно подключать к другим пользовательским компонентам, чтобы отображать вложенные значения. Значения, полученные через такие пробники, также можно подключать к компоненту программы.

В Мастерской менеджер файлов также управляет пользовательскими компонентами. Имена файлов определяют название компонента, а структура каталогов определяет расположение компонентов в меню.



=== asset/manual/Circuits/The screen/doc.txt ===

$76434165550872*
[large]Режимы экрана[/large]
Экран поддерживает четыре режима, которые определяют, как он отображает значения:
0: Ascii 8
1: Ascii 32
2: Pixel 8
3: Pixel 32

Кроме того, у каждого режима есть свои настройки, которые можно изменять во время работы с помощью входных пинов экрана.

[large]Режим Ascii 8[/large]
Каждый байт интерпретируется как символ на экране размером 96 на 40 символов.

[b]Команды:[/b]
0 Сменить режим
1 Задать смещение данных
2 Задать цвет переднего плана
3 Задать цвет фона
4 Установить шрифт

[large]Режим Ascii 32[/large]
Каждые четыре соседних байта интерпретируются как: символ, цвет переднего плана и цвет фона соответственно.

8-битные цвета используют 3 бита на красный, 3 бита на зелёный и 2 бита на синий, вот так:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

[b]Команды:[/b]
0 Сменить режим
1 Задать смещение данных

[large]Режим Pixel 8[/large]
Каждый байт интерпретируется как цвет пикселя (3 бита на красный, 3 бита на зелёный и 2 бита на синий):
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

Разрешения режимов пикселей имеют соотношение сторон 4:3, от 4x3 вплоть до 1024x768.
Разрешение вычисляется на основе настройки следующим образом:
4 x (настройка + 1) : 3 x (настройка + 1)


[b]Команды:[/b]
0 Сменить режим
1 Задать смещение данных
2 Задать разрешение

[large]Режим Pixel 32[/large]
Четыре байта интерпретируются как цвет пикселя (по одному байту на красный, зелёный и синий):
[b][color=#ff5555]RRRRRRRR[/color][color=#55ff55]GGGGGGGG[/color][color=#5555ff]BBBBBBBB[/color][/b]

Разрешения режимов пикселей имеют соотношение сторон 4:3, от 4x3 вплоть до 1024x768.
Разрешение вычисляется на основе настройки следующим образом:
4 x (настройка + 1) : 3 x (настройка + 1)

[b]Команды:[/b]
0 Сменить режим
1 Задать смещение данных
2 Задать разрешение



=== asset/manual/Computer concepts/ASCII encoding/doc.txt ===

$69772243733094*
Этот симулятор использует (расширенный) ASCII в нескольких местах. Ниже приведены символы с соответствующими им числами. Консоль поддерживает разные версии расширенного ASCII.

[large][b]Псевдографика (cp437)[/b][large]
[image="TC_cp437.png"]

[large][b]Текст (cp850)[/b][large]
[image="TC_cp850.png"]

[large][b]APL (cp910)[/b][large]
[image="TC_cp910.png"]

[large][b]Кириллица (cp866)[/b][large]
[image="TC_cp866.png"]



=== asset/manual/Computer concepts/Endianness/doc.txt ===

$78199387512682*
По традиции данные в памяти отображаются слева направо с увеличением адресов. Благодаря этому текст ASCII также читается слева направо, когда символы хранятся по возрастающим адресам.

[box]          Память (hex) |   ASCII
Адрес:   0  1  2  3  4 | 0 1 2 3 4
Данные: [color=#ff6680]48[/color] [color=#ffe666]65[/color] [color=#66ff99]6C[/color] [color=#66ccff]6C[/color] [color=#9966ff]6F[/color] | [color=#ff6680]H[/color] [color=#ffe666]e[/color] [color=#66ff99]l[/color] [color=#66ccff]l[/color] [color=#9966ff]o[/color]
[/box]

Кроме того, числа принято записывать так, чтобы старшие цифры находились слева. Например, число тринадцать записывается как [color=#ff6680]13[/color], а не [color=#ff6680]31[/color].

Поэтому очевидный способ хранения многобайтового числа, например 0x12345678, выглядит так:

[box]          Память (hex)
Адрес:   0  1  2  3
Данные: [color=#ff6680]12[/color] [color=#ffe666]34[/color] [color=#66ff99]56[/color] [color=#66ccff]78[/color]
[/box]

Это называется [b]Big Endian[/b] (от «big end first» — старший байт первым), потому что более значимые байты хранятся по меньшим адресам.

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

Хранение младших битов/байтов первым (Little Endian) также имеет другие практические преимущества. Например, гораздо чаще требуется только младшая часть числа (приведение типа вниз), чем старшая. При Little Endian это можно делать, не меняя указатель.

Такой естественный с вычислительной точки зрения порядок называется [b]Little Endian[/b]. К сожалению, при просмотре Little Endian всё выглядит ещё запутаннее, потому что байты внутри слова отображаются в привычном направлении. Поэтому число 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] в памяти будет выглядеть так:

[box]          Память (hex)
Адрес:   0  1  2  3
Данные: [color=#ff6680]78[/color] [color=#ffe666]56[/color] [color=#66ff99]34[/color] [color=#66ccff]12[/color]
[/box]

Если бы числа и текст изначально росли в одном направлении, то этой страницы документации вообще не понадобилось бы.

Сегодня практически все современные процессоры используют Little Endian, и он стал общепринятым стандартом. Исключение — протоколы TCP/IP, которые используют Big Endian.



=== asset/manual/Computer concepts/Truth tables/doc.txt ===

$16579770195459*
Таблицы входов и выходов, которые используются по всей игре, называются таблицами истинности.

[center][image="truth_table.png"][/center]

Вместо «Input»(Ввод) и «Output»(Вывод) часто используются переменные (как в алгебре). А вместо цветов значения обычно обозначают как 0/1 или False/True.



=== campaign/any_doubles/hint_0.txt ===

$10183449965120* Чтобы проверить, что включены хотя бы 2 входа, можно проверять их попарно



=== campaign/any_doubles/hint_1.txt ===

$83867604619162* Чтобы проверить, что оба входа в паре включены, можно применить к ним И(AND)



=== campaign/any_doubles/meta.txt ===

$43068867747292*
На этом уровне 4 входа. 
Выведите [T], когда 2 или больше из них включены.

[tip]Не усложняйте этот уровень.[/tip]



=== campaign/assembly_programming/default.isa ===

$11603603520594* Переместить значение из %b в %a.



=== campaign/assembly_programming/meta.txt ===

$73801373825270*
Цель языка ассемблера — дать человеку удобочитаемые названия для инструкций, которые выполняет машина.

Обычно синтаксис инструкции начинается с сокращённого слова (оно называется "[color=#9966ff]мнемоникой[/color]"), за которым следует список [color=#66ccff]операндов[/color], например:
[highlight][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]r2[/color][/highlight]

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

Нажмите «Edit» на компоненте RAM, чтобы открыть редактор ассемблера. Затем нажмите «ASM» в верхнем левом углу, чтобы увидеть полный список инструкций архитектуры Overture.



=== campaign/assembly_programming/new_program.asm ===

$73562005049347* Пересылает входное значение в регистр 2

$80524429403045* Нажмите «ISA» в левом верхнем углу, чтобы увидеть все инструкции



=== campaign/binary_programming/default.isa ===

$31456617450268* Переместить значение из %b в %a.



=== campaign/binary_racer/meta.txt ===

$78267067157141*
Этот уровень научит вас двоичной системе.

Переключайте биты в панели уровня так, чтобы в сумме они давали десятичное число, указанное в вопросе.

Чтобы пройти уровень, нужно победить на 3-м уровне.



=== campaign/bit_adder/hint_0.txt ===

$90884846016283* Перенос включён тогда и только тогда, когда оба входа включены



=== campaign/bit_inverter/hint_1.txt ===

$40415302067949* когда либо Вход 0 включён И Вход 1 выключен, либо Вход 0 выключен И Вход 1 включён

$61125857472821* Таблица истинности говорит, что выход включён тогда и только тогда



=== campaign/bit_switch/hint_1.txt ===

$45466715038362* И вся схема становится одним вентилем ИЛИ, но с превышением бюджета

$76027454955517* Теперь переключатель очень похож на вентиль И(AND)



=== campaign/bit_switch/hint_solution.txt ===

$62622482229413* Особенность переключателя в том, что если пин «Разрешить» [F], то, в отличие от вентиля И(AND), он не выводит [F]

$80836475394613* Он вообще ничего не выводит, что позволяет выходам переключателей соединяться на общих проводах без короткого замыкания



=== campaign/bit_switch/meta.txt ===

$88100823584262*
Если несколько компонентов выводят разные значения на один и тот же провод, возникает ошибка. Однако у некоторых компонентов выходные пины серые — они ничего не выводят, когда компонент выключен. Именно так работает битовый переключатель.

[center][image="switch.png"][/center]

Когда нижний пин [F], выход отключён. К одному проводу можно подключить несколько выходов без ошибки, если в каждый момент времени активен только один из них.



=== campaign/byte_adder/hint_2.txt ===

$57534334907443* Добавьте ещё по 7 компонентов Полный сумматор для каждого бита



=== campaign/byte_adder/meta.txt ===

$45061087867940*
Если результат не помещается в 8 битов, включите выход переноса [T] (можно считать его 9-м битом).

Кроме того, у уровня есть вход переноса. Он полезен для соединения нескольких сумматоров байтов при сложении больших чисел. Его можно рассматривать как добавление 0 ([F]) или 1 ([T]).



=== campaign/byte_asr/hint_2.txt ===

$87506885530483* Затем мы сдвигаем Вход 0 на 1, 2 или 4 в зависимости от включённых битов Входа 1



=== campaign/byte_asr/meta.txt ===

$79125097012724*
Сдвиг, который вы построили на прошлом уровне, называется [b]логическим[/b] сдвигом. Логический сдвиг вправо на 1 эквивалентен делению на 2 для беззнаковых чисел. Для знаковых чисел, если старший бит равен [T], освободившиеся биты заполняются [T], а не [F]. Это называется [b]арифметическим сдвигом вправо[/b] и в ассемблере часто обозначается как [b]asr[/b].

[color=#e49f44]-106 asr 3[/color]
 [T] [F] [F] [T] [F] [T] [T] [F]
Результат:
|[T] [T] [T]|[T] [F] [F] [T] [F]
      ^                     
Здесь вместо [F] вставляется [T].



=== campaign/byte_constant/hint_solution.txt ===

$67841603404086* Двоичное представление числа 164 — это 1010 0100



=== campaign/byte_equal/hint_solution.txt ===

$88637818475024* Далее мы проверяем, равен ли байт нулю, проверив, что все его биты равны нулю



=== campaign/byte_less_s/hint_0.txt ===

$14667194911431* Наконец, знаковый бит рассматривается отдельно для знаковых чисел, здесь он действует противоположным образом

$19896249626650* (если только у одного числа он [T], то это число гарантированно меньше)



=== campaign/byte_less_u/hint_3.txt ===

$15205448412655* Т.е. Вход_1 + (ОТРИЦ(NEG) Вход_2)



=== campaign/byte_lsr/hint_2.txt ===

$22456794338741* Затем мы сдвигаем Вход 0 на 1, 2 или 4 в зависимости от включённых битов Входа 1



=== campaign/byte_lsr/meta.txt ===

$57629598331916*
Сдвиг значения на 1 вправо означает перемещение всех битов байта на одну позицию вправо.

Эта операция называется [b]логическим сдвигом вправо[/b] и в ассемблере часто обозначается как [b]lsr[/b].

Пример: [b]180 lsr 1[/b]

[T] [F] [T] [T] [F] [T] [F] [F] → после сдвига на 1:
[F] [T] [F] [T] [T] [F] [T] [F]

[b]180 lsr 3[/b]
[T] [F] [T] [T] [F] [T] [F] [F] → после сдвига на 3:
[F] [F] [F] [T] [F] [T] [T] [F]



=== campaign/byte_mux/hint_0.txt ===

$71057700033977* Но A вместо Входа 0 и B вместо НЕ(NOT) Входа 0



=== campaign/byte_mux/ui.txt ===

$28574225028041* ВЫБРАТЬ Вход 1/2



=== campaign/byte_nand/meta.txt ===

$52274910421610*
Примените И-НЕ(NAND) к каждому биту входных байтов и выведите результат.

Пример:
\#ВХОД 1 [T][T][F][F][F][T][F][F]
\#ВХОД 2 [F][F][F][F][T][T][F][F]
\#ВЫХОД  [T][T][T][T][T][F][T][T]



=== campaign/capitalize/meta.txt ===

$36850349097673*
На входе этого уровня — предложения в кодировке ASCII (см. руководство). Каждое слово отделено пробелом (числовой код 32). Замените первую букву каждого слова на заглавную.

Возможные входные символы — строчные a–z и пробел.



=== campaign/conditional_jumps/meta.txt ===

$65712025748767*
Если использовать фиксированное число как адрес перехода, его придётся обновлять каждый раз при добавлении или удалении кода.

Вместо этого можно использовать [color=#66ccff]label[/color](метку), которая автоматически обновляется при изменении кода:

[box][color=#66ccff]my_label[/color]:     [color=#aaaaaa]; Это метка[/color]
[color=#9966ff]imm[/color] [color=#66ccff]my_label[/color]  [color=#aaaaaa]; Загрузить смещение метки[/color]
[/box]
  



=== campaign/conditional_jumps/new_program.asm ===

$78380513477546* Нажмите «ASM», чтобы увидеть другие инструкции перехода



=== campaign/count_leading_zeroes/meta.txt ===

$30557055303267*
Создайте схему, которая начиная со старшего бита считает, сколько подряд идут [F].

Для примера ответ — 3, так как здесь 3 ведущих [F]:
[F][F][F][T][F][T][F][T]



=== campaign/counter/hint_solution.txt ===

$81327009436542* Но использовать здесь полный сумматор — это избыточно!



=== campaign/counter/meta.txt ===

$42949183679479*
Постройте счётчик, который будет увеличиваться на 1 каждый такт.

Кроме того, должна быть возможность перезаписать счётчик заданным значением.

У вас есть два входа: бит и байт.

Битовый вход переключает режим между счётом и перезаписью значением байта.



=== campaign/counting_signals/hint_2.txt ===

$90442785399123* Выход 2 включён тогда и только тогда, когда включены все сигналы



=== campaign/counting_signals/hint_3.txt ===

$12139411441713* Выход 1 включён тогда и только тогда, когда включены как минимум 2, но не все 4 сигнала



=== campaign/counting_signals/meta.txt ===

$83123268362253*
Выходной компонент этого уровня — двоичный счётчик, где первые три пина соответствуют 1, 2 и 4.
С помощью двоичного счётчика отобразите количество сигналов.

[tip]Решение этого уровня не очень аккуратное и требует больше компонентов.[/tip]



=== campaign/decoder_1/ui.txt ===

$40303102766749* Выход 2



=== campaign/decoder_3/test.si ===

$18073111523064* Ожидается, что все выходы будут [F], так как бит запрета [T]



=== campaign/double_buffer/meta.txt ===

$28070798445412* Постройте схему, которая выводит то же самое, что и вход, но с задержкой в 2 такта.

$66914768639545* На этом уровне вводится компонент «Линия задержки». Он принимает вход и выдаёт его на такт позже.



=== campaign/double_number/hint_0.txt ===

$16215081868720* До этого момента мы работали только с битом — сигналом ВКЛ/ВЫКЛ



=== campaign/foundry/meta.txt ===

$24718289227251*
Добро пожаловать в мастерскую! Схемы, которые вы создаёте здесь, можно использовать как компоненты в архитектурах.
Схемотехника определяет поведение компонента, а расположение — его внешний вид.



=== campaign/full_adder/hint_1.txt ===

$54848313056941* Перенос (CARRY) включён тогда и только тогда, когда включены как минимум 2 входа



=== campaign/hex_racer/meta.txt ===

$65517909958697*
Когда битов много, двоичная система становится неудобной для чтения. Шестнадцатеричная система (основание 16) представляет каждые 4 бита одним символом:

0 [F][F][F][F]
1 [F][F][F][T]
2 [F][F][T][F]
3 [F][F][T][T]
4 [F][T][F][F]
5 [F][T][F][T]
6 [F][T][T][F]
7 [F][T][T][T]
8 [T][F][F][F]
9 [T][F][F][T]
A [T][F][T][F]
B [T][F][T][T]
C [T][T][F][F]
D [T][T][F][T]
E [T][T][T][F]
F [T][T][T][T]

Пример, где шестнадцатеричная запись гораздо нагляднее — максимальное 16-битное число:

Двоичное:   1111111111111111
Десятичное: 65535
Шестнадцатеричное: FFFF

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



=== campaign/introduction/meta.txt ===

$76679675871478* Это первый уровень игры — простое введение в схемы. Здесь у вас есть вход и выход с проводом между ними. Включите вход в меню слева, чтобы завершить уровень.



=== campaign/mod_4/meta.txt ===

$46388374967041*
На этом уровне на вход подаётся число, а вы должны вернуть его по модулю 4.

Сложность в том, что у вас есть всего 8 тактов на вывод результата.

Примечание: аппаратную часть менять не нужно — нужно просто найти быстрый способ вычисления mod 4.



=== campaign/mod_4/test.si ===

$13853243145042* Вы должны вывести результат до такта 8!

$59240995307159* Сначала запросите вход.



=== campaign/nand_gate/meta.txt ===

$50880631203389* Правильно! Вы разблокировали вентиль И-НЕ(NAND). Из этого фундаментального строительного блока вы сможете построить всё остальное в игре.

$65167079914703* Первый раздел игры посвящён булевой логике. Булева логика описывает самые простые формы вычислений, которые способен выполнять компьютер. На самом деле именно эти вычисления лежат в основе всех остальных вычислений в компьютере.



=== campaign/negative_numbers/meta.txt ===

$16731935541997*
На этом уровне вводится «дополнительный код»(two's comliment) — самый распространённый способ представления отрицательных чисел.

Здесь старший разряд меняет знак. Для байта это значит, что 8-й разряд вместо +128 имеет значение -128.

Для прохождения уровня нужно дойти до 3-го уровня или дальше.



=== campaign/nor_gate/hint_0.txt ===

$18962231551900* только тогда, когда оба Вход 0 И Вход 1 выключены

$68908249643417* Таблица истинности говорит, что вентиль ИЛИ-НЕ(NOR) включён



=== campaign/not_gate/hint_1.txt ===

$20946507323050* Когда оба входа [T] — выход [F]

$88952480145102* Когда оба входа [F] — выход [T]



=== campaign/not_gate/meta.txt ===

$64052600264884*
С помощью вентилей И-НЕ(NAND) постройте вентиль НЕ.

Используя: [b]Вентиль И-НЕ(NAND)[/b]
\#ВХОД 1: [F][T][F][T]
\#ВХОД 2: [F][F][T][T]
\#ВЫХОД:  [T][T][T][F]

Постройте: [b]Вентиль НЕ[/b]
\#ВХОД 1: [T][F]
\#ВЫХОД:  [F][T]



=== campaign/odd_number_of_signals/hint_1.txt ===

$39747324204871* Но что если вместо [F]/[T] представить их как чётное/нечётное?

$80670337048058* До этого момента красный сигнал назывался [F], а зелёный — [T]



=== campaign/odd_ticks/hint_0.txt ===

$75667038547709* Информация приходит от счётчика тактов, и здесь отлично работает линия задержки



=== campaign/odd_ticks/hint_1.txt ===

$88356074900046* и получить сигнал на основе счётчика тактов



=== campaign/odd_ticks/meta.txt ===

$54648226811178* Нечётные Такты

$60625429879527*
Оранжевые пины в игре никогда не влияют на выход в том же такте. Поэтому они никогда не вызывают циклических зависимостей.
  
  [image="delay_line.png"]

$75292456030647*
Линии задержки разрешено зависеть от собственного выхода. Это потому, что вход влияет на остальную схему только на следующем такте.
  
[image="delay_line.png"]

$85913836277587* Выведите [F] на чётных тактах и [T] на нечётных.



=== campaign/or_gate/hint_0.txt ===

$29061908449874* только тогда, когда хотя бы один из входов включён

$49190016957852* Таблица истинности говорит, что вентиль ИЛИ(OR) включён



=== campaign/overture_1_registers/default.isa ===

$58396790216558* Переместить значение из %b в %a.



=== campaign/overture_1_registers/meta.txt ===

$13757092116124*
[color=#c54d5e]Source[/color](источник) и [color=#e49f44]destination[/color](назначение) могут быть одним из 6 регистров, мы назовём их REG 0 — REG 5 соответственно.

Кроме того, на этом уровне есть специальный компонент ввода(input), который может быть [color=#c54d5e]source[/color](источником), и компонент вывода(output), который может быть [color=#e49f44]destination[/color](назначением).

$61875924861326*
На этом уровне нужно создать схему, которая может перемещать значение в [color=#e49f44]destination[/color](приёмник) из [color=#c54d5e]source[/color](источника).

Байт инструкции определяет [color=#e49f44]destination[/color](приёмник) и [color=#c54d5e]source[/color](источник).

Биты 1, 2 и 3 задают [color=#c54d5e]source[/color](источник). Биты 4, 5 и 6 задают  [color=#e49f44]destination[/color](приёмник).

$87179643828952*
Вот битовые шаблоны для каждого [color=#c54d5e]source[/color](источника) и [color=#e49f44]destination[/color](приёмника).

[color=#c54d5e]Источник[/color]:
[F] [F] [F]  REG 0 
[F] [F] [T]  REG 1 
[F] [T] [F]  REG 2 
[F] [T] [T]  REG 3 
[T] [F] [F]  REG 4 
[T] [F] [T]  REG 5 
[T] [T] [F]  #INPUT 
[T] [T] [T]  UNUSED

[color=#e49f44]Приёмник[/color]:
[F] [F] [F]  REG 0 
[F] [F] [T]  REG 1 
[F] [T] [F]  REG 2 
[F] [T] [T]  REG 3 
[T] [F] [F]  REG 4 
[T] [F] [T]  REG 5 
[T] [T] [F]  #OUTPUT
[T] [T] [T]  UNUSED



=== campaign/overture_2_alu/default.isa ===

$57911760722636* Переместить значение из %b в %a.



=== campaign/overture_2_alu/meta.txt ===

$17602708328746*
Пора объединить схему "Арифметико-логического устройства", которую вы сделали ранее, со схемой регистров. Схема АЛУ была сохранена в мастерской и теперь её можно добавить как компонент. Если вы забыли, какой пин что делает, проверьте схему в мастерской.

Используйте декодер, который вы построили, чтобы определить, следует ли пересылать данные между регистрами или выполнять вычисления в АЛУ. Вот четыре разных режима снова:
[left]            [F][F] Непосредственно
[F][T] АЛУ
[T][F] Пересылка
[T][T] Условие[/left]

На этом уровне вам нужно беспокоиться только о режимах пересылки и АЛУ. В режиме АЛУ берите [color=#e49f44]REG 1[/color] и [color=#e49f44]REG 2[/color] как входы(input), а результат сохраняйте в [color=#e49f44]REG 3[/color].

[tip]Не забудьте, что компонент 3-битного декодера имеет бит отключения.[/tip]



=== campaign/overture_3_immediates/default.isa ===

$50864238070873* Переместить значение из %b в %a.



=== campaign/overture_3_immediates/meta.txt ===

$63109056149876*
Нам нужен способ напрямую переносить числа из программы в регистры. Для этого используется режим непосредственных значений (когда два старших бита — [F][F]).

В режиме непосредственных значений весь байт интерпретируется как число, которое мы сохраняем в РЕГ 0. Это значит, что мы можем сохранить любое значение от 0 до 63.



=== campaign/overture_4_program/default.isa ===

$26930827349244* Переместить значение из %b в %a.



=== campaign/overture_4_program/meta.txt ===

$58149108600515* Компонент ввода инструкции был удалён. Его заменил компонент ОЗУ, содержащий программу. К ОЗУ подключён «порт загрузки». Когда пин разрешения на порте загрузки включён, он выводит значение из ОЗУ по заданному адресу. Каждый такт используйте счётчик, чтобы загрузить следующую инструкцию из памяти программы.



=== campaign/overture_5_conditionals/meta.txt ===

$27747401844990* Вы сделали это! Вы действительно построили настоящий компьютер! Потрясающе.

$89085328104477*
Последнее, что нам нужно добавить, — это механизм изменения счётчика команд с помощью инструкций при выполнении определённых условий.

Когда два старших бита равны [T][T], мы находимся в режиме условий. В режиме условий значение в РЕГ 3 сравнивается с условиями, заданными тремя младшими битами инструкции. Если условие выполнено, мы перезаписываем счётчик значением из РЕГ 0.
Условное изменение счётчика позволяет пропускать инструкции или организовывать циклы.

Условия:
[F] [F] [F] Никогда
[F] [F] [T] Всегда
[F] [T] [F] Если [color=#e49f44]РЕГ 3[/color] = 0
[F] [T] [T] Если [color=#e49f44]РЕГ 3[/color] ≠ 0 
[T] [F] [F] Если [color=#e49f44]РЕГ 3[/color] < 0
[T] [F] [T] Если [color=#e49f44]РЕГ 3[/color] ≥ 0
[T] [T] [F] Если [color=#e49f44]РЕГ 3[/color] ≤ 0 
[T] [T] [T] Если [color=#e49f44]РЕГ 3[/color] > 0

Эти условия соответствуют компоненту условий, который вы сохранили в Мастерской (компанент cont).



=== campaign/overture_6_budget/default.isa ===

$42577908074742* Загрузка константы %a в r0.

$71072332861445* Ничего не делает.



=== campaign/overture_conditions/hint_0.txt ===

$73479968135998* Часть «Равно 0» — это фактически проверка, что все биты равны нулю



=== campaign/overture_conditions/meta.txt ===

$71466914240996*
На этом уровне есть вход значения и 3 входа битов условия.

Три бита выбирают условие, как показано ниже. Сравните значение с выбранным условием и
выведите [T], если оно выполнено, и [F] в противном случае.

Код битов:   Включить [T], когда:
[left]       [F][F][F]   Никогда[/left][left]       [F][F][T]   Всегда[/left][left]       [F][T][F]   Если значение = 0[/left][left]       [F][T][T]   Если значение ≠ 0[/left][left]       [T][F][F]   Если значение < 0[/left][left]       [T][F][T]   Если значение ≥ 0[/left][left]       [T][T][F]   Если значение ≤ 0[/left][left]       [T][T][T]   Если значение > 0[/left]



=== campaign/overture_decoder/meta.txt ===

$44644153822563* Схема, которую вы построили в уровне «Регистры», может копировать значения между регистрами, а «Арифметический движок» может выполнять разные операции над двумя входами. Но вам нужно уметь делать и то, и другое в одной схеме. Для этого постройте «декодер», который определит, в каком режиме находится наш компьютер, по двум битам, которые мы ещё не использовали.

$62355105651643*
Чтобы различать инструкции четырёх разных видов, два старших бита будут определять РЕЖИМ следующим образом:

[left]            [F][F][Z][Z][Z][Z][Z][Z] Непосредственно[/left]
[left]            [F][T][Z][Z][Z][Z][Z][Z] АЛУ[/left]
[left]            [T][F][Z][Z][Z][Z][Z][Z] Перемещение[/left]
[left]            [T][T][Z][Z][Z][Z][Z][Z] Условие[/left]

Где [Z] означает любое значение.

Определите РЕЖИМ по входу, затем отправьте [T] на правильный выход.



=== campaign/ram_component/hint_2.txt ===

$51243843817679* С помощью [T]-выхода декодера мы можем разрешить соответствующую ячейку для загрузки

$78963222298606* И не забудьте ещё один переключатель, чтобы выводить только когда LOAD включён



=== campaign/rng/meta.txt ===

$90664310835282*
На этом уровне у вас только один вход — мы называем его начальным зерном. Зерно проходит следующие шаги и превращается в псевдослучайное число.

[b]32-битный xorshift ГСЧ:[/b]
[box]temp1  = seed  xor (seed  lsr 13)
temp2  = temp1 xor (temp1 lsl 17)
result = temp2 xor (temp2 lsr 5)[/box]

В конце выведите «result» и используйте его как зерно для следующей итерации.



=== campaign/saving_bytes/meta.txt ===

$87293777622656*
Создайте схему, которая может [color=#ffcc44][b]STORE[/b][/color](записывать) байт.

Когда вход «SAVE» [T], [color=#ffcc44][b]STORE[/b][/color](записать) входной байт.

Всё время выводите сохранённое значение на выход.



=== campaign/saving_gracefully/hint_1.txt ===

$16548183735739* Она, однако, хранит значение только 1 такт, поэтому замыкаем её на себя, чтобы она постоянно обновлялась



=== campaign/saving_gracefully/hint_2.txt ===

$11101940160071* Когда пин Action(Действие) включён (или Save), мы хотим перезаписать значение



=== campaign/saving_gracefully/meta.txt ===

$13114757255411*
На этом уровне у вас 2 входа.
Когда первый вход [T], обновите сохранённое значение.
Второй вход — это значение.
Всегда выводите текущее сохранённое значение.


$61501859914469* Линия задержки позволяет хранить значение только 1 такт. Но иногда полезен компонент, который может хранить значение дольше.



=== campaign/score/hint_1.txt ===

$75346310834154* Сигнал [T] постоянный, поэтому схему там можно упростить



=== campaign/second_tick/hint_0.txt ===

$81345258398584* Таблица истинности говорит, что выход включён

$87387306821265* только тогда, когда Вход 0 включён, А Вход 1 выключен



=== campaign/second_tick/meta.txt ===

$11961528105462* Выдайте [T] только на втором такте.

$69913560783046* Второй Такт



=== campaign/symphony/test.si ===

$17745932940157* Вы должны были прочитать адрес {expected_value} из Основной памяти, а не {actual_counter}. Вы, вероятно, неправильно обновили счётчик на прошлом такте.



=== campaign/symphony_10_stack/meta.txt ===

$68315222097089*
Задача этого уровня — реализовать распространённую структуру данных под названием «стек». Вы можете делать с ним две вещи:

[color=#66ccff]PUSH[/color] — добавляет число в стек
[color=#66ccff]POP[/color]  — убирает последнее добавленное число из стека

Стек можно представить как стопку тарелок в ресторане в час пик. Мойщик посуды [color=#66ccff]кладёт[/color] тарелки сверху, а повар [color=#66ccff]берёт[/color] их сверху.

Прочитайте вход на этом уровне, чтобы узнать следующую операцию.
Ненулевой вход — это PUSH, в этом случае сохраните значение, чтобы потом его можно было извлечь.
Значение 0 — это POP, уберите и выведите последнее сохранённое число.

$90806029597852*
Поскольку стек очень полезен для программирования, в следующий уровень Symphony будут добавлены инструкции «push» и «pop». Обе они — синонимы других инструкций и используют регистр «sp» (сокращение от stack pointer), чтобы отслеживать стек.

«push» — синоним:
sub sp, sp, 4
store_32 [sp], %value

«pop» — синоним:
load_32 %destination, [sp]
add sp, sp, 4

Обратите внимание, что «push» вычитает из «sp», поэтому стек растёт вниз от старших адресов. Младшие адреса остаются свободными для ваших нужд.



=== campaign/symphony_11_functions/meta.txt ===

$64240772623662*
На этом уровне в список инструкций добавлены «call» и «ret». Обе они — сложные синонимы.

«call» используется для входа в функцию. Он помещает адрес следующей инструкции в стек (читая счётчик и прибавляя смещение). Затем выполняет прыжок в начало функции.

«ret» используется для возврата из функции. Он извлекает адрес возврата из стека и выполняет прыжок по нему.



=== campaign/symphony_12_budget/ui.txt ===

$17052191264122* Добавьте инструкции Ввода/Вывода в Symphony



=== campaign/symphony_1_nand/meta.txt ===

$83483553172261*
Разобравшись со всем этим, реализуйте инструкцию NAND.

Вот как кодируются инструкции:

[color=#ff9800]M[/color] = Режим(Mode)
[color=#ff6680]O[/color] = Опкод(Opcode)
[color=#ffe666]D[/color] = Регистр назначения(Destination)
[color=#66ff99]A[/color] = Аргумент A
[color=#66ccff]B[/color] = Аргумент B
[color=#bbbbbb]0[/color] = Не используется / ноль

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#bbbbbb]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

Используйте декодер, чтобы разделить регистры назначения и аргументов. Внимание: порты загрузки и сохранения принимают адрес в байтах, но каждый регистр занимает 4 байта. Поэтому нужно указывать адрес регистра, а не его индекс.
Также на этом уровне [color=#ff9800]Mode[/color] всегда равен 1, а [color=#ff6680]Opcode[/color] всегда равен 0. Это значит, что мы выполняем И-НЕ(NAND) первого аргумента со вторым и сохраняем результат в регистр назначения. Пока можно просто использовать 32-битный вентиль И-НЕ(NAND) вместо АЛУ.

[center][image="symphony_diagram_1.png"][/center]

$88649654188267*
Вот имена 16 регистров архитектуры [color=#e49f44]Symphony[/color]:

0 zr
1 r1
2 r2
3 r3
4 r4
5 r5
6 r6
7 r7
8 r8
9 r9
10 r10
11 r11
12 r12
13 r13
14 sp
15 flags

Регистр «zr» всегда выдаёт 0 при чтении, поэтому любая запись в «zr» будет отброшена — это упрощает аппаратуру. «sp» и «flags» — обычные регистры, просто у них особые имена. Позже они будут зарезервированы для специальных целей.

Вместо отдельных регистров используйте предоставленный компонент ОЗУ с названием «Register File».



=== campaign/symphony_1_nand/test.si ===

$34545926188340* Вы должны были прочитать адрес {expected_value} из Основной памяти, а не {actual_counter}. Вы, вероятно, неправильно обновили счётчик на прошлом такте.



=== campaign/symphony_2_io/meta.txt ===

$66929200224494*
На этом уровне мы добавляем возможность вводить и выводить значения в [color=#e49f44]Symphony[/color].

Кодирование инструкций снова такое же:

[color=#ff9800]M[/color] = Режим(Mode)
[color=#ff6680]O[/color] = Опкод(Opcode)
[color=#ffe666]D[/color] = Регистр назначения(Destination)
[color=#66ff99]A[/color] = Аргумент A
[color=#66ccff]B[/color] = Аргумент B
[color=#bbbbbb]0[/color] = Не используется / ноль

Как и в [color=#e49f44]Overture[/color], существует 4 режима:

0 Ввод-вывод
1 АЛУ
2 ПЕРЕХОД
3 ОЗУ

Однако на этом уровне вам нужно реализовать только режимы Ввод-вывод и АЛУ. В режиме АЛУ выполняйте инструкцию И-НЕ(NAND), как в предыдущем уровне. В режиме Ввод-вывод выполняйте одну из следующих инструкций в зависимости от опкода:

0 nop (ничего не делать)
1 in  (отправить вход в [color=#ffe666]destination[/color](регистр назначения))
2 out (отправить [color=#66ccff]аргумент B[/color] на выход)



=== campaign/symphony_3_alu/meta.txt ===

$13069282666558*
Добавьте АЛУ, который вы построили на предыдущем уровне, в схему. Операция каждой инструкции кодируется в [color=#ff6680]Opcode[/color].

[color=#ff9800]M[/color] = Режим(Mode)
[color=#ff6680]O[/color] = Опкод(Opcode)
[color=#ffe666]D[/color] = Регистр назначения(Destination)
[color=#66ff99]A[/color] = Аргумент A
[color=#66ccff]B[/color] = Аргумент B
[color=#bbbbbb]0[/color] = Не используется / ноль

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#bbbbbb]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]



=== campaign/symphony_4_immediates/meta.txt ===

$85471608475185*
Иногда полезно загрузить значение напрямую из программы, а не из регистров. Значение, закодированное прямо в инструкции, называется immediate (непосредственным значением). В [color=#e49f44]Symphony[/color] мы можем заменить аргумент B на непосредственное значение в любой инструкции. Для этого нужно установить четвёртый бит в 1 и закодировать значение в последних двух байтах следующим образом:

 [color=#ff9800]M[/color]  = Режим(Mode)
 [color=#ff6680]O[/color]  = Опкод(Opcode)
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Режим непосредственного значения(Immediate)
 [color=#ffe666]D[/color]  = Регистр назначения(Destination)
 [color=#66ff99]A[/color]  = Аргумент A
 [color=#66ccff]B[/color]  = Аргумент B (возможно, непосредственное значение)
 [color=#bbbbbb]0[/color]  = Не используется / ноль

Кодирование инструкции, если аргумент B не является непосредственным значением:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]
Кодирование инструкции, если аргумент B — непосредственное значение:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]



=== campaign/symphony_5_jumps/hint_solution.txt ===

$30888506574129* Белые провода реализуют режим ПЕРЕХОДА



=== campaign/symphony_5_jumps/meta.txt ===

$57225943470132*
Вот [color=#ff9800]Режимы[/color] архитектуры [color=#e49f44]Symphony[/color]:

0 Ввод-вывод
1 АЛУ
2 ПЕРЕХОД
3 ОЗУ

На этом уровне мы реализуем режим ПЕРЕХОД. Кодирование инструкции, как всегда:

 [color=#ff9800]M[/color]  = Режим(Mode)
 [color=#ff6680]O[/color]  = Опкод(Opcode)
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Режим непосредственного значения(Immediate)
 [color=#ffe666]D[/color]  = Регистр назначения(Destination)
 [color=#66ff99]A[/color]  = Аргумент A
 [color=#66ccff]B[/color]  = Аргумент B (возможно, непосредственное значение)
 [color=#bbbbbb]0[/color]  = Не используется / ноль

Кодирование инструкции, если аргумент B не является непосредственным значением:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]
Кодирование инструкции, если аргумент B — непосредственное значение:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]

В режиме ПЕРЕХОД значение в регистре, указанном [color=#66ff99]аргументом A[/color], — это флаги, которые нужно сравнить с условием, заданным [color=#ff6680]опкодом[/color]. Для сравнения используйте ранее созданный пользовательский компонент «cond».

Если флаги соответствуют условию, перезапишите значение счётчика [color=#66ccff]аргументом B[/color].



=== campaign/symphony_6_ram/meta.txt ===

$65386575947998*
На этом уровне мы реализуем режим ОЗУ. Пока в этом режиме шесть [color=#ff6680]опкодов[/color]:
[color=#ff6680]0[/color] load_8
[color=#ff6680]1[/color] load_16
[color=#ff6680]2[/color] load_32
[color=#ff6680]3[/color] [color=#bbbbbb]зарезервировано[/color]
[color=#ff6680]4[/color] store_8
[color=#ff6680]5[/color] store_16
[color=#ff6680]6[/color] store_32

Инструкции «load» должны загружать значение из памяти программы по адресу [color=#66ccff]аргумент B[/color] и сохранять результат в [color=#ffe666]регистр назначения[/color].

Инструкции «store» должны сохранять значение из регистра [color=#66ccff]аргумент A[/color] в память программы по адресу [color=#66ccff]аргумент B[/color].

Числовой суффикс определяет ширину в битах: сколько бит нужно прочитать или записать в память. Например, «load_8» загружает 8 бит данных, а «store_16» записывает 16 бит данных, начиная с указанного адреса.

$73426457129430*
Ещё раз напомним [color=#ff9800]Режимы[/color] архитектуры [color=#e49f44]Symphony[/color]:

[color=#ff9800]0[/color] Ввод-вывод
[color=#ff9800]1[/color] АЛУ
[color=#ff9800]2[/color] ПЕРЕХОД
[color=#ff9800]3[/color] ОЗУ

И кодирование выглядит так:
 [color=#ff9800]M[/color]  = Режим(Mode)
 [color=#ff6680]O[/color]  = Опкод(Opcode)
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Режим непосредственного значения(Immediate)
 [color=#ffe666]D[/color]  = Регистр назначения(Destination)
 [color=#66ff99]A[/color]  = Аргумент A
 [color=#66ccff]B[/color]  = Аргумент B (возможно, непосредственное значение)
 [color=#bbbbbb]0[/color]  = Не используется / ноль

Кодирование инструкции, если аргумент B не является непосредственным значением:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]
Кодирование инструкции, если аргумент B — непосредственное значение:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]



=== campaign/symphony_7_ssd/meta.txt ===

$23620554597332*
На этом уровне мы добавили ещё один компонент ОЗУ — для хранения данных между перезапусками.

Затем добавили две новые инструкции памяти: «pload» и «pstore». Они должны работать как 32-битные варианты load и store из предыдущего уровня, но обращаться к компоненту ОЗУ «Постоянная Память», а не к памяти программы.

Вот все [color=#ff6680]опкоды[/color] в режиме памяти:
[color=#ff6680]0[/color] load_8
[color=#ff6680]1[/color] load_16
[color=#ff6680]2[/color] load_32
[color=#ff6680]3[/color] pload
[color=#ff6680]4[/color] store_8
[color=#ff6680]5[/color] store_16
[color=#ff6680]6[/color] store_32
[color=#ff6680]7[/color] pstore



=== campaign/symphony_8_io_devices/default.isa ===

$53941960758392* Пересылка значения из %b в %a.



=== campaign/symphony_8_io_devices/meta.txt ===

$29247683714165*
До сих пор в режиме Ввод-вывод было только 3 инструкции, но теперь пришло время добавить ещё несколько. Вот полный список опкодов инструкций Ввод-вывод:

0  nop       Ничего не делать
1  in        Ввод
2  out       Вывод
3  keyboard  Прочитать значение клавиатуры
4  screen    Установить параметры экрана
5  time_0    Прочитать младшие 32 бита времени
6  time_1    Прочитать старшие 32 бита времени
7  counter   Прочитать значение счётчика


Экран может интерпретировать байты в подключённом к нему ОЗУ множеством способов (см. руководство). У экрана есть входы «Разрешить», «Установка индекса» и «Значение» — именно так происходит взаимодействие с внутренними регистрами экрана (также описано в руководстве).
При выполнении инструкции screen регистр экрана, указанный аргументом A, должен получить значение аргумента B (которое может быть непосредственным значением или браться из регистра).

Компонент Time выводит время в наносекундах с 1 января 1970 года (эпоха Unix) как 64-битное число. Поскольку архитектура работает только с 32 битами, значение делится на две части, которые можно прочитать отдельно. Однако объединение значений времени с разных тактов может дать неверные значения из-за переполнения. Чтобы избежать этого, таймер обновляется только при выполнении «time_0» сохраняя значение «time_1» во временном буфере. 

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

Значение клавиатуры — это комбинация выходов «Клавиша Нажата» и «Код Клавиши» следующим образом:

D = Клавиша Нажата
V = Код Клавиши

0000000D VVVVVVVV



=== campaign/symphony_8_io_devices/new_program.asm ===

$23344524651761* обновить next_tick



=== campaign/symphony_8_io_devices/test.si ===

$41024505081324* Вы должны были прочитать адрес {counter_value} из Основной памяти, а не {actual_counter}. Вы, вероятно, неправильно обновили счётчик на прошлом такте.



=== campaign/symphony_9_aliases/meta.txt ===

$41535895646297*
Как и в предыдущих уровнях, здесь вводятся новые инструкции. Однако на этом уровне не нужно добавлять дополнительное железо — вместо этого измените спецификацию ассемблера, чтобы уже существующие аппаратные блоки могли выполнять новые инструкции.

Нажмите кнопку «ISA» в левом верхнем углу окна Ассемблера и изучите, как реализованы инструкции. Затем добавьте следующие три новые инструкции:

[box]mov %a(register), %b(immediate)
Копирует непосредственное значение %b в регистр %a.

neg %a(register), %b(register)
Отрицает регистр %b и сохраняет результат в %a.

not %a(register), %b(register)
Побитово инвертирует каждый бит регистра %b и сохраняет результат в %a.[/box]

После добавления этих инструкций ассемблерный код станет корректным, и его выполнение пройдёт уровень.



=== campaign/symphony_condition_test/meta.txt ===

$20911185106374*
На этом уровне первый вход содержит флаги, а второй аргумент — условие. Нужно проверить, соответствуют ли флаги условию. Сравните три бита флагов попарно с первыми тремя битами условия. Если хотя бы одна из трёх пар одновременно истинна, условие выполнено.

Наконец, 4-й бит условия инвертирует результат. То есть если условие выполнено, но 4-й бит [T], выведите [F].



=== campaign/symphony_counter_1/meta.txt ===

$77897142643435*
Постройте 32-битный счётчик, который по умолчанию увеличивает значение на 4, но может быть перезаписан конкретным значением.

Также подключите предоставленный пробник памяти к 32-битному компоненту, хранящему значение счётчика.



=== campaign/symphony_counter_1/test.si ===

$70376380014778* Выход никогда не должен быть в состоянии Z



=== campaign/symphony_counter_1/ui.txt ===

$81792554779622* Постройте 32-битный счётчик, который увеличивается на 4 каждый такт



=== campaign/symphony_decoder/meta.txt ===

$71911284169222*

Постройте схему, которая разделяет инструкции Symphony на их отдельные части. Это очень пригодится позже.

Существует два способа кодирования инструкций Symphony — в зависимости от того, используем ли мы непосредственные значения:

[color=#ff9800]M[/color] = Режим(Mode)
[color=#ff6680]O[/color] = Опкод(Opcode)
[color=#9966ff]I[/color] = Бит непосредственного значения(Immediate)
[color=#ffe666]D[/color] = Регистр назначения(Destination)
[color=#66ff99]A[/color] = Аргумент A
[color=#66ccff]B[/color] = Аргумент B (возможно, непосредственное значение)
[color=#bbbbbb]0[/color] = Не используется / ноль

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]
  



=== campaign/the_bus/meta.txt ===

$25369396405852*
На этом уровне 2 байтовых входа и 2 байтовых выхода. Ваша цель — переместить число с одного входа на один выход.

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

На каждом такте только один выход должен получать значение, второй выход должен получать Z (никакого значения). Это будет отображаться как «-» на выходе.



=== campaign/tower/meta.txt ===

$62636370223849*
Потрясающе, вы прошли игру! Посмотрите, как далеко вы продвинулись от простого вентиля И-НЕ(NAND).

Отсюда вы можете соревноваться за высокие результаты с другими игроками или строить всё, что захотите, в Песочнице. И не забудьте подписаться на нас в Steam — мы продолжаем работать над новыми уровнями.

$72724057674158*
Первые 4 входа дают вам следующую информацию по порядку:
disk_nr — номер самого большого диска в стопке (от 2 до 4)
source — номер колышка, откуда перемещать
destination — куда перемещать стопку
spare — третий колышек, который не является ни source, ни destination

Управляйте магнитом с помощью следующих выходов:
0 — Переместить магнит на позицию 0
1 — Переместить магнит на позицию 1
2 — Переместить магнит на позицию 2
5 — Включить/выключить магнит

Поиграйте с магнитом вручную: стрелки перемещают его, Enter включает/выключает.

$81427576809439*
Этот уровень сложный, но отличная возможность использовать функции. На самом деле приведённое ниже решение уровня содержит «рекурсивную функцию», то есть функцию, которая вызывает сама себя:

[b]Алгоритм Ханойской башни:[/b]
[box]func move(disk_nr, source, dest, spare) {
    if disk_nr is 0 {
        move disk from source to dest
    } else {
        move(disk_nr - 1, source, spare, dest)
        move disk from source to dest
        move(disk_nr - 1, spare, dest, source)
    }
}[/box]

[tip]Не забудьте помещать значения регистров в стек, если функция их изменяет.[/tip]



=== campaign/xor_gate/hint_0.txt ===

$62308032073140* когда либо Вход 0 включён И Вход 1 выключен, либо Вход 0 выключен И Вход 1 включён

$84782011304318* Таблица истинности говорит, что выход включён тогда и только тогда



=== campaign/xor_gate/meta.txt ===

$30005674935190*
Это также известно как вентиль ИСКЛ-ИЛИ(XOR). Уровень довольно сложный, поэтому не расстраивайтесь, если сразу не получится.

[tip]Вы можете подключить один выход к нескольким вентилям.[/tip]

$50002893048555* На прошлом уровне вы построили схему, которая выдаёт [T] только на втором такте. На этом уровне нужно построить схему, которая выдаёт [T] на втором ИЛИ третьем такте.



=== model/board/prototype_list.nim ===


# com_concatenator_8's description
$12443053648819* Объединяет восемь проводов в один


# com_counter's description
$12736827510023* Увеличивает значение на 1 каждый такт, если не перезаписано


# com_concatenator_4's description
$15492861320167* Объединяет четыре провода в один


# com_maker_word_8's description
$15845204308823* Объединяет восемь значений в одно


# com_concatenator_4's name
$15908922745328* Конкатенатор


# com_splitter_bit_4's description
$16428357982878* Разбивает значение на четыре части


# com_and_3_bit's description
$16839706221116* 3-пиновый И-вентиль


# com_concatenator_8's name
$16974631589430* Конкатенатор


# com_store_port's description
$17240636780043* Добавить дополнительный пин хранения к компоненту памяти


# com_concatenator_2's name
$17495243848605* Конкатенатор


# com_or_3_bit's description
$17576327690867* 3-х контактный OR элемент


# com_splitter_bit_4's output pin
$17862413256378* Слово 1


# com_maker_bit_4's input pin
$17897455882076* Слово 1


# com_delay_line_bit's description
$18206009264853* Сохраняет вход на 1 такт


# com_delay_line_word_config's description
$18447417990806* Сохраняет вход на 1 такт


# com_splitter_bit_2's description
$18566798809283* Разбивает значение на две части


# com_maker_bit_4's description
$18837875001662* Объединяет четыре значения в одно


# com_decoder_3's output pin
$19041825668970* Бит 8


# com_decoder_2's output pin
$19275565166747* Бит 4


# com_xnor_word's input pin
$19329533997829* Вход 2


# com_maker_word_8's input pin
$19740232065347* Слово 8


# com_delay_line_word's description
$53901484249817* Сохраняет вход на 1 такт



=== model/isa_spec/assemble.nim ===

$58979769991732* Ожидается новая строка после 'include'

$87525828760679* Не удалось разрешить паттерн({err}): {resolved_pattern}



=== model/isa_spec/isa_spec.nim ===

$42160516340132* Ожидалась скобка после имени операнда, например: {variable_name}(Непосредственно)

$59877879891546* Не удалось интерпретировать выражение условия 'if': {err}

$61352853872444* Разрешены только непосредственные значения шириной от 1 до {max_field_size}

$68066163358870* Ожидался пробел после 'if'

$68462760531745* Битовая схема {field_name} имеет длину только {actual} бит, ожидалось {expected}

$73627734748417* Ожидалось @ перед именем паттерна



=== model/isa_spec/parse.nim ===

$64743950507593* Ожидалось значение списка



=== presenter/board_ui/bottom_panel/common.nim ===

$81974422302188* Читать



=== presenter/board_ui/bottom_panel/component_description.nim ===

$39851490511821* Режим координат

$65365515206856* Примечание: хотя клавиатура отображает значение нажатой клавиши, реальный вывод происходит только по обычному тику!



=== presenter/board_ui/bottom_panel/introduction.nim ===

$80966247197959* Ваша цель — довести сигнал до выходного компонента справа.



=== presenter/board_ui/function_icons.nim ===

$36396661222670* Щёлкните правой кнопкой мыши, чтобы увеличить скорость тиков

$80746616574054* Следующий ({key}) (правая кнопка: перейти на такт)



=== presenter/board_ui/popup/cycle_editor.nim ===

$19062117579269* Запустить до такта: 



=== presenter/board_ui/popup/cycle_speed_editor.nim ===

$16026817441460* тактов/сек



=== presenter/board_ui/popup/dialogue/unlock.nim ===

$30368115829346* Худший такт

$72987046679863* Время (задержка × такт)



=== presenter/board_ui/popup/instruction_overture.nim ===


# The text above the 3 LSBs
$38497477227061* Когда [color=#e49f44]результат {condition}[/color]


# The text below the byte
$59958585065722* {condition} переместить [color=#DD6576][bold]REG 0[/bold][/color] в счётчик



=== presenter/level_tree_ui.nim ===

$26276191141664* Управление:



=== presenter/main_menu_ui/options/control_tab.nim ===

$13231048881956* Сбросить такт

$86574817679356* Следующий такт



=== presenter/main_menu_ui/options/general_tab.nim ===

$29594613477534* Для применения изменения языка нужно перезапустить игру.



=== presenter/update_state_common.nim ===

$39906291838542* Такт



=== presenter/utilities/helper_functions.nim ===


# Fallback for component name on the left panel
$87591753278764* {nr} Рег

$97450409600317*

[b]ГЛАВНЫЕ ВЫВОДЫ[/b]

1. Чтобы перейти от отрицательного к положительному — инвертируйте все биты и прибавьте 1.
2. Если старший бит [T] — число всегда отрицательное.
3. Построенный вами сумматор байтов также работает со знаковыми числами.
4. Каждое число по-прежнему имеет только один способ записи.


# Fallback for component name on the left panel
$97889215332379* {nr} Памяти


=======================================================================================================================
=======================================================================================================================
================================================= FINISHED TRANSLATION ================================================
=======================================================================================================================
=======================================================================================================================


=== asset/manual/Assembly/Assembly programming/title.txt ===

$81923869207578*
Программирование на ассемблере



=== asset/manual/Assembly/Language creation/Fields/title.txt ===

$32103815380062*
Поля



=== asset/manual/Assembly/Language creation/Instructions/Operators/doc.txt ===

$20029422748716*
[b]Операторы выражений[/b]
Игра предоставляет ограниченный набор операторов для построения виртуальных операндов:

[box]Оператор        Описание                                   Пример        Результат, если %a = -30000
!               логическое НЕ (NOT)                        !%a           0
&&              логическое И (AND)                         %a && 7       1
||              логическое ИЛИ (OR)                        %a || 7       1



=== asset/manual/Assembly/Language creation/Instructions/Operators/title.txt ===

$21043147057012* Операторы



=== asset/manual/Assembly/Language creation/Instructions/doc.txt ===

$64897298154598*
[large]Обзор[/large]

Страница [link="Assembly/Language creation"]Создание языка[/link] описывает только базовые определения инструкций. Эта страница призвана охватить более продвинутые возможности.

Определение инструкции состоит из следующих строк:

[color=#66ff99]Синтаксис[/color]
[color=#ffe666]Виртуальные операнды[/color] (необязательно)
[color=#ff6680]Утверждения[/color] (необязательно)
[color=#66ccff]Машинный код[/color]
[color=#9966ff]Описание[/color]

Пример:
[box][color=#66ff99]jmp %offset(label)[/color]
[color=#ffe666]%high_bits = %offset / 4[/color]
[color=#ff6680]assert(%offset % 4 == 0, "Можно перейти только по адресу кратному 4 байтам")[/color]
[color=#66ccff]01 hhhhhh[/color]
[color=#9966ff]# Переход на %offset[/color][/box]

[large][color=#66ff99]Синтаксис[/color][/large]
Синтаксисы — это список [b]литералов[/b] и [b]операндов[/b], разделённых [b]пробелами[/b].

[b]Литералы[/b]
В примере выше мнемоника [highlight]jmp[/highlight] — это литерал. Инструкции с несколькими операндами обычно также имеют литералы [highlight],[/highlight] между операндами.
Используйте [highlight]%%[/highlight], чтобы экранировать символ [highlight]%[/highlight] в литералах.

[b]Операнды[/b]
Операнды инструкции начинаются с префикса [highlight]%[/highlight] и записываются в форме [highlight]%name(fields)[/highlight].
* [highlight]name[/highlight] — любой идентификатор.
* [highlight]fields[/highlight] — список из одного или нескольких полей, созданных в предыдущей секции «Fields» (или зарезервированных полей). Список разделяется символом трубы ([highlight]|[/highlight]).

[b]Пробелы[/b]
Пробелы могут быть либо табуляциями, либо пробелами. Если используется один символ пробела, пробел будет необязательным в языке ассемблера. Если за символом пробела следует ещё один пробел, ассемблер потребует пробел между токенами.

[large][color=#ffe666]Виртуальные операнды[/color][/large]
В архитектуре примера прыжка выше все инструкции имеют ширину 4 байта, поэтому младшие два бита адреса перехода всегда должны быть равны 0. Мы можем создать новый виртуальный операнд без этих двух младших битов вот так:
[box]%high_bits = %offset / 4[/box]
Мы будем использовать [highlight]%high_bits[/highlight] вместо [highlight]%offset[/highlight] в определении машинного кода.
Список поддерживаемых операторов можно найти [link="Assembly/Language creation/Instructions/Operators"]здесь[/link].

Два специальных операнда определяются автоматически: [highlight]$start[/highlight] и [highlight]$end[/highlight]. $start — это смещение машинного кода непосредственно перед инструкцией, а $end — сразу после. Их можно использовать, например, для вычисления смещений относительно текущей инструкции, вот так:
[box]%rel_offset = %offset - $end[/box]

[large][color=#ff6680]Утверждения(assertions)[/color][/large]
Утверждения позволяют проверять ошибки пользователя. В примере выше мы используем их, чтобы гарантировать, что переход выполняется по адресу, выровненному на 4 байта.

[large][color=#66ccff]Машинный код[/color][/large]
В примере выше используется следующий синтаксис машинного кода.
[box]01 hhhhhh[/box]
Обратите внимание, что [highlight]h[/highlight] относится к виртуальному операнду [highlight]%high_bits[/highlight]. Используя этот синтаксис, биты операндов всегда представляются первой буквой их имени.

Альтернативный, но эквивалентный способ записать то же самое — использовать [b]нарезку битов[/b] (bit slicing):
[box]01 %offset\[8:2][/box]
Нарезка битов использует стандартный аппаратный синтаксис для выбора части битового поля. Синтаксис: [highlight]\[last:first][/highlight], где both first и last включаются.

Нарезку битов можно применять к нескольким операндам и смешивать с синтаксисом «по одному биту на символ».

[large][color=#9966ff]Описание[/color][/large]
Описание не влияет на работу ассемблера — оно существует purely для документирования.



=== asset/manual/Assembly/Language creation/Instructions/title.txt ===

$27583144414493*
Инструкции



=== asset/manual/Assembly/Language creation/Patterns/title.txt ===

$50803475056346*
Шаблоны



=== asset/manual/Assembly/Language creation/Settings/doc.txt ===

$13660841232898*
Секция [highlight]\[settings][/highlight] определяет несколько свойств конфигурации вашей архитектуры:

[b]name[/b]
[box]name = "Architecture name"
[/box]Имя архитектуры.

[b]variant[/b]
[box]variant = "Architecture variant"
[/box]Дополнительное описание архитектуры.

[b]endianness[/b]
Определяет порядок байтов инструкций.
[box]endianness = big
endianness = little[/box]
По умолчанию — прямой порядок байтов (big endian).

Подробнее о порядке байтов можно прочитать [link="Computer concepts/Endianness"]здесь[/link].

[box=info]Компоненты ОЗУ имеют собственный флаг порядка байтов, который можно изменить независимо. Это просто, если ширина инструкции совпадает с битовой шириной компонента памяти, но может быть запутанно, если ширины различаются.[/box]

[b]line_comments[/b]
Задаёт токены, используемые для обозначения начала однострочного комментария. Однострочные комментарии начинаются с заданного токена и захватывают остаток строки.
[box]line_comments = "#"
line_comments = \[";", "//"][/box]
Значение по умолчанию для line_comments — [highlight]\[";", "//"][/highlight].

[b]block_comments[/b]
Задаёт токены, используемые для обозначения начала и конца блочного комментария. Блочные комментарии начинаются с первого токена и захватывают всё до финального токена. Это включает переносы строк, а также дополнительные токены начала блочного комментария (что предотвращает вложенность блочных комментариев).
[box]block_comments = {"/*":"*/"}[/box]
Значение по умолчанию для block_comments — [highlight]{"/*":"*/"}[/highlight].



=== asset/manual/Assembly/Language creation/Settings/title.txt ===

$78090021698706*
Настройки



=== asset/manual/Assembly/Language creation/title.txt ===

$67371980949119*
Создание языка



=== asset/manual/Assembly/title.txt ===

$85571962806085*
Ассемблер



=== asset/manual/Circuits/Auto size/title.txt ===

$18060272082456*
Авто размер



=== asset/manual/Circuits/Circular dependency/title.txt ===

$79928695804890*
Циклическая зависимость



=== asset/manual/Circuits/Delay/doc.txt ===

$25269304368822*
В реальном оборудовании все компоненты имеют задержку. Это важно, поскольку задержка схемы определяет максимальную скорость, с которой вы можете её запускать.

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



=== asset/manual/Circuits/Delay/title.txt ===

$82367602514282*
Задержка



=== asset/manual/Circuits/Short circuit/title.txt ===

$80662783536910*
Короткое замыкание



=== asset/manual/Circuits/The foundry/title.txt ===

$83185064398279*
Мастерская



=== asset/manual/Circuits/The keyboard/doc.txt ===

$18477347795935*
Компонент клавиатуры записывает нажатия клавиш с вашей клавиатуры.

Каждое нажатие клавиши приведёт к двум событиям: событию нажатия клавиши и событию отпускания клавиши. Затем вы сможете прочитать события по одному за раз из компонента.

[large]Режимы клавиатуры[/large]
В разных странах используются разные клавиатуры. Например, в то время как первая строка символов на английской клавиатуре начинается с QWERTY, на русском она начинается с ЙЦУКЕН.

Если вы создаёте текстовый редактор, вас не интересует физическое расположение клавиш — вам просто нужно знать, что на них напечатано. В этом случае вам следует использовать [b]Режим локализации[/b].

С другой стороны, если вы хотите использовать верхние левые клавиши для управления в игре, вам не хочется иметь дело с тем, что WASD на английских клавиатурах превращается в ЦФЫВ на русских клавиатурах. Вам просто нужно ссылаться на физическое расположение клавиш на клавиатуре, а не на то, что на них напечатано. В этом случае вам следует использовать [b]Режим физического расположения[/b].

[large]Режим локализации[/large]

В этом режиме клавиши сопоставляются со значением ASCII, где это возможно. [highlight]w[/highlight] на QWERTY, AZERTY (французская клавиатура) или любой другой клавиатуре всегда будет [highlight]0x77[/highlight].

[large]Режим физического расположения[/large]
В этом режиме клавиши отображаются на их физическое расположение по строке и столбцу. И строка, и столбец используют по 4 бита, поэтому расположения можно аккуратно записывать в шестнадцатеричном виде. Например, пробел находится на 5-й строке и 3-м столбце — это 0x53 в hex.

[image="coordinate_mode.png"]

Обратите внимание, что клавиши справа от чёрной линии имеют бОльшие номера строк, чтобы уместить все клавиши в ограничение 4 бита на строку и столбец.

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



=== asset/manual/Circuits/The keyboard/title.txt ===

$11486015900582*
Клавиатура



=== asset/manual/Circuits/The screen/title.txt ===

$53269020658041*
Экран



=== asset/manual/Circuits/title.txt ===

$42610024611500*
Схемы



=== asset/manual/Computer concepts/ASCII encoding/title.txt ===

$75719044675256*
ASCII кодировка



=== asset/manual/Computer concepts/Binary/doc.txt ===

$39479426746559*
Числа, к которым вы привыкли, используют десятичную систему счисления (основание 10). В ней добавление нуля справа увеличивает значение числа в 10 раз.

Двоичная система счисления (основание 2) работает иначе: добавление нуля справа просто удваивает значение. Другими словами, каждая цифра представляет степень двойки. Вот пример с цветовой подсветкой [color=#c54d5e]двоичной[/color] и [color=#e49f44]десятичной[/color] систем:

[color=#c54d5e]  1[/color] = [color=#e49f44]1[/color]
[color=#c54d5e] 10[/color] = [color=#e49f44]2[/color]
[color=#c54d5e]100[/color] = [color=#e49f44]4[/color]

Чтобы представить число 6, мы просто складываем 4 и 2:

[color=#c54d5e]110[/color] = [color=#e49f44]6[/color]

Сложение, умножение и все остальные операции работают точно так же, как в десятичной системе, только перенос происходит, когда значение достигает 2, а не 10.



=== asset/manual/Computer concepts/Binary/title.txt ===

$73447955210779*
Двоичная система



=== asset/manual/Computer concepts/Bytes/doc.txt ===

$64065714320299*
В этой игре вам предстоит построить 8-битный компьютер. В обычном случае это означало бы, что игрок должен прокладывать 8 параллельных линий проводов во многих местах.

Чтобы избавить вас от такой утомительной рутины, в игре введено понятие байта — это просто виртуальный пучок из 8 битов.

Состояние байтового входа/выхода или байтовой линии передаётся числом, а не красным или зелёным цветом.



=== asset/manual/Computer concepts/Bytes/title.txt ===

$68430971305988*
Байты



=== asset/manual/Computer concepts/De Morgan's laws/doc.txt ===

$13079267765950*
Таблицы истинности четырёх фундаментальных вентилей симметричны. Вы можете переходить от одной к другой, [color=#6e9759][b]инвертируя входы[/b][/color] (вертикальные стрелки) или [color=#595f99][b]инвертируя выход[/b][/color] (горизонтальные стрелки), как показано на рисунке ниже.

[center][image="de morgan.png"][/center]

Примечания
1. Из любого базового вентиля можно получить любой другой — максимум нужно инвертировать оба входа и выход.
2. Между OR(ИЛИ) и NOR(ИЛИ-НЕ) можно перейти, инвертируя только выход. То же самое между AND(И) и NAND(И-НЕ).
   Название NOR(ИЛИ-НЕ) означает NOT OR (НЕ ИЛИ), а NAND — NOT AND (НЕ И).
   Обратите внимание, что форма компонентов OR/NOR одинакова, кроме маленькой точки на выходе, которая обозначает инверсию. То же самое с AND/NAND.
3. Инвертирование выхода переворачивает все биты в последней строке таблицы истинности. Инвертирование входов зеркально отражает последнюю строку таблицы относительно центра.



=== asset/manual/Computer concepts/De Morgan's laws/title.txt ===

$66359790889628*
Законы де Моргана



=== asset/manual/Computer concepts/Endianness/title.txt ===

$25715726162519*
Порядок байт



=== asset/manual/Computer concepts/Negative numbers/doc.txt ===

$22037524510182*
Способ представления отрицательных чисел в этой игре называется "two's complement" (дополнительный код). Это стандартный способ представления отрицательных чисел в современных компьютерах. Вот несколько ключевых моментов для понимания дополнительног кода:
 1. Чтобы перейти от отрицательного к положительному (и обратно), можно инвертировать все биты и прибавить[nbsp]1.
 2. Если старший бит равен [T], значение всегда отрицательное.
 3. Сумматоры работают как в знаковом, так и в беззнаковом режиме.
 4. Каждое число имеет только один способ записи.

В ранние дни вычислительной техники основным конкурентом было дополнение до единицы (one's complement). Его главное преимущество — простота смены знака числа: достаточно применить НЕ (NOT) к каждому биту. Однако у него есть два представления нуля — положительное и отрицательное, что усложняет сравнения.

Ещё одно интересное представление — это основание −2, где знак значения каждой цифры чередуется между положительным и отрицательным.



=== asset/manual/Computer concepts/Negative numbers/title.txt ===

$64907157003500*
Отрицательные числа



=== asset/manual/Computer concepts/Truth tables/title.txt ===

$39788153942181*
Таблицы истинности



=== asset/manual/Computer concepts/Turing complete/doc.txt ===

$38118080841071*
Некоторые компьютеры, например простые калькуляторы, сильно ограничены в том, какие алгоритмы они могут выполнять.

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

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



=== asset/manual/Computer concepts/Turing complete/title.txt ===

$88124920557040*
Полный по Тьюрингу



=== asset/manual/Computer concepts/Universal gates/doc.txt ===

$11499640163947*
Оказывается, всю логику компьютера можно построить на базе вентилей И-НЕ(NAND) или на базе вентилей ИЛИ-НЕ(NOR). Компьютеры наведения Аполлона были полностью построены на вентилях ИЛИ-НЕ(NOR). Разработанные в 1960-х годах, они имели всего 4 КБ оперативной памяти и 32 КБ постоянной памяти, но при этом успешно доставили астронавтов на Луну.

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



=== asset/manual/Computer concepts/Universal gates/title.txt ===

$24291443495513*
Универсальные вентили



=== asset/manual/Computer concepts/title.txt ===

$42755701050268*
Концепции



=== campaign/always_on/hint_0.txt ===

$62210202128540* Обратите внимание, что вход вообще не важен?



=== campaign/always_on/hint_solution.txt ===

$33906573915218* Выберите любой вентиль, который выдаёт [T], когда его входы ни к чему не подключены



=== campaign/always_on/meta.txt ===

$18258110894478* Этот уровень открывает первую страницу руководства. Она очень важная — обязательно внимательно прочитайте её.

$61066799501731* Всегда Включён

$85978749941194* Постройте схему, которая всегда выдаёт [T].



=== campaign/and_gate/hint_0.txt ===

$68158507707802* Вентиль И(AND) можно сделать как НЕ-НЕ-И или как НЕ-(И-НЕ)



=== campaign/and_gate/meta.txt ===

$18221128000007*
Постройте схему, которая соответствует таблице.
[tip]На большинстве уровней есть кнопка-подсказка (лампочка) — нажмите на неё, если у вас возникли трудности.[/tip]

$70892117360845* Вентиль И(AND)



=== campaign/and_gate_3/hint_0.txt ===

$34539182309616* Большой вентиль И(AND) — это просто несколько вентилей И(AND) подряд



=== campaign/and_gate_3/meta.txt ===

$28751026881977* Постройте вентиль И(AND) с тремя входами.

$32912994842868* Большой Вентиль И(AND)



=== campaign/any_doubles/hint_solution.txt ===

$34521278233301* Но это мы оставляем в качестве упражнения для игрока!

$43216513907358* Это решение далеко не самое элегантное и оптимальное



=== campaign/any_doubles/meta.txt ===

$81647833476822* Обнаружение Двух



=== campaign/assembly_programming/meta.txt ===

$17226968214352* Программирование с помощью перфокарт — это довольно утомительно. Давайте попробуем ещё раз прибавить 5 к входному значению, как на предыдущем уровне, но теперь с помощью ассемблера.

$72990407719621* Программирование На Ассемблере



=== campaign/assembly_programming/new_program.asm ===

$36228934755685* Записывает константу 15 в регистр 0

$41299869859669* Это комментарий



=== campaign/assembly_programming/test.si ===

$38629344681843* {input_value} + 5 равно {expected_value}, а не {actual_value}.

$47165251832545* {input_value} + 5 равно {expected_value}, а не Z.



=== campaign/assembly_programming/ui.txt ===

$27941792707668* Прибавьте 5 к входному значению с помощью программирования на ассемблере



=== campaign/binary_programming/meta.txt ===

$12002017150690* Нажмите кнопку «Edit» на компоненте «Program», чтобы начать программирование вашего компьютера с помощью перфокарт. Ваш компьютер должен считать входное значение, прибавить к нему 5 и вывести результат.

$23659479615536* Теперь, когда вы построили свой первый компьютер, пришло время научиться его программировать.

$47348572622406* Программирование На Перфокартах



=== campaign/binary_programming/test.si ===

$61846111928326* {input_value} + 5 равно {expected_value}, а не {actual_value}.

$81797824381193* {input_value} + 5 равно {expected_value}, а не Z.



=== campaign/binary_programming/ui.txt ===

$65391114076509* Прибавьте 5 к входному значению с помощью программирования на перфокартах



=== campaign/binary_racer/meta.txt ===

$37988524800638* Двоичная Гонка



=== campaign/binary_search/meta.txt ===

$16764912826624* Взломщик Кода



=== campaign/bit_adder/hint_0.txt ===

$32998192994042* Для суммы используется та же логика, что и на уровне «Нечётное Количество Сигналов»



=== campaign/bit_adder/meta.txt ===

$10776402819741* Мы измеряем Вселенную числами. Поэтому наша машина должна уметь считать.

$19285770105090*
Считайте входы как [b]0[/b] или [b]1[/b] в зависимости от того, [F] они или [T]. Сложите их в двоичной системе, чтобы результат был либо [b]0[/b], либо [b]1[/b].

Как и в обычном сложении, если результат не помещается в один разряд, установите перенос в [b]1[/b].

$64470174232265* Полусумматор



=== campaign/bit_switch/hint_0.txt ===

$22413958203952* Таблица истинности просто говорит нам сделать вентиль ИСКЛ-ИЛИ(XOR)

$46480779443140* Для начала представим, что ограничение на компоненты не существует



=== campaign/bit_switch/meta.txt ===

$12922292218235* Битовый Переключатель

$77268807700313* Используя 2 вентиля НЕ и 2 переключателя, постройте вентиль ИСКЛ-ИЛИ(XOR).



=== campaign/byte_adder/hint_0.txt ===

$37690209655811* Вам понадобится всего 8 полных сумматоров



=== campaign/byte_adder/hint_1.txt ===

$49335074955899* Сложение на уровне битов можно выполнить с помощью компонента Полный сумматор

$56143546486508* Как и у других байтовых компонентов, сначала разбиваем байты на отдельные биты



=== campaign/byte_adder/hint_solution.txt ===

$36646953278480* Перенос с предыдущего бита является переносом на вход следующего

$69804974830322* Подключите перенос на входе и перенос на выходе уровня, чтобы завершить схему



=== campaign/byte_adder/label.txt ===

$45190053242926* Перенос вход

$76244671092409* Перенос выход



=== campaign/byte_adder/meta.txt ===

$31490345812891* Сложите два входных байта. Каждый бит выхода должен быть результатом сложения соответствующих битов входов с учётом возможного переноса.

$53076615315445* На этом уровне очень много тестов. Щёлкните правой кнопкой мыши по кнопке запуска, чтобы увеличить скорость тестирования.

$62793095496458* Сложение Байтов



=== campaign/byte_adder/ui.txt ===

$51758065631068* [color=#E49F44][left]Перенос       Сумма[/left][/color]



=== campaign/byte_asr/hint_0.txt ===

$86214455922761* Для начала давайте вспомним, что представляют собой эти сдвиги: это схемы на основе разветвителя байта и объединителя



=== campaign/byte_asr/hint_1.txt ===

$11228896363898* т.е. сдвиг на 3 эквивалентен сдвигу на 1 + сдвигу на 2

$11260842500047* Мы можем реализовать версию этого сдвига, называемую barrel shifter (быстрым сдвигом)

$55175982917102* Для этого отметим аддитивное свойство сдвига,



=== campaign/byte_asr/meta.txt ===

$53539145017840* ASR



=== campaign/byte_constant/meta.txt ===

$55176290924321* Создайте схему, которая всегда выводит число 164.

$55259569122850* Байтовая Константа



=== campaign/byte_constant/ui.txt ===

$90758832592628* Создайте цепь, которая всегда выводит число 164.



=== campaign/byte_divide/meta.txt ===

$15513439442399* Разделите два входных числа и выведите результат. Обратите внимание: этот уровень необязательный, так как он очень сложный. Если второй вход (делитель) равен 0, результат должен быть равен 0.

$55155519654685* Деление



=== campaign/byte_divide/test.si ===

$10903561275291* {a} / {b} равно {result}



=== campaign/byte_divide/ui.txt ===

$86943286745277* Разделите два числа.



=== campaign/byte_equal/hint_0.txt ===

$13186595896308* ИСКЛ-ИЛИ(XOR) двух одинаковых чисел даёт очень красивый результат



=== campaign/byte_equal/hint_solution.txt ===

$85034261531833* ИСКЛ-ИЛИ(XOR) двух чисел равно 0 тогда и только тогда, когда они равны



=== campaign/byte_equal/meta.txt ===

$16679981460998* Выведите [T], когда оба входа одинаковые.

$44220989927736* Равенство



=== campaign/byte_equal/test.si ===

$18508994046371* {a} == {b} это {value}

$32432328437519* Значение {a} не равно {b}

$51276780017906* Значение {a} равно {b}



=== campaign/byte_equal/ui.txt ===

$41065065514143* Создайте цепь, которая выводит [T], когда оба входа одинаковые.



=== campaign/byte_less_s/hint_1.txt ===

$82755888644217* Если знаковые биты входов различаются, мы можем просто сравнить их



=== campaign/byte_less_s/hint_solution.txt ===

$52492743864774* В противном случае мы можем сравнить два 7-битных беззнаковых числа



=== campaign/byte_less_s/meta.txt ===

$12621415211383* Создайте схему, которая выводит [T], когда первый вход меньше второго. Интерпретируйте байты как [color=#dd6576]знаковые[/color].

$57911276445846* Знаковое Меньше



=== campaign/byte_less_s/test.si ===

$18672872329218* Значение {a} не меньше {b}

$60636366241019* Значение {a} меньше {b}

$67770115019509* {a} < {b} равно {result}



=== campaign/byte_less_s/ui.txt ===

$33907970782848* Создайте цепь, которая выводит [T], когда первое число меньше второго (со знаком).



=== campaign/byte_less_u/hint_0.txt ===

$18968293717104* Один из способов — сравнивать по цифрам, как мы делаем для десятичных чисел

$45223418140453* Например, 09 < 21, потому что 0 < 2, поэтому 1100 > 1001, потому что 11XX > 10XX



=== campaign/byte_less_u/hint_1.txt ===

$23270172293605* поэтому для каждого бита используйте цепочку вентилей ИЛИ(OR), чтобы проверить, есть ли выше включённые биты

$34091176621640* Это можно сделать с помощью байтового ИСКЛ-ИЛИ(XOR) (помните, что ИСКЛ-ИЛИ(XOR) включает [T], когда входы не совпадают)

$38704349429368* Сначала определите, какие биты отличаются между двумя байтами

$45560562333305* Но мы должны учитывать только самый старший отличающийся бит,

$72421677239233* Мы знаем, что число с самым старшим отличающимся битом [T] является большим



=== campaign/byte_less_u/hint_2.txt ===

$37315430614523* 09 < 11, поэтому 09 - 11 < 0; 1100 > 1001, поэтому 1100 - 1001 > 0

$73589178770254* Другой способ — сравнить разность с нулём



=== campaign/byte_less_u/hint_3.txt ===

$19139933016995* У нас нет компонента вычитания, только сложение и отрицание

$56709208304109* Поэтому мы преобразуем, например, 1100 - 1001 в 1100 + (-1001)



=== campaign/byte_less_u/hint_4.txt ===

$21199347421587* Чтобы представить их в знаковом виде, нужно работать с 9-битными байтами

$46518640933018* Но у нас 8-битные беззнаковые входы



=== campaign/byte_less_u/hint_5.txt ===

$11293872851403* Мы можем сделать пользовательский 9-битный компонент

$17291563256662* Или разделить ОТРИЦ(NEG) на элементы НЕ(NOT) и ADD_1(+1) и использовать их 



=== campaign/byte_less_u/hint_solution.txt ===

$90593296729801* Упростите схему



=== campaign/byte_less_u/meta.txt ===

$39605373706887* Беззнаковое Меньше

$68842379350661* Создйте схему, которая выводит [T], когда первое число меньше второго. Интерпретируйте байты как [color=#dd6576]unsigned[/color](беззнаковые).



=== campaign/byte_less_u/test.si ===

$50702714470018* Значение {a} не меньше {b}

$54835419299907* Значение {a} меньше {b}

$75551771019196* {a} < {b} равно {value}



=== campaign/byte_less_u/ui.txt ===

$88632565567686* Создайте цепь, которая выводит [T], когда первое число меньше второго (без знака).



=== campaign/byte_lsr/hint_0.txt ===

$75806240403820* Для начала давайте вспомним, что представляют собой эти сдвиги: это схемы на основе разветвителя байта и объединителя



=== campaign/byte_lsr/hint_1.txt ===

$12195819154781* т.е. сдвиг на 3 эквивалентен сдвигу на 1 + сдвигу на 2

$28136552692253* Мы можем реализовать версию этого сдвига, называемую barrel shifter (быстрым сдвигом)

$88850298427736* Для этого отметим аддитивное свойство сдвига,



=== campaign/byte_lsr/label.txt ===

$17566441654249* Сдвиг



=== campaign/byte_lsr/meta.txt ===

$26791208073532* Задача уровня — сдвинуть первый вход вправо на величину, указанную во втором входе.

$36654581830314* LSR

$83781539475221* В дополнение к компоненту сдвига вправо вы также получили компонент сдвига влево.



=== campaign/byte_mod/meta.txt ===

$84095392269624* Остаток От Деления

$87605997307596* Выводит остаток от деления двух входов. Если второй вход (делитель) равен 0, результат должен совпадать с первым входом (делимым).



=== campaign/byte_mod/test.si ===

$38641362389638* {a} mod {b} это {result}



=== campaign/byte_mod/ui.txt ===

$76653207214085* Возвращает остаток от деления двух входов.



=== campaign/byte_mux/hint_0.txt ===

$37740515704094* Этот уровень очень похож на «БИТОВЫЙ ПЕРЕКЛЮЧАТЕЛЬ»



=== campaign/byte_mux/label.txt ===

$63172000393911* Выбор



=== campaign/byte_mux/meta.txt ===

$44523532982427* Когда бит выбора равен [F], выведите Байт A, иначе выведите Байт B.

$75861961518456* Мультиплексор



=== campaign/byte_mux/test.si ===

$15140861344476* Выбран {select}



=== campaign/byte_nand/hint_0.txt ===

$88766421259023* Побитовое И-НЕ(NAND) двух двоичных чисел — это просто вентиль И-НЕ(NAND), применённый к каждому биту



=== campaign/byte_nand/meta.txt ===

$11980470862173* Байтовый И-НЕ(NAND)



=== campaign/byte_not/hint_0.txt ===

$55051011788323* Байтовое НЕ(NOT) двоичного числа — это просто вентиль НЕ(NOT), применённый побитово к двоичному числу



=== campaign/byte_not/meta.txt ===

$54090032127372* Инвертируйте каждый бит входного байта.

$65498108564418* Байтовый НЕ(NOT)



=== campaign/byte_xor/hint_0.txt ===

$66692685876410* Байтовое ИСКЛ-ИЛИ(XOR) двух двоичных чисел — это просто вентиль ИСКЛ-ИЛИ(XOR), применённый побитово между ними



=== campaign/byte_xor/meta.txt ===

$41472172986798* Байтовый ИСКЛ-ИЛИ(XOR)

$70973830134418* Создайте схему, которая выполняет побитовое ИСКЛ-ИЛИ(XOR) двух байтов.



=== campaign/byte_xor/test.si ===

$54747903652562* {a} XOR {b} это {result}



=== campaign/byte_xor/ui.txt ===

$62779271315005* Создайте цепь, которая выполняет побитовое ИСКЛ-ИЛИ(XOR) двух байтов.



=== campaign/capitalize/meta.txt ===

$22440157378882* Заглавные Буквы



=== campaign/capitalize/test.si ===

$37137490280093* Вы ещё не прочитали символ {character} из строки

$52976618691411* Выход должен был быть {char}, а не {output}



=== campaign/circumference/meta.txt ===

$21808795465233* Умножение на 6

$46884494321384* Цель уровня — взять входное число и умножить его на 6 с помощью языка ассемблера.



=== campaign/circumference/test.si ===

$18136442036625* Чему равно 2π × {radius}?



=== campaign/circumference/ui.txt ===

$24129473753872* Прочитайте вход

$47357954866257* *Считаем что π ≈ 3



=== campaign/conditional_jumps/meta.txt ===

$38150072401115*
Чтобы пройти уровень, читайте вход до тех пор, пока не увидите число 37.

Затем выведите количество прочитанных значений.

$40525671378957*
Цель уровня — познакомить вас с переходами и метками.

Переход (jump) — это инструкция, которая перезаписывает счётчик.

Перезапись счётчика означает, что мы «прыгаем» к другой инструкции в программе, вместо того чтобы просто идти дальше.

$47703565240245* Условные Переходы



=== campaign/conditional_jumps/new_program.asm ===

$35642914965530* Выполняет Переход на 5-й байт программы

$50319416070023* Пересылает 5 в регистр 0

$66946505646203* Так можно загрузить её смещение

$67381454058237* Это метка



=== campaign/conditional_jumps/test.si ===

$39953782121467* Последний вход был не 37!

$75138288162938* Вы прочитали вход {read_count} раз, а не {output}.



=== campaign/conditional_jumps/ui.txt ===

$65261628219716* Редактируйте ассемблер в ОЗУ



=== campaign/count_leading_zeroes/hint_0.txt ===

$15352671410916* где 8 — это количество бит, а log2 — позиция первого бита [T].

$75683304945175* За исключением случая, когда Вход равен 0, это то же самое, что 8 - 1 - log2(Вход)

$83745112465243* Нахождение log2 двоичных чисел — очень хорошо изученная область в информатике



=== campaign/count_leading_zeroes/hint_1.txt ===

$40521556880682* Один из методов — разделить задачу:

$46035077948196* Чему равен log2 2-битного ненулевого двоичного числа (то есть 1, 2 или 3)?



=== campaign/count_leading_zeroes/hint_2.txt ===

$32041142528569* Вычитая из (2 - 1) = 1, получаем 1 и 0 ведущих нулей соответственно

$88044062357651* А как насчёт 4-битного числа?

$88309764896321* Если число меньше 2, log2 = 0; иначе log2 = 1



=== campaign/count_leading_zeroes/hint_3.txt ===

$24472621996685* Если число меньше 4, мы можем свести задачу к 2-битной

$42632561737634* В любом случае задача сводится с 4 бит до 2 бит

$87709120049440* Если нет, то первый бит [T] находится где-то в старших 2 битах



=== campaign/count_leading_zeroes/hint_4.txt ===

$12591714876491* Единственное, чего не хватает — это случай, когда Вход равен 0

$82513296271559* Примените те же шаги, чтобы свести задачу с 8 бит до 4 бит



=== campaign/count_leading_zeroes/hint_solution.txt ===

$27675083487752* Это решение ни в коем случае не самое элегантное или оптимальное

$62535209440079* Впрочем, это остаётся вам в качестве упражнения!

$81301599100070* Самый простой способ — отдельно обработать случай 0



=== campaign/count_leading_zeroes/meta.txt ===

$18890527031365* Подсчёт Ведущих Нулей



=== campaign/count_leading_zeroes/test.si ===

$10248302990519* В числе {input_value} ({binary_value}) {count} ведущих нулей

$46565705342966* В числе {input_value} ({binary_value}) 1 ведущий нуль



=== campaign/count_leading_zeroes/ui.txt ===

$85604588212035* Посчитайте ведущие нули



=== campaign/counter/hint_0.txt ===

$74290091312759* Этот уровень — всего в одном шаге от сохранения с возможностью перезаписи



=== campaign/counter/hint_solution.txt ===

$22938387275450* Просто прибавьте 1 к зацикливающему проводу линии задержки



=== campaign/counter/label.txt ===

$24866509692444* Установить



=== campaign/counter/meta.txt ===

$68850421394935* Счётчик



=== campaign/counter/test.si ===

$27837193789838* Выход должен быть {memory}.

$30050502504940* Прибавить 1

$69821998974515* Перезаписать значением {num}



=== campaign/counter/ui.txt ===

$16305942415014* Действие

$57018164959250* Следующий желаемый выход



=== campaign/counting_signals/hint_0.txt ===

$20653200546136* Схема для бита единиц такая же, как в уровне «Нечётное Количество Сигналов»

$39788606928520* Схема для бита двоек — это то, что вы сделали в «Обнаружение Двух», кроме случая, когда все 4 включены



=== campaign/counting_signals/hint_1.txt ===

$79041418443903* Выход 0 — это то же самое, что и в уровне «Нечётное Количество Сигналов»



=== campaign/counting_signals/hint_3.txt ===

$83417330967064* Часть «как минимум 2» мы уже сделали в уровне «Обнаружение Двух»



=== campaign/counting_signals/meta.txt ===

$14499217305520* Подсчёт Сигналов



=== campaign/decoder_1/meta.txt ===

$55345008240214* 1-битный Декодер

$64947954189801* Создайте компонент, который может переключать сигнал между двумя пинами.



=== campaign/decoder_1/ui.txt ===

$56552908891774* Выход 1



=== campaign/decoder_2/meta.txt ===

$44276233109848* 2-битный Декодер

$46223188985873* При 2-битном входе существует 4 комбинации. Создайте схему, которая выбирает ровно 1 выход для каждой из 4 комбинаций. В любой момент должен быть включён не более чем 1 бит.



=== campaign/decoder_3/label.txt ===

$44918705544255* Выкл.



=== campaign/decoder_3/meta.txt ===

$28695849165746* При 3 битах на входе существует 8 комбинаций. Постройте схему, которая выбирает один выход для каждой из 8 комбинаций. Кроме того, есть вход запрета. Когда он [T], все выходы должны быть [F].

$43603044118584* 3-битный Декодер



=== campaign/decoder_3/test.si ===

$10870388349665* Ожидается, что выход {cycle} будет [T], а остальные [F]



=== campaign/decoder_3/ui.txt ===

$20191487800946* Желаемый бит

$23128720321555* Отключён



=== campaign/dependency/hint_0.txt ===

$21613887420121* Простая схема, где вход зависит от собственного выхода, — это замкнутый вентиль НЕ(NOT)

$57091568089512* Обратите внимание на красный ошибочный провод

$64834808154176* Это ошибка в других уровнях, но цель именно этого уровня



=== campaign/dependency/hint_1.txt ===

$13967626449720* Некоторые даже обманчивые, как в этом примере, который может иметь смысл в чисто логической форме

$71118235828147* Циклическая зависимость может быть сложной и включать множество разных проводов и компонентов



=== campaign/dependency/meta.txt ===

$24156270270079*
Создайте «циклическую зависимость». Это схема, в которой вход компонента зависит от его собственного выхода. В ситуации циклической зависимости невозможно определить выход компонента, потому что сначала нужно определить вход, который зависит от выхода, и так далее (отсюда и название «циклическая»).

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

$25862237357880* Циклическая Зависимость



=== campaign/double_buffer/meta.txt ===

$81657957055974* Линии Задержки



=== campaign/double_number/hint_0.txt ===

$13944257184132* На этом уровне предоставляется байт — группа из 8 битов, поэтому мы должны их разветвить и объединить



=== campaign/double_number/hint_1.txt ===

$29000872588470* Чтобы удвоить число в двоичном формате, нужно сдвинуть позицию бита на одну



=== campaign/double_number/meta.txt ===

$46697878992908* Удвоение Числа

$78449227663032*
На этом уровне вводятся байтовые значения — числа от 0 до 255. Байт состоит из 8 битов. Вам даны два новых компонента: один разбивает байт на биты, другой собирает биты обратно в байт.

С помощью этих компонентов придумайте, как удвоить входное число (до 127).



=== campaign/foundry/meta.txt ===

$62612312608874* Поскольку этот уровень — инструмент, а не испытание, вы можете перейти на карту уровней и продолжить, когда захотите.

$72171231322685* Мастерская

$88436914545275* Компоненты можно добавлять, переименовывать и удалять через меню схем.



=== campaign/full_adder/hint_0.txt ===

$50970897346580* Сумма (SUM) требует того же рассуждения, что и в уровне «Нечётное Количество Сигналов»



=== campaign/full_adder/hint_solution.txt ===

$13880107359455* Однако это оставляем вам в качестве упражнения!

$18497022543669* Это решение ни в коем случае не самое изящное или оптимальное



=== campaign/full_adder/label.txt ===

$12555311310864* Вход 0

$13755587162128* Вход 2

$34717193596171* Перенос

$41149959264274* Вход 1

$50183740481245* Сумма



=== campaign/full_adder/meta.txt ===

$34381936755276*
На прошлом уровне мы складывали два входа, теперь складываем три. Снова сложите входы в двоичной системе, чтобы результат был либо [b]0[/b], либо [b]1[/b].

Как и в обычном сложении, если результат не помещается в один разряд, установите перенос в [b]1[/b].

$42735906141201* Полный Сумматор



=== campaign/full_adder/ui.txt ===

$40317306745068* Желаемая сумма

$49855734765642* Желаемый перенос

$51965136043073* Текущий перенос

$84617036256734* Текущая сумма



=== campaign/hex_racer/meta.txt ===

$45399195121692* Шестнадцатеричная Гонка

$87098190175913*
Переключайте биты в панели уровня так, чтобы в сумме они давали шестнадцатеричное число из вопроса.

Чтобы пройти уровень, нужно победить на 3-м уровне.



=== campaign/introduction/meta.txt ===

$44716420394020* Скромное Начало



=== campaign/logic_gate_racer/meta.txt ===

$35186537961257* Этот уровень создан, чтобы убедиться, что вы хорошо освоили булеву логику, прежде чем двигаться дальше. Хорошее понимание сильно поможет вам в будущем.

$39180730338379* Здесь вам предстоит пройти тест на несколько разных схем. Когда вы нажмёте кнопку «Запуск», ваша схема будет проверена. Если она правильная — появится зелёная отметка, если нет — красная. Уровень считается пройденным, когда из 5 отметок в истории ниже хотя бы 4 будут зелёными.

$39721874026332* Отличная работа! Теперь, когда вы уверенно владеете булевой логикой, пришло время приступить к созданию вашего первого компьютера. Но сначала нужно изучить память и двоичную арифметику. Путь к мастерству долог, но очень приятен.

$57679157572023* Экзамен По Логике



=== campaign/logic_gate_racer/ui.txt ===

$32183772878666* История



=== campaign/maze/hint_0.txt ===

$10423837492124* [left][b]Повернуть налево[/b][/left]

$18756407685566* [left][b]Поворачивать направо, пока впереди стена[/b][/left]

$51767168505953* [left][b]Повторить[/b][/left]

$60076150664554* Всегда следуя по левой (или правой) стороне лабиринта, вы обязательно в итоге дойдёте до выхода

$63325960964451* [left][b]Шаг вперёд[/b][/left]

$66501964970865* Псевдокод такого алгоритма выглядит так:



=== campaign/maze/meta.txt ===

$19088384441761*
Чтение входа покажет, что робот видит перед собой. Возможны два варианта:
0 — ничего
1 — стена

$56722492138232* Отличная работа! Вы прошли лабиринт и уверенно владеете ассемблером Overture. Но Overture слишком простой. Далее вы будете строить Symphony — более мощный компьютер с ОЗУ, экраном, клавиатурой и возможностью повторного использования кода через функции. По пути вам предстоит создать новые компоненты, изучить стек и многое другое.

$84960209408475*
На этом уровне вы управляете роботом. Напишите алгоритм, который проведёт его от старта до двери в конце лабиринта.

Доступны три команды:
0 — поворот влево
1 — движение вперёд
2 — поворот вправо

Вы также можете управлять роботом вручную с помощью стрелок.

$90660848232877* Лабиринт



=== campaign/mod_4/hint_0.txt ===

$23027113131109* представляет число по модулю 2 (чётное или нечётное), младшие 3 бита — по модулю 8 и так далее

$35037773638556* Аналогично в десятичной 4321 по модулю 100 тоже просто

$40190253854900* В двоичной системе взятие остатка от деления на 4 равно использованию только двух младших битов

$44666331884152* Это потому, что старшие биты представляют 4, 8, 16 и т.д., и все они делятся на 4 без остатка

$47075416850998* Это верно в общем случае для остатка от деления на степень двойки: младший бит числа

$79521133202800* (ответ 21, старшие цифры отбрасываются, потому что 100 — степень 10)

$81555476661504* Теперь вам остаётся только понять, как получить последние 2 цифры числа



=== campaign/mod_4/meta.txt ===

$78836302049950* Модуль 4-х



=== campaign/mod_4/test.si ===

$60992625993288* {inp} mod 4 равно {result}.



=== campaign/multiply/meta.txt ===

$44500958231665* Умножьте два числа. Если результат не помещается в 8 битов, отбросьте лишние биты.

$54529139494347* Умножение



=== campaign/multiply/test.si ===

$13790051293386* {a} * {b} это {result}

$46804407616321* Младший байт {a} * {b} должен быть {result}

$83214947196979* Умножьте два числа



=== campaign/multiply/ui.txt ===

$77112891598455* Умножьте два числа



=== campaign/nand_gate/meta.txt ===

$39082333495604* Вентиль И-НЕ(NAND)

$68865507501612* На этой схеме находится вентиль И-НЕ(NAND), который я хочу, чтобы вы изучили. Я хочу, чтобы вы задокументировали его поведение, заполнив таблицу истинности в панели, которую вы видите ниже. Заполнены только две строки для входов таблицы истинности. Ваша задача — поэкспериментировать со входами схемы, понаблюдать, что делает вентиль И-НЕ, и заполнить последнюю строку таблицы истинности.



=== campaign/negative_numbers/meta.txt ===

$20753698232132* Отрицательные числа

$87951492143019* Чтобы отличать всякие штуки друг от друга, нужно уметь вычитать. А для вычитания сначала нужны отрицательные числа.



=== campaign/nim/meta.txt ===

$19817843844200* Ним

$47072576894526* Также схемы являются общими для уровней архитектуры, поэтому вы можете решить этот уровень как на Overture, так и на Symphony. Нажмите на иконку файла в верхнем левом углу, чтобы сменить схему.

$53912339443439*
На этом уровне вам нужно победить ИИ в простой карточной игре. Правила такие:

На столе лежит 12 карт. Игроки по очереди берут от 1 до 3 карт. Вы начинаете первым. Игрок, который берёт последнюю карту (джокер), проигрывает.

Чтение входа даёт текущее количество оставшихся карт. Отправив на выход 1, 2 или 3, вы заберёте соответствующее количество карт. Противник реагирует сразу, поэтому вы можете сразу прочитать вход, чтобы увидеть результат его хода.



=== campaign/nim/test.si ===

$27262056315410* Вы проиграли!

$29769682738867* Вы можете взять только 1, 2 или 3 карты

$42147812867053* Вы выиграли!

$49299754864790* Нажмите Enter, чтобы взять {card_count} карт

$64085588225039* Нажмите Enter, чтобы увидеть ход противника

$85502688597126* Используйте стрелки, чтобы брать карты

$90440029783715* Вы взяли последнюю карту



=== campaign/nim/ui.txt ===

$79378464416004* Используйте стрелки для выбора карт



=== campaign/nor_gate/hint_1.txt ===

$14349743750598* Вентиль И(AND) можно сделать как НЕ-НЕ-И или как НЕ-(И-НЕ)



=== campaign/nor_gate/meta.txt ===

$56653221050913* Постройте схему, которая соответствует таблице.

$72918877035793* Вентиль ИЛИ-НЕ(NOR)



=== campaign/not_gate/hint_0.txt ===

$26513163439009* У нас есть только вентиль И-НЕ(NAND)



=== campaign/not_gate/meta.txt ===

$16394937100308* Вентиль НЕ(NOT)

$56423993638708* На прошлом уровне вы заполняли таблицу истинности, которая описывала работу вентиля. На этом уровне вам нужно построить схему, которая соответствует таблице истинности.

$80163590000700* Теперь, когда вы открыли вентиль И-НЕ(NAND), пришло время построить схему самостоятельно.



=== campaign/odd_number_of_signals/hint_0.txt ===

$17243045715726* Вы можете определить, есть ли у двух входов нечётное число [T], с помощью всего одного компонента



=== campaign/odd_number_of_signals/hint_2.txt ===

$28104365880572* чётное число + чётное число = чётное число

$49444546097133* нечётное число + нечётное число = чётное число

$57603105454008* Есть ли у нас компонент, который ведёт себя именно так?

$59534613718377* нечётное число + чётное число = нечётное число



=== campaign/odd_number_of_signals/hint_3.txt ===

$47175212977659* Вентиль ИСКЛ-ИЛИ(XOR) — именно то, что нужно



=== campaign/odd_number_of_signals/meta.txt ===

$44190469254011* Нечётное Количество Сигналов

$63242509760527* Используя максимум 3 компонента, выведите [T] только тогда, когда нечётное количество входов [T].



=== campaign/odd_number_of_signals/test.si ===

$36609687959808* {count} из 3

$40553112323959* Вы не можете использовать более 3 компонентов на этом уровне



=== campaign/odd_number_of_signals/ui.txt ===

$74552564780850* Компонентов потрачено



=== campaign/odd_ticks/hint_0.txt ===

$69947751578736* Вход здесь — просто отвлечение



=== campaign/odd_ticks/hint_1.txt ===

$14188568517859* Линию задержки можно замкнуть на саму себя



=== campaign/odd_ticks/meta.txt ===

$17699211754487* На предыдущем уровне вы узнали, что циклические зависимости запрещены. Теперь вы познакомитесь с единственным исключением.



=== campaign/one_hot_encoding/hint_0.txt ===

$28460985244857* Один из компонентов, который вам понадобится, — это сдвиг



=== campaign/one_hot_encoding/hint_1.txt ===

$49063245216494* Этот уровень использует ранее реализованный компонент LSL (сдвиг влево)



=== campaign/one_hot_encoding/meta.txt ===

$12296593054599* Унитарное Кодирование

$17817215316423*
Вход определяет, какой выход должен быть [T]. Если вход равен 7, включите 7-й выход и [F] все остальные.

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



=== campaign/one_hot_encoding/test.si ===

$60812617177494* Не используйте более 3 компонентов.

$74562193652628* Выход на пине {pin} неверный.



=== campaign/or_gate/meta.txt ===

$46797361496226*
Постройте схему, которая соответствует таблице.
[tip]Дважды кликните по компоненту, чтобы переместить его вместе с подключёнными проводами.[/tip]

$81822607191994* Вентиль ИЛИ(OR)



=== campaign/or_gate_3/hint_0.txt ===

$67313804184537* Больший вентиль ИЛИ(OR) — это просто несколько вентилей ИЛИ(OR) подряд



=== campaign/or_gate_3/meta.txt ===

$29275887429601* Постройте вентиль ИЛИ(OR) с тремя входами.

$68089739910654* Большой Вентиль ИЛИ(OR)



=== campaign/or_gate_3/ui.txt ===

$15378963142694* Вход 2



=== campaign/overture_1_registers/hint_0.txt ===

$25938996008186* с Источником(source) вместо Входов(Inputs) и Приёмником(Destination) вместо Выходов(Outputs)

$87908319845833* Этот уровень похож на «ШИНУ»



=== campaign/overture_1_registers/hint_1.txt ===

$66937784075495* Затем мы используем декодеры, чтобы найти включённый источник(source) и приёмник(destination)



=== campaign/overture_1_registers/meta.txt ===

$36376879506769* Наконец-то пришло время построить ваш первый компьютер. Я научу вас создавать архитектуру [color=#e49f44]Overture[/color] — настоящую машину Тьюринга, полноценный компьютер.

$79626649565563* Регистры



=== campaign/overture_1_registers/test.si ===

$18540192543555* Регистр {reg_i} должен иметь значение {value}.

$51132330915663* Выход не разрешён.

$75546240775660* Ожидаемый выход: {value}.



=== campaign/overture_1_registers/ui.txt ===

$77115196290575* Постройте основу архитектуры Symphony



=== campaign/overture_2_alu/meta.txt ===

$76398546711745* АЛУ



=== campaign/overture_2_alu/test.si ===

$27417572090527* Выход не разрешён.

$45837083894306* Ожидаемый выход: {value}.

$67011612338355* Регистр {reg_i} должен иметь значение {value}.



=== campaign/overture_2_alu/ui.txt ===

$49706182840588* Интегрируйте АЛУ в цепь



=== campaign/overture_3_immediates/meta.txt ===

$23614311904581* Непосредственные Значения



=== campaign/overture_3_immediates/test.si ===

$17793323757435* Ожидаемый выход: {value}.

$73489311755739* Регистр {reg_i} должен иметь значение {value}.

$82564442776805* Выход не разрешён.



=== campaign/overture_3_immediates/ui.txt ===

$57764930098721* Добавьте непосредственные значения в цепь



=== campaign/overture_4_program/meta.txt ===

$10102035559374* Программа



=== campaign/overture_4_program/test.si ===

$49097812105667* Регистр {reg_i} должен иметь значение {value}.

$50052313044113* Выход не разрешён.

$73023200204536* Счётчик должен иметь значение {expected_value}.

$88140381331491* Ожидаемый выход: {value}.



=== campaign/overture_4_program/ui.txt ===

$62678678871254* Добавьте программу в схему



=== campaign/overture_5_conditionals/label.txt ===

$37075142107851* Рег 2

$38743609381557* Рег 1

$40362507068221* Рег 4

$57061942907076* Рег 5

$79357977314471* Рег 3

$82470056393191* Рег 0



=== campaign/overture_5_conditionals/meta.txt ===

$59169726539090* Тьюринг-Полный

$77166984247940* До этого момента все возможные программы выполнялись строго по порядку, байт за байтом.

$85320707451673* Раньше только код мог влиять на память, теперь память должна влиять на код. С добавлением условной логики наш компьютер может выполнять любой алгоритм и вычислять всё, что вообще можно вычислить. Как и у всех реальных компьютеров, единственное ограничение — конечный объём памяти.



=== campaign/overture_5_conditionals/test.si ===

$33411257451562* Ожидаемый выход: {value}.

$36308361121667* Выход не разрешён.



=== campaign/overture_5_conditionals/ui.txt ===

$65145204616501* Добавьте условия в схему



=== campaign/overture_6_budget/default.isa ===

$18505654344513* Переход на адрес в r0.

$21095867785396* И(AND) над r1 и r2, результат сохраняет в r3.

$24147817394058* Переход на адрес в r0, если r3 меньше 0.

$26704206992933* И-НЕ(NAND) над r1 и r2, результат сохраняет в r3.

$33850592701591* Вычитает r2 из r1, результат сохраняет в r3.

$43876958520450* Переход на адрес в r0, если r3 не равен 0.

$46599288949396* Переход на адрес в r0, если r3 равен 0.

$48758564562305* Переход на адрес в r0, если r3 меньше или равен 0.

$58823897430160* ИЛИ(OR) над r1 и r2, результат сохраняет в r3.

$64808551937719* Переход на адрес в r0, если r3 больше или равен 0.

$75067212691206* ИЛИ-НЕ(NOR) над r1 и r2, результат сохраняет в r3.

$75524550463342* Складывает r1 и r2, результат сохраняет в r3.

$88048573834702* Переход на адрес в r0, если r3 больше 0.



=== campaign/overture_6_budget/label.txt ===

$42538649427331* Программа



=== campaign/overture_6_budget/test.si ===

$24524168624111* Память счётчика должна быть {expected_value}.

$35224907301551* Регистр {reg_i} должен иметь значение {value}.



=== campaign/overture_alu_1/hint_0.txt ===

$17808301775724* Этот уровень похож на «МУЛЬТИПЛЕКСОР»

$69085851994491* с результатами И-НЕ(NAND), ИЛИ(OR), И(AND) и ИЛИ-НЕ(NOR) вместо Входа A/B



=== campaign/overture_alu_1/hint_solution.txt ===

$76898193108851* Включённый переключатель затем можно найти с помощью декодера



=== campaign/overture_alu_1/meta.txt ===

$16562043259074* АЛУ 1

$31234606133949*
Создайте арифметико-логическое устройство (АЛУ), которое может выполнять ИЛИ(OR), И-НЕ(NAND), ИЛИ-НЕ(NOR) или И(AND) над двумя байтовыми входами. Третий вход — это инструкция. Инструкция — это просто число, которое определяет, какую операцию выполнять.

Инструкции:

[color=#87a8c8]0 И-НЕ(NAND)
1 ИЛИ(OR)
2 И(AND)
3 ИЛИ-НЕ(NOR)[/color]



=== campaign/overture_alu_2/hint_solution.txt ===

$30599543511275* Расширение с использованием 3-битного декодера вместо 2-битного

$61118397217284* A SUB B — это A + (- B)



=== campaign/overture_alu_2/meta.txt ===

$20519420764551* АЛУ 2

$39134024311972*
Добавьте сложение и вычитание в арифметико-логическое устройство (АЛУ).

Инструкции:

[color=#87a8c8]0 И-НЕ(NAND)
1 ИЛИ(OR)
2 И(AND)
3 ИЛИ-НЕ(NOR)
4 СЛОЖ(ADD)
5 ВЫЧ(SUB)[/color]



=== campaign/overture_alu_2/ui.txt ===

$53936374688885* Опкод



=== campaign/overture_conditions/hint_0.txt ===

$30858693828450* Давайте подключим их вместе с шиной

$41615813866999* Никогда и Всегда — самые простые части



=== campaign/overture_conditions/meta.txt ===

$83283206082997* Условия



=== campaign/overture_conditions/test.si ===

$74974087807935* ВСЕГДА

$80507287196650* НИКОГДА



=== campaign/overture_conditions/ui.txt ===

$11886599003881* value

$38979555213581* Описание

$43384041502940* Значение

$81487261104241* Условие



=== campaign/overture_decoder/label.txt ===

$15645900189277* Перенос

$60698949860454* АЛУ

$90597971391617* Непосредственно



=== campaign/overture_decoder/meta.txt ===

$81732613304305* Декодер Инструкций



=== campaign/overture_decoder/test.si ===

$23393810721136* АЛУ

$41856942338650* Условие

$67613074322431* Переслать

$71705253055197* Непосредственно



=== campaign/overture_decoder/ui.txt ===

$35299017249605* Желаемый режим

$55162862394836* Инструкция



=== campaign/preview_architecture/meta.txt ===

$46932595269557* Обзор схем



=== campaign/preview_foundry/meta.txt ===

$78694087261378* Обзор схем



=== campaign/ram_component/hint_0.txt ===

$32597308066943* Прежде всего разместим наши 4 байта памяти на плате



=== campaign/ram_component/hint_1.txt ===

$73686127519870* Затем нужно решить, из какой ячейки памяти загружать / в какую сохранять

$86131527203527* Здесь очень пригодится декодер



=== campaign/ram_component/hint_3.txt ===

$51887730294248* Подключите его, и останется только разрешить нужную ячейку памяти

$65959445914539* Значение для сохранения в ячейку приходит с одного входа



=== campaign/ram_component/label.txt ===

$10655955073336* Загрузить

$46688176903674* Адрес



=== campaign/ram_component/meta.txt ===

$14374127314134* Маленькая Коробочка

$68663841862704*
На этом уровне вам нужно построить схему, 
которая может загружать или сохранять данные в 4 разных байтах памяти.

У вас есть 1 бит, который определяет, нужно ли выполнять загрузку. Ещё один бит определяет, нужно ли выполнять сохранение, и к нему прилагается соответствующее значение.
Кроме того, у вас есть 2 адресных бита. 

С помощью 2 битов существует 4 комбинации — по одной для каждого байта памяти на этом уровне.

[tip]Пробел поворачивает компоненты.[/tip]

$76851096880864* Сможете ли вы разместить 4 байта памяти в этом ограниченном пространстве?



=== campaign/ram_component/test.si ===

$29258463778822* Выход был Z, но должен был быть {expected_value}.

$45179662026844* Выход должен был быть Z.

$48251194975794* Выход был {actual_value}, но должен был быть {expected_value}.

$52597500133853* Сохранить {text_value} к {text_add}

$55086379351729* Загрузить {text_state} из {text_add}



=== campaign/ram_component/ui.txt ===

$22107475451139* [left]Загрузить ??? в ??[/left]

$27304327624610* [color=#E49F44][b]Состояние[/b][/color]

$27457656265551* [color=#E49F44][b]Сохранить [/b][/color]

$57378010777762* [left]Сохранить ??? из ??[/left]

$62207646058430* [color=#E49F44][b]Загрузить [/b][/color]

$62589960113273* [color=#E49F44][b]Адрес[/b][/color]

$71008031461945* [color=#E49F44][b] Значение  [/b][/color]

$85306375920893* [color=#E49F44][b]   Адрес   [/b][/color]



=== campaign/rng/meta.txt ===

$83969937380086* Генератор Случайных Чисел



=== campaign/rng/test.si ===

$77825640575531* Следующее зерно должно быть {result}, а не {output}



=== campaign/sandbox/meta.txt ===

$58382627590046* Песочница



=== campaign/saving_bytes/hint_solution.txt ===

$73980120059844* Мы просто делаем байтовую версию из уровня "Изящное охранение"



=== campaign/saving_bytes/meta.txt ===

$41663630841312* Сохранение Байтов



=== campaign/saving_bytes/test.si ===

$60269032570207* Ожидаемый выход {expected_output}.



=== campaign/saving_gracefully/hint_0.txt ===

$14624167685294* На этом уровне вам понадобится одна линия задержки

$52905927349424* Входами являются 2 входа уровня И выход линии задержки, так как выход участвует в собственном входе

$61760299843073* Рассматривайте вход линии задержки как выход вашей таблицы

$83682732712729* Составьте таблицу истинности для того, что должно поступать в линию задержки

$90057665917240* Как только вы запишете требования уровня в виде таблицы, решить станет намного проще

$90652401745526* Всего у вас 3 «входа» для этой таблицы, что даёт 8 комбинаций



=== campaign/saving_gracefully/hint_1.txt ===

$64973475823722* Единственный компонент, который у нас есть с «памятью», — это линия задержки



=== campaign/saving_gracefully/hint_2.txt ===

$19959785727663* Но если сделать это напрямую, возникнет короткое замыкание



=== campaign/saving_gracefully/hint_solution.txt ===

$10919459809145* Поэтому мы ставим мультиплексор, который решает, какое значение записывать в линию задержки



=== campaign/saving_gracefully/label.txt ===

$88860903896097* Сохранить



=== campaign/saving_gracefully/meta.txt ===

$39874917169400* Изящное Сохранение



=== campaign/saving_gracefully/ui.txt ===

$10654649810679* Сохранить

$63465863198591* Значение



=== campaign/score/hint_0.txt ===

$71529804454649* Сделайте байтовую версию полусумматоров, затем прибавьте Вход и 1



=== campaign/score/hint_solution.txt ===

$50044461577278* Последний результат И(AND) не используется, поэтому его можно спокойно удалить



=== campaign/score/meta.txt ===

$34375498293137* Этот уровень вводит оценку эффективности, которая основана на времени и энергии.

$38383835706006*
Чтобы решить этот уровень, прибавьте 1 к входному числу и выведите результат.

Если результат не помещается в 8 бит, отбросьте старший бит, который не помещается.

Сделайте это не более чем за 40 вентилей и 10 задержки.

$40775045205647*
Стоимость компонентов, которые вы открыли, зависит от вашего счёта в уровнях, где вы их открыли.

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

На самом деле, чтобы пройти этот уровень, ваш вентиль ИСКЛ-ИЛИ(XOR) должен стоить 3 вентиля и иметь задержку 2.

$59781832788691*
Каждый базовый вентиль (И-НЕ(NAND), ИЛИ-НЕ(NOR), И(AND), ИЛИ(OR)) имеет задержку в одну единицу — ему требуется единица времени на выполнение.

Однако разные части схемы могут работать одновременно, поэтому мы ждём только самый медленный путь — «критический путь».

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

$70169388789757*
Эти уравнения равны, но не одинаковы:

((A + B) + C) + D
(A + B) + (C + D)

Они дают один и тот же результат, но параллельность позволяет одному из них быть быстрее другого.

$72877144436007*
Каждый из четырёх базовых вентилей потребляет одну единицу энергии за единицу времени.

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



=== campaign/score/test.si ===

$15039285047182* Выход должен быть {expected}.

$46433606967015* Прибавить 1 к {cycle}



=== campaign/score/ui.txt ===

$85765173996083* Увеличьте вход на 1



=== campaign/signed_negator/hint_0.txt ===

$59964726775903* инвертированием всех его битов (байтовое НЕ(NOT)) и последующим прибавлением единицы

$77523753173621* Отрицание двоичного числа получается



=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* Однако это оставляем вам в качестве упражнения!

$55687805352825* Это решение ни в коем случае не самое изящное или оптимальное



=== campaign/signed_negator/meta.txt ===

$15862778001173*
Воспринимая вход как знаковый (где 8-й бит — это -128), создайте компонент, который берёт число и меняет его знак.
Например, 4 после отрицания станет -4. -9 после отрицания станет 9.

$54237470041206* Знаковый Отрицатель



=== campaign/signed_negator/ui.txt ===

$10529708471093* Вход



=== campaign/sort/meta.txt ===

$23043475637417* На этом уровне ваша задача — отсортировать 16 чисел. Читайте вход 16 раз по одному, отсортируйте их и выведите от наименьшего к наибольшему.



=== campaign/sort/test.si ===

$25018662661467* Индекс {index} в отсортированном списке должен быть {expected}, а не {output}



=== campaign/symphony/test.si ===

$21000091589999* Выход должен был быть {expected_output}, а не {output_value}.

$22469925230320* Адрес постоянной памяти {i} должен иметь значение {expected_value}, а не {value}

$29078414770160* Регистр 'zr' должен всегда быть нулём (адрес 0 в 'Файле регистров').

$60841927788704* Компонент времени не должен был быть разрешён с момента выполнения последней инструкции time_0.

$70740757119887* {register} (адрес {address} в 'Файле регистров') должен иметь шестнадцатеричное значение {expected_value}, а не {actual_value}

$74663212299349* Адрес основной памяти {i} должен иметь значение {expected_value}, а не {value}

$85916420035294* Выход должен был быть разрешён.



=== campaign/symphony_10_stack/meta.txt ===

$29798404581087* Стек



=== campaign/symphony_10_stack/test.si ===

$35910734851012* {expected_value} должен быть на вершине стека, а не {actual_value}.

$77129086767196* Вы не вывели последнее извлечённое значение.



=== campaign/symphony_10_stack/ui.txt ===

$35820332981557* Реализуйте операции стека для Symphony



=== campaign/symphony_11_functions/meta.txt ===

$28617596738571*
Иногда полезно повторно использовать участок кода. Такие участки мы называем «функциями». Чтобы повторно использовать код, нужно перейти в начало функции и вернуться обратно в конце. Переход к функции называется «вызовом» функции, а возврат из функции — «возвратом».

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

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

Представьте, что функция A вызывает функцию B, а B вызывает функцию C. Когда мы хотим вернуться из C, нам нужен только адрес возврата для B, а в B — только адрес для A. В общем случае, независимо от того, как функции вызывают друг друга, последний добавленный адрес возврата всегда будет первым, который нам снова понадобится. Именно так работает стек.

$41513122622358* Функции

$42088257134737* Этот уровень только для того, чтобы вы увидели, как работают функции. Здесь нет тестов. Обязательно прочитайте ассемблерный код и пройдитесь по нему до конца, чтобы понять, как всё работает. Это понадобится в следующих уровнях.

$56028205797304* Поскольку функции, скорее всего, изменяют значения регистров, мы можем захотеть поместить значения в стек для сохранения, а потом извлечь их обратно для восстановления. Неважно, делается это внутри вызванной функции или снаружи, но хорошей практикой считается установить соглашение (так называемое «calling convention»), чтобы все функции были совместимы друг с другом.



=== campaign/symphony_11_functions/new_program.asm ===

$10902022971046* Кроме r1 и r2, функция должна возвращать все регистры в исходном состоянии

$11016773181609* Последний вызов multiply уже поместил результат в r1

$14412657671278* Помещаем r3 и r4 в стек, чтобы можно было использовать их внутри функции, но перед возвратом восстановить прежние значения

$18457350783754* Первый вход — 2

$21553876748933* Аккумулятор

$21707356398727* Загружаем два числа, которые даёт уровень

$27088227324511* Оставшаяся правая часть умножения

$27592840036827* Второй вход — 5

$30769341721428* Левая часть умножения

$32724600358227* Восстанавливаем значение снаружи

$33479507858734* Вычисляем 2 в степени 5

$42717933764735* r1 и r2 используются для аргументов, r1 — результат функции

$42740851915963* Оставшаяся степень

$43461252553161* Соглашение о вызовах:

$59000482794872* Должно вывести 32

$63878589013500* Продолжаем умножать, пока «оставшаяся степень» не станет 0

$65068280556611* Восстанавливаем значения снаружи

$68500361393623* Даём имена регистрам, чтобы было проще читать

$70634976221207* Помещаем r3 в стек, чтобы можно было использовать его внутри функции, но перед возвратом восстановить прежнее значение



=== campaign/symphony_11_functions/ui.txt ===

$51514522389782* Посмотрите, как работают вызовы функций



=== campaign/symphony_12_budget/meta.txt ===

$68182570848466* Задача этого уровня проста: уменьшите задержку Symphony до 175 или ниже. Вернитесь к предыдущим уровням и улучшите свои результаты, если потребуется.

$69806637130600* Быстрый Symphony



=== campaign/symphony_1_nand/meta.txt ===

$36086882016175*

Большинство инструкций принимают 2 аргумента и выдают 1 результат (например, И(ADD), ИЛИ(OR) и т.д.).

[color=#e49f44]Symphony[/color] использует 4 байта на инструкцию и может закодировать все три части в одной инструкции, которая хранится в компоненте ОЗУ под названием «Main Memory». Это значит, что мы можем, например, сложить любые два регистра и сохранить результат в любой другой регистр.

$62556352127349* Лапша Из Проводов

$70083014183793* Наконец пришло время начать строить архитектуру [color=#e49f44]Symphony[/color]!



=== campaign/symphony_1_nand/test.si ===

$35453700742253* Компонент времени не должен был быть разрешён с момента выполнения последней инструкции time_0.

$40674051088628* Настройка экрана 3 должна быть {expected_value}, а не {value}

$55420494010123* Адрес основной памяти {i} должен иметь значение {expected_value}, а не {value}

$56149980430079* Выход должен был быть разрешён.

$68153781027719* Адрес постоянной памяти {i} должен иметь значение {expected_value}, а не {value}

$74043498193765* Выход должен был быть {expected_output}, а не {output_value}.

$81124009043205* Регистр 'zr' должен всегда быть нулём (адрес 0 в 'Файле регистров').

$84654787309709* {register} (адрес {address} в 'Файле регистров') должен иметь шестнадцатеричное значение {expected_value}, а не {actual_value}



=== campaign/symphony_1_nand/ui.txt ===

$21345632528660* Постройте основу архитектуры Symphony



=== campaign/symphony_2_io/hint_solution.txt ===

$34652721020070* Серые провода реализуют режим Ввода/Вывода



=== campaign/symphony_2_io/meta.txt ===

$85119202720349* Ввод-вывод



=== campaign/symphony_2_io/ui.txt ===

$76620689360899* Добавьте режим Ввода/Вывода в Symphony



=== campaign/symphony_3_alu/hint_solution.txt ===

$23277299590423* Замените вентиль И-НЕ(NAND) на компонент АЛУ

$90347458725803* Новые оранжевые провода подают опкод на АЛУ



=== campaign/symphony_3_alu/meta.txt ===

$78613176066303* Интеграция АЛУ



=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* Добавьте АЛУ в Symphony



=== campaign/symphony_4_immediates/hint_solution.txt ===

$61996387838431* Фиолетовые провода реализуют режим непосредственных значений



=== campaign/symphony_4_immediates/meta.txt ===

$46968415562883* Непосредственные Значения

$74993560224545*
Обновите архитектуру, чтобы она выглядела как на этой диаграмме:

[image="symphony_diagram_2.png"]




=== campaign/symphony_4_immediates/ui.txt ===

$90023711394112* Добавьте непосредственные значения в Symphony



=== campaign/symphony_5_jumps/meta.txt ===

$39122914366346* Переходы



=== campaign/symphony_5_jumps/ui.txt ===

$88550064597726* Добавьте переходы в Symphony



=== campaign/symphony_6_ram/hint_solution.txt ===

$78759770178685* Фиолетовые провода реализуют взаимодействие с основной памятью



=== campaign/symphony_6_ram/meta.txt ===

$41276257356528* ОЗУ

$43585926436336* Обратите внимание, что порты работают сверху вниз. Порт загрузки будет читать после порта сохранения, если он расположен ниже, и до — если выше. Это важно, когда порты обращаются к одному и тому же адресу. В общем случае все порты ждут завершения портов сохранения, расположенных выше них. На этом уровне порты загрузки должны находиться выше портов сохранения, иначе возникнет циклическая зависимость.

$69462908463194*
На этом уровне мы добавляем возможность загружать и сохранять данные в то же ОЗУ, которое используется для программы. Мы хотим уметь читать и писать 32-битные слова, 16-битные слова и 8-битные байты, поэтому добавьте 3 дополнительных порта загрузки и 3 порта сохранения к компоненту ОЗУ.

Вставьте новые компоненты портов между портом загрузки «Инструкции» и компонентом ОЗУ «Основная память».



=== campaign/symphony_6_ram/ui.txt ===

$51703376131802* Добавьте инструкции загрузки и сохранения в Symphony



=== campaign/symphony_7_ssd/hint_solution.txt ===

$28652182390799* Новые фиолетовые провода реализуют взаимодействие с постоянной памятью



=== campaign/symphony_7_ssd/meta.txt ===

$76705374584193* Постоянная Память



=== campaign/symphony_7_ssd/ui.txt ===

$89678353617146* Добавьте постоянную память в Symphony



=== campaign/symphony_8_io_devices/default.isa ===

$28545157055801* Помещает %a в стек. Эта инструкция — синоним для:   sub sp, sp, 4   store_32 [sp], %a

$34859363394334* Пересылка значения в %a.

$40508048121543* НЕ(NOT) значения, результат сохраняет в %a.

$48332460366102* Возвращается из последнего вызова функции. Перезаписывает регистр флагов. Эта инструкция — синоним для:   load_32 flags, [sp]   add sp, sp, 4   jmp flags

$54469754973269* Извлекает %a из стека. Эта инструкция — синоним для:   load_32 %a, [sp]   add sp, sp, 4

$55357258069734* НЕ(NOT) над %b, результат сохраняет в %a.

$57504570243305* Вычисляет отрицание значения и сохраняет результат в %a.

$57788320241950* Вызывает %a. Перезаписывает регистр флагов. Эта инструкция — синоним для:   counter flags   add flags, flags, 20   sub sp, sp, 4   store_32 [sp], flags   jmp %a

$72894099288447* Вычисляет отрицание %b и сохраняет результат в %a.



=== campaign/symphony_8_io_devices/hint_solution.txt ===

$48843089545173* Новые серые провода реализуют взаимодействие с устройствами Ввода/Вывода



=== campaign/symphony_8_io_devices/meta.txt ===

$67457044658869*
На этом уровне нужно разместить три новых компонента ввода-вывода: Экран(Screen), Время(Time) и Клавиатура(Keyboard).

Также подключите экран к компоненту ОЗУ с названием «Основная память».



=== campaign/symphony_8_io_devices/new_program.asm ===

$10169473219025* 1 секунда = 1_000_000_000 наносекунд = 0x0000_0000_3B9A_CA00

$11549850182703* координата y

$16841324702501* Робот

$22405816552972* направление

$25470599373421* нарисовать призрака на новой позиции

$25474902303790* увеличить направление

$26430777268618* робот вниз

$28230914387367* монета

$29369794309677* TODO: обрабатывать монету и пустоту по-разному

$31647601023268* Таблица переходов адресов спрайтов

$33327526977497* Призрак

$33450896282702* заглушка

$34042928458359* modulo 3

$35647670060017* пусто

$36791496238134* 2 * длина инструкции = 8

$37230877526029* призрак вправо

$37647180126584* нарисовать робота на новой позиции

$38695844571056* переполнение

$40959483784712* робот вправо

$45301848117435* призрак вниз

$50069163371185* призрак влево

$50501450979711* робот вверх

$55263046326109* удар о стену -> отменить движение

$55673115734516* выравнивание для сохранения 32-битного выравнивания

$61792431057747* координата x

$62236058044269* [выравнивание]

$64851396075477* 2 * размер инструкции = 8

$67744627518982* монета

$69893421560125* робот влево

$72366220861688* призрак вверх

$73803385159414* так что первое значение равно 0

$75937352730902* 0.5 секунды = 500_000_000 наносекунд = 0x0000_0000_1DCD_6500



=== campaign/symphony_8_io_devices/test.si ===

$18975134592059* Выход должен был быть разрешён.

$26871980917450* Адрес постоянной памяти {i} должен иметь значение {address}, а не {value}

$29202969341865* Неверный выход времени (вы не забыли кэшировать время на инструкции time_0?)

$29909286517152* Регистр 'zr' должен всегда быть нулём (адрес 0 в 'Файле регистров').

$30816527015736* Выход должен был быть {expected_output}, а не {output_value}.

$31400969059429* {register} (адрес {address} в 'Файле регистров') должен иметь шестнадцатеричное значение {expected_value}, а не {actual_value}

$42960087865089* Настройка экрана {i} должна быть {expected_value}, а не {value}

$46474751521062* Свяжите экран с компонентом "Основная память" (используйте маленькую красную кнопку в углу экрана).

$78917660933958* Адрес основной памяти {i} должен иметь значение {address}, а не {value}



=== campaign/symphony_8_io_devices/ui.txt ===

$63394282539727* Добавьте инструкции Ввода/Вывода в Symphony



=== campaign/symphony_9_aliases/default.isa ===

$11626177279992* Переход на %a если первое значение было больше (беззнаковое) второго (читая результат из 'flags').

$12835125621741* Сохраняет значение %b в настройке экрана %a.

$13110303123442* Сохраняет %value по адресу %adr в постоянной памяти.

$13576771671264* Логический сдвиг влево %b на %c, результат сохраняет в %a.

$15915531259935* Отправляет %a на выход.

$16685334571248* Логический сдвиг вправо %b на %c, результат сохраняет в %a.

$18254089726214* Отправляет %a на выход.

$19953421010778* Сохраняет %value по адресу %adr в основной памяти.

$23349431010010* Складывает %b и %c, результат сохраняет в %a.

$23396316982953* Загружает значение по адресу %adr из основной памяти и сохраняет его в %dest.

$26183125927881* Переход на %a если первое значение было меньше (беззнаковое) или равно второму (читая результат из 'flags').

$27219499692147* Загружает значение по адресу %adr из основной памяти и сохраняет его в %dest.

$27868418224252* Загружает ввод с клавиатуры и сохраняет его в %a.

$28652904157569* Вычитает %c из %b, результат сохраняет в %a.

$29562677483890* Сохраняет %value по адресу %adr в основной памяти.

$30574433901064* ИЛИ(OR) над %b и %c, результат сохраняет в %a.

$31763492459833* Переход на %a если первое значение было меньше (беззнаковое) второго (читая результат из 'flags').

$37102964808364* Сравнивает %a и %b и сохраняет результат в регистре 'flags'.

$37333076617857* ИЛИ-НЕ(NOR) над %b и %c, результат сохраняет в %a.

$39857449355186* Сохраняет значение %b в настройке экрана %a.

$40732211165530* ИЛИ(OR) над %b и %c, результат сохраняет в %a.

$42626144645228* Арифметический сдвиг вправо %b на %c, результат сохраняет в %a.

$44524771082050* Загружает входное значение и сохраняет его в %a.

$46087142860391* ИЛИ-НЕ(NOR) над %b и %c, результат сохраняет в %a.

$46967848572964* ИСКЛ-ИЛИ(XOR) над %b и %c, результат сохраняет в %a.

$47442552951774* Сохраняет %value по адресу %adr в основной памяти.

$51030225266712* Складывает %b и %c, результат сохраняет в %a.

$53499765587663* Переход на %a если первое значение было больше (знаковое) или равно второму (читая результат из 'flags').

$54565380946620* Сравнивает %a и %b и сохраняет результат в регистре 'flags'.

$54577249258785* Логический сдвиг влево %b на %c, результат сохраняет в %a.

$55551510150818* Арифметический сдвиг вправо %b на %c, результат сохраняет в %a.

$57200935026773* Загружает значение по адресу %adr из основной памяти и сохраняет его в %dest.

$59344052643304* Сохраняет %value по адресу %adr в постоянной памяти.

$61040780958703* Сохраняет %value по адресу %adr в основной памяти.

$66785854415645* ИСКЛ-ИЛИ(XOR) над %b и %c, результат сохраняет в %a.

$67019902294705* Логический сдвиг вправо %b на %c, результат сохраняет в %a.

$67178948469318* Переход на %a если значения были не равны (читая результат из 'flags').

$67376584796076* Загружает значение счётчика и сохраняет его в %a.

$67495552371225* Вычитает %c из %b, результат сохраняет в %a.

$68219187873304* Загружает старшие четыре байта значения времени и сохраняет его в %a.

$69550893885320* Сохраняет %value по адресу %adr в основной памяти.

$69632418904622* Загружает значение по адресу %adr из основной памяти и сохраняет его в %dest.

$71317192057126* Переход на %a если первое значение было больше (знаковое) второго (читая результат из 'flags').

$71637103729391* Переход на %a если первое значение было меньше (знаковое) второго (читая результат из 'flags').

$72280171778920* Загружает значение по адресу %adr из постоянной памяти и сохраняет его в %dest.

$72551400437977* Загружает младшие четыре байта значения времени и сохраняет его в %a.

$73559051740347* Сохраняет %value по адресу %adr в основной памяти.

$74148826866592* Переход на %a.

$75302656449127* И-НЕ(NAND) над %b и %c, результат сохраняет в %a.

$77040234358389* Переход на %a если первое значение было меньше (знаковое) или равно второму (читая результат из 'flags').

$77232719678109* Загружает значение по адресу %adr из основной памяти и сохраняет его в %dest.

$82087388048746* Переход на %a если первое значение было больше (беззнаковое) или равно второму (читая результат из 'flags').

$85679146831122* И(AND) над %b и %c, результат сохраняет в %a.

$85822609095465* Загружает значение по адресу %adr из основной памяти и сохраняет его в %dest.

$86705346481666* И-НЕ(NAND) над %b и %c, результат сохраняет в %a.

$86713121915282* И(AND) над %b и %c, результат сохраняет в %a.

$88180305667389* Переход на %a если значения были равны (читая результат из 'flags').

$88272577071256* Ничего не делает.

$89257021109854* Загружает значение по адресу %adr из постоянной памяти и сохраняет его в %dest.

$90876214388280* Переход на %a.



=== campaign/symphony_9_aliases/label.txt ===

$18099138932731* Постоянная Память

$28246040923235* Файл Регистров

$35059654572638* время

$41903613959902* Основная Память

$79162322081640* клавиатура

$80985404567327* экран



=== campaign/symphony_9_aliases/meta.txt ===

$20456965663323* Псевдонимы Инструкций



=== campaign/symphony_9_aliases/new_program.asm ===

$71972143734450* Шестнадцатеричное значение



=== campaign/symphony_9_aliases/test.si ===

$44683006232656* Первая инструкция должна была переслать шестнадцатеричное значение 0x1235 в r1.

$67087756287234* r3 должен был иметь шестнадцатеричное значение 0x1234

$83123414679662* r2 должен был иметь шестнадцатеричное значение 0xffffedcb.



=== campaign/symphony_9_aliases/ui.txt ===

$13320201556243* Создайте спецификацию ISA для новых инструкций



=== campaign/symphony_alu/meta.txt ===

$52048822283735*
Это копия АЛУ Overture. Пришло время обновить его до 32 бит и добавить несколько новых инструкций.

Инструкции:

[color=#87a8c8]0 И-НЕ(NAND)
1 ИЛИ(OR)
2 И(AND)
3 ИЛИ-НЕ(NOR)
4 СЛОЖ(ADD)
5 ВЫЧ(SUB)
6 ИСКЛ-ИЛИ(XOR)
7 LSL
8 LSR
9 ASR
10 CMP[/color]

Операция cmp — это та, для которой вы уже создали пользовательский компонент на предыдущем уровне.

$71902120982324* АЛУ Symphony



=== campaign/symphony_alu/ui.txt ===

$69427874681706* Реализуйте АЛУ Symphony



=== campaign/symphony_cmp/meta.txt ===

$37729390402296* Флаги Сравнения

$64818361855764*
На этом уровне нужно сравнить два 32-битных входа тремя разными способами. Каждый результат — это 1-битное значение, называемое «флагом».

Флаги:
Установите бит 0 в 1, если входы равны.
Установите бит 1 в 1, если первый вход меньше (беззнаково) второго.
Установите бит 2 в 1, если первый вход меньше (знаково) второго.

Чтобы узнать, как делать 32-битные компоненты, откройте уровень «Счётчик Symphony», если ещё не сделали этого.



=== campaign/symphony_cmp/test.si ===

$55730459238598* Ожидаемый выход: {a}{b}{c}.



=== campaign/symphony_cmp/ui.txt ===

$73310930628112* Реализуйте флаги Symphony



=== campaign/symphony_condition_test/label.txt ===

$13327132168076* Результат

$17010689474441* Условие

$25959617344671* Флаги



=== campaign/symphony_condition_test/meta.txt ===

$90224867995967* Проверка Условия



=== campaign/symphony_condition_test/test.si ===

$33181499064044* Результат никогда не должен быть в Z-состоянии

$73051402798264* Правильный выход — {U1 result}



=== campaign/symphony_counter_1/label.txt ===

$41164574218692* Счёт

$42019997838216* Перезаписать

$48990052180226* Значение



=== campaign/symphony_counter_1/meta.txt ===

$56387381898532* Счётчик Symphony

$76860406179468*
Чтобы изменить ширину слова компонента, используйте инструмент «Размер бита» в левой панели (выглядит как двунаправленная стрелка с числом).

Правой кнопкой мыши по инструменту «Размер бита» задайте целевую ширину.
Левой кнопкой мыши по компонентам при активном инструменте установите ширину компонента.
Новые размещаемые компоненты слова будут иметь эту ширину по умолчанию.



=== campaign/symphony_counter_1/test.si ===

$54301125260332* Память должна быть {expected_memory}, а не {memory_value}

$84451713761977* Выход должен быть {expected_memory}



=== campaign/symphony_decoder/label.txt ===

$16402377924132* Это непосредственное

$24747841106265* Аргумент B

$26207217884026* Опкод

$26325060783055* Аргумент A

$40584554497383* Непосредственное значение

$48212238534381* Инструкция

$48506758479060* Режим

$67128656777473* Назначение



=== campaign/symphony_decoder/meta.txt ===

$13883461694525* Декодер Инструкций

$41138026161536*
Используйте компонент статического индексатора для решения этого уровня.

Компонент статического индексатора — это специальный компонент, который позволяет сдвигать определённые биты провода без какой-либо задержки или стоимости вентилей. Изменяя число на компоненте, вы сдвигаете биты (положительное число сдвигает вправо). Затем нажмите на компонент, чтобы задать ширину выхода.



=== campaign/symphony_decoder/test.si ===

$15174125339458* Опкод должен быть {opcode}, а не {actual_opcode}.

$31544476297744* Назначение должно быть {dest}.

$31942264008156* Аргумент B должен быть {b}.

$45701446129480* Непосредственное значение должно быть {immediate_value}.

$63089562267538* 'Является непосредственным' должно быть {immediate}.

$64926808682290* Режим должен быть {mode}.

$82638458430252* Аргумент A должен быть {a}.



=== campaign/symphony_decoder/ui.txt ===

$51036929729507* Реализуйте декодер Symphony



=== campaign/the_bus/hint_0.txt ===

$42863588667057* Используйте переключатели, чтобы поместить входы на один провод



=== campaign/the_bus/hint_1.txt ===

$88955803760495* Выбор входа — это просто мультиплексор



=== campaign/the_bus/hint_solution.txt ===

$55189990966587* Подправьте мультиплексор так, чтобы он делил входной провод, а не выходной, для выборочного вывода

$86286155471986* Фиолетовый провод посередине — это ШИНА



=== campaign/the_bus/label.txt ===

$25477689162292* Выбор выхода

$25535487507842* А

$43340511034957* Выбор входа

$43474590938240* Y

$47236089523392* X

$65041743851294* Б



=== campaign/the_bus/meta.txt ===

$10949534274977* Шина



=== campaign/the_bus/test.si ===

$28173496384607* Выход Y должен быть {val}.

$46672500255781* Выход X должен быть Z.

$65293894030728* Выход X должен быть {val}.

$69214136994673* Переслать значение из {source} в {destination}

$75577618213381* Выход Y должен быть Z.



=== campaign/the_bus/ui.txt ===

$31341803878224* Создайте цепь, которая передаёт значение с указанного входа на указанный выход.



=== campaign/tower/meta.txt ===

$23374750315066* В игре «Ханойская Башня» нужно переместить стопку дисков с одного колышка на другой. Сложность в том, что за один ход можно перемещать только один диск, только самый верхний диск на стопке и никогда нельзя класть больший диск на меньший.

$29450953142176* Ханойская Башня



=== campaign/tower/ui.txt ===

$39419617008574* Ой, вы положили больший диск на меньший!



=== campaign/xnor/hint_0.txt ===

$89305883777750* Обратите внимание, что выход вентиля ИСКЛ-ИЛИ-НЕ — это точная противоположность выхода вентиля ИСКЛ-ИЛИ?



=== campaign/xnor/meta.txt ===

$29396170535219* Постройте инверсию вентиля ИСКЛ-ИЛИ, которая называется ИСКЛ-ИЛИ-НЕ(XNOR).

$50956872142719* Вентиль ИСКЛ-ИЛИ-НЕ(XNOR)



=== campaign/xor_gate/hint_0.txt ===

$15534865654723* Вход 0

$17025412277453* Вход 1

$59092390409834* Желаемый выход



=== campaign/xor_gate/hint_solution.txt ===

$16623524168613* Но это мы оставляем в качестве упражнения для игрока!

$30671593085518* Это решение далеко не самое элегантное и оптимальное



=== campaign/xor_gate/label.txt ===

$22122562689406* Выход

$45326245069696* Вход



=== campaign/xor_gate/meta.txt ===

$21287008524643* Вентиль ИСКЛ-ИЛИ(XOR)



=== campaign/xor_gate/ui.txt ===

$38271404408184* Текущий выход



=== model/board/custom_prototype.nim ===


# Default new output pin name for custom compoennts
$14864122622568* Выход


# Default new input pin name for custom compoennts
$14951951489108* Вход



=== model/board/prototype_list.nim ===


# com_mux's output pin
$10003014068713* Выход


# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* Входы


# com_concatenator_8's input pin
$10080083255838* Слово 3


# com_clz's output pin
$10092537578053* Результат


# com_splitter_bit_4's output pin
$10111764008386* Бит 2


# com_level_output_4_pin's name
$10190739202646* Выход


# com_ctz's description
$10231593934948* Подсчёт нулей от младшего бита до первой 1


# com_xor_word's output pin
$10269927015049* Результат


# com_static_indexer_config's name
$10289043699917* Автоматический статический индексатор


# com_lsr's input pin
$10335381544532* Сдвиг на


# com_halt's name
$10351143139905* Остановка


# com_nand_word's input pin
$10425218359878* Вход 0


# com_splitter_bit_8's description
$10488114435022* Разбивает байт на 8 бит


# com_splitter_bit_8's output pin
$10491931394044* Бит 3


# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* Вв/Выв


# com_probe_wire_bit's input pin
$10499689720024* Значение


# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* Разработка


# com_splitter_bit_4's name
$10524104374521* Разветвитель


# com_cc_output's name
$10557704838301* Выходной пин


# com_segment_display's name
$10582128204153* 7-сегментный индикатор


# com_switch_word's name
$10611658692685* Переключатель


# com_xnor_bit's description
$10614106399129*
[T] когда входы одинаковые


# com_not_word's description
$10624873506476* Побитовое инвертирование


# com_counter's output pin
$10629272823895* Счёт


# com_splitter_bit_2's output pin
$10655485270988* Бит 0


# com_splitter_bit_8's output pin
$10688845521356* Бит 1


# com_level_input_3_pin's name
$10689623552857* Вход


# com_maker_bit_8's input pin
$10716205698752* Бит 5


# com_decoder_3's input pin
$10755367544042* Вход


# com_delay_line_word_config's output pin
$10757852071445* Результат


# com_rol's input pin
$10762061266647* Значение


# com_decoder_2's output pin
$10762093809413* Бит 1


# com_nor_word's input pin
$10770218762282* Вход 0


# com_concatenator_2's description
$10776829749898* Объединяет две шины в одну, ширина выходной шины равна сумме всех входных.


# com_cc_output's description
$10781578424003* Выходной пин


# com_ror's description
$10802217509530* Прокручивает биты входа направо


# com_add's output pin
$10815269647822* Перенос


# com_not_bit's description
$10844421681709*
Инвертирует вход


# com_nand_word's description
$10859914201083* Побитовое И-НЕ(NAND) двух значений


# com_full_adder's output pin
$10918445419498* Результат


# com_static_value's output pin
$10920459933396* Значение


# com_mod's description
$10934212906097* Остаток от деления 2 чисел


# com_level_input_word's name
$10943344093513* Вход


# com_keyboard's name
$10965596602414* Клавиатура


# com_less_s's output pin
$11019209691112* Результат


# com_asr's name
$11034107377099* Арифметический сдвиг вправо


# com_maker_word_2's description
$11048127331082* Объединяет n-значений в одно


# com_register_word_config's input pin
$11057152094224* Размер


# com_concatenator_8's input pin
$11115698874478* Слово 0


# com_maker_bit_4's name
$11119510732154* Соединитель


# com_nand_bit's name
$11130919681688* И-НЕ(NAND)


# com_static_indexer_config's output pin
$11132082500971* Результат


# com_mux's description
$11168613697835* Выбирает из двух 8 битных значение


# com_full_adder's input pin
$11264799740288* Вход 0


# com_level_input_switched's name
$11278573510238* Переключаемый вход


# com_not_word's name
$11286216680410* НЕ(NOT) 


# com_maker_word_2's output pin
$11293966912554* Результат


# com_decoder_2's output pin
$11297026031742* Бит 2


# com_level_output_word's name
$11300749636961* Выход


# com_full_adder's input pin
$11312161634667* Вход 1


# com_delay_line_word_config's late input pin
$11320392055125* Вход


# com_mod's output pin
$11329013865174* Результат


# com_or_word's input pin
$11335506036805* Вход 1


# com_level_input_word's description
$11342065742485* Словесный вход


# com_splitter_word_4's output pin
$11345730126879* Слово 0


# com_static_indexer_config's input pin
$11349557191063* Вход


# com_maker_word_8's output pin
$11351867388170* Результат


# com_mod's input pin
$11352468367638* Делимое


# com_concatenator_8's input pin
$11366501215506* Слово 2


# com_level_gate's name
$11417416554850* Компонент уровня


# com_splitter_word_8's input pin
$11440186157356* Вход


# com_level_input_4_pin's name
$11447837612693* Вход


# com_inc's description
$11449663590476* Увеличивает вход на 1


# com_splitter_word_8's output pin
$11465347976002* Слово 3


# com_level_output_switched's input pin
$11520072088720* Разрешить


# com_asr's output pin
$11521973612539* Результат


# com_splitter_bit_8's output pin
$11548514728473* Бит 0


# com_switch_bit's name
$11574334638147* Переключатель


# com_nand_word's input pin
$11578787451669* Вход 1


# com_div's input pin
$11611913368782* Делитель


# com_switch_word's output pin
$11625195403324* Выход


# com_maker_bit_8's input pin
$11634467729625* Бит 4


# com_neg's input pin
$11637742665554* Вход


# com_clz's name
$11678932883790* Подсчёт ведущих нулей


# com_ram's name
$11710093917097* ОЗУ


# com_decoder_2's name
$11727998752868* Двухбитный декодер


# com_maker_bit_2's input pin
$11752209410617* Бит 1


# com_and_word's description
$11791872137683* Побитовое И(AND) двух значений


# com_mul's output pin
$11838813794006* Результат


# com_off's name
$11860786587357* ВЫКЛ


# com_splitter_bit_8's name
$11904470559153* Разветвитель


# com_nor_word's output pin
$11938328576163* Результат


# com_delay_line_bit's output pin
$11945697622944* Результат


# com_and_word's input pin
$11977039914327* Вход 0


# com_neg's description
$12021716182809* Инвертирует вход


# com_splitter_bit_2's input pin
$12046095993506* Вход


# com_screen's name
$12046117430308* Экран


# com_cc_level_output's description
$12051024347384* Словесный выход, который преобразуется в пин ввода-вывода при сохранении уровня как компонента


# com_splitter_bit_4's input pin
$12060097589370* Вход


# com_xnor_word's name
$12087865653212* ИСКЛ-ИЛИ-НЕ(XNOR)


# com_ror's name
$12093087039542* Циклический сдвиг вправо


# com_delay_line_bit's name
$12121899638400* Линия задержки


# com_nor_word's name
$12175906806727* НЕ-ИЛИ(NOR)


# com_neg's output pin
$12196354295621* Результат


# com_level_output_1_pin's name
$12242923444593* Выход


# com_level_output_counter's name
$12247325526438* Счётчик


# com_maker_word_4's output pin
$12262460678043* Результат


# com_probe_memory_bit's name
$12318534735397* Пробник памяти (бит)


# com_concatenator_2's input pin
$12329350771997* Провод 2


# com_concatenator_8's input pin
$12341255296823* Слово 1


# com_verilog_output's name
$12353364840899* Verilog-выход


# com_probe_wire_asm's late input pin
$12365938365321* Вход


# com_splitter_word_4's description
$12370556827575* Разбивает значение на n частей


# com_concatenator_4's input pin
$12371272172145* Слово 1


# com_concatenator_8's input pin
$12384635971036* Слово 5


# com_decoder_3's output pin
$12390018918095* Бит 7


# com_asr's input pin
$12408847893200* Сдвиг на


# com_register_word's late input pin
$12420839132846* Сохранить значение


# com_constant's description
$12424468899005* Константа


# com_keyboard's output pin
$12465282633818* Значение ключа


# com_level_input_1_pin's output pin
$12465938629713* Вход


# com_concatenator_8's output pin
$12478474747295* Результат


# com_probe_memory_word's description
$12492235992906* Отображает значение на пользовательском компоненте или в редакторе программы


# com_mux's input pin
$12520768681157* Значение 1


# com_switch_word's input pin
$12550214308917* Значение


# com_maker_word_8's input pin
$12592072659210* Слово 1


# com_maker_bit_2's name
$12602955212919* Соединитель


# com_maker_word_8's input pin
$12616927929524* Слово 3


# com_static_indexer_config's input pin
$12633414511976* Размер


# com_delay_line_word's late input pin
$12644592179746* Вход


# com_register_bit's name
$12678278048629* Регистр


# com_mux's input pin
$12687047365426* Значение 0


# com_and_bit's description
$12719674432950*
[T] когда оба входа [T]


# com_splitter_word_2's name
$12723870092766* Разветвитель


# com_level_input_1_pin's name
$12746117288689* Вход


# com_off's description
$12749460799924* Всегда [F]


# com_less_s's description
$12765625016236* Проверяет, меньше ли первый вход второго


# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* Биты


# com_switch_word's input pin
$12784430582183* Разрешить


# com_lsl's input pin
$12849468178655* Значение


# com_static_indexer_config's input pin
$12869119410565* Сдвиг


# com_nand_bit's description
$12903183841172*
[T] если не оба входа [T]


# com_and_word's name
$12926911335769* И(AND)


# com_lsr's name
$12931148241340* Сдвиг вправо


# com_splitter_word_4's input pin
$12938882109013* Вход


# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* Дисплеи


# com_halt's description
$12990744955549* Останавливает выполнение с пользовательским сообщением


# com_or_bit's description
$13013154620359*
[T] когда хотя бы один вход [T]


# com_level_output_8_pin's name
$13087193858087* Выход


# com_maker_bit_8's input pin
$13104890311933* Бит 1


# com_rol's input pin
$13135722015590* Поворот на


# com_decoder_3's output pin
$13138546420646* Бит 6


# com_store_port's name
$13159020985209* Порт хранения


# com_level_output_3_pin's description
$13174121812559* Трёхбитный выход


# com_maker_word_4's input pin
$13236424504117* Слово 2


# com_xor_word's description
$13236921580268* Побитовое ИСКЛ-ИЛИ(XOR) двух значений


# com_level_output_2_pin's name
$13255344581755* Выход


# com_level_gate's description
$13259215761047* Используется для создания карт уровней


# com_cc_input's description
$13263310288543* Входной пин


# com_delay_line_word_config's input pin
$13271299225650* Размер


# com_level_input_1_pin's description
$13272198916233* Однобитный вход


# com_register_word's late input pin
$13298317818150* Разрешено сохранение


# com_concatenator_4's input pin
$13331778821779* Слово 0


# com_verilog_input's output pin
$13351141217116* Вход


# com_nor_bit's name
$13375115196253* НЕ-ИЛИ(NOR)


# com_maker_word_8's input pin
$13378739117488* Слово 6


# com_less_u's name
$13502755965496* Меньше < (беззнаковое)


# com_splitter_word_2's output pin
$13510688527850* Слово 1


# com_ror's input pin
$13521735131997* Поворот на


# com_register_word's description
$13576980017857* Маленький компонент памяти


# com_splitter_word_2's output pin
$13625849577132* Слово 0


# com_splitter_bit_8's output pin
$13666042416530* Бит 2


# com_keyboard's output pin
$13705122401876* Ожидание события


# com_splitter_bit_2's name
$13766521376720* Разветвитель


# com_maker_bit_4's input pin
$13826250945595* Бит 3


# com_ctz's input pin
$13829181406158* Вход


# com_equal's input pin
$13859686951415* Вход 0


# com_add's name
$13973952772642* Сложение


# com_xnor_bit's name
$14079327237795* ИСКЛ-ИЛИ-НЕ(XNOR)


# com_lsl's output pin
$14132199132916* Результат


# com_less_u's input pin
$14201184715010* Вход 0


# com_maker_bit_4's input pin
$14237744302250* Бит 0


# com_keyboard's output pin
$14338437722935* Клавиша нажата


# com_maker_bit_8's description
$14338505460996* Объединяет 8 бит в 1 байт


# com_level_input_2_pin's description
$14340334686746* Двухбитный вход


# com_decoder_3's name
$14375716460090* 3-битный декодер


# com_verilog_input's description
$14408471620057* Verilog-вход


# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* Канал


# com_probe_wire_word's name
$14427436420428* Пробник провода


# com_not_bit's name
$14453052824732* НЕ(NOT)


# com_inc's name
$14456039381703* Инкремент


# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* Verilog


# com_nor_word's description
$14517798310461* Побитовое НЕ-ИЛИ(NOR) двух значений


# com_maker_bit_2's description
$14531866237078* Объединяет два бита в одно 2-битное значение


# com_splitter_word_8's output pin
$14592399073683* Слово 7


# com_splitter_bit_4's output pin
$14645527447275* Бит 0


# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* ОЗУ


# com_decoder_3's output pin
$14688114733776* Бит 5


# com_maker_bit_8's input pin
$14770992007366* Бит 6


# com_maker_word_2's name
$14812135740513* Соединитель слова


# com_xor_bit's name
$14832952840086* ИСКЛ-ИЛИ(XOR)


# com_register_bit's output pin
$14834136969633* Результат


# com_maker_bit_2's input pin
$14834270613682* Бит 0


# com_segment_display's input pin
$14849689592952* Значение


# com_maker_bit_4's input pin
$14852108377004* Бит 2


# com_level_output_2_pin's description
$14875690243444* Двухбитный выход


# com_maker_bit_8's output pin
$14889574903079* Результат


# com_mul's input pin
$14896244080868* Вход 0


# com_mul's input pin
$14913258317738* Вход 1


# com_probe_wire_word's input pin
$14914933156268* Значение


# com_level_input_switched's input pin
$14935676453720* Разрешить


# com_maker_bit_8's input pin
$14944669923906* Бит 7


# com_div's name
$14959426271423* Деление


# com_verilog_output's description
$14973155280765* Verilog-выход


# com_less_u's output pin
$15024221028085* Результат


# com_mux's input pin
$15091015683874* Выбор 0 / 1


# com_asr's description
$15194709458499* Сдвигает биты вправо с сохранением знака числа


# com_probe_wire_bit's description
$15206117280094* Отображает значение на пользовательском компоненте или в редакторе программы


# com_splitter_word_8's description
$15228522216068* Разбивает 8n-битное значение на n-бит


# com_maker_word_4's input pin
$15232070727738* Слово 1


# com_lsl's name
$15268915597774* Сдвиг влево


# com_inc's output pin
$15310910823919* Результат


# com_splitter_word_4's output pin
$15360783001914* Слово 2


# com_less_s's name
$15403981009644* Меньше < (знаковое)


# com_maker_word_4's description
$15410415450178* Объединяет 4 (n/4)-бит значений, в одно n-битое


# com_splitter_word_2's description
$15417695246232* Разбивает 2n-битное значение на два n-битных


# com_mux's name
$15422378975821* Мультиплексор


# com_less_s's input pin
$15432695156488* Вход 0


# com_decoder_3's output pin
$15527856774069* Бит 2


# com_rol's description
$15557725551789* Циклически сдвигает биты входа влево


# com_splitter_word_4's output pin
$15566912320742* Слово 1


# com_cc_level_output's name
$15625973306519* Выход


# com_not_word's output pin
$15635980858172* Результат


# com_level_output_8_pin's input pin
$15649241608462* Выход 6


# com_equal's description
$15668435514829* Проверяет равенство двух входов


# com_maker_word_4's input pin
$15693531522415* Слово 0


# com_splitter_bit_4's output pin
$15744234453408* Бит 3


# com_concatenator_8's input pin
$15759275278695* Слово 4


# com_ror's input pin
$15762072154176* Значение


# com_xnor_word's description
$15789912406647* Побитовое ИСКЛ-ИЛИ-НЕ(XNOR) двух значений


# com_static_value's output pin
$15833633678405* Размер слова


# com_constant's name
$15858905835416* Константа


# com_on's name
$15896157427528* ВКЛ


# com_decoder_2's output pin
$15898724303882* Бит 3


# com_or_word's input pin
$15962339721851* Вход 0


# com_probe_wire_word's description
$15969687819995* Отображает значение на пользовательском компоненте или в редакторе программы


# com_clz's input pin
$15988469904002* Вход


# com_register_word's name
$16007777261800* Регистр


# com_time's name
$16011300295966* Время


# com_splitter_word_4's output pin
$16099286786157* Слово 3


# com_static_indexer's description
$16103423834548* Сдвигает значение на фиксированное количество без задержки или стоимости вентилей. Положительные — вправо, отрицательные — влево


# com_lsr's input pin
$16105779236896* Значение


# com_less_s's input pin
$16118461327893* Вход 1


# com_splitter_word_8's output pin
$16120663256468* Слово 4


# com_level_output_word's description
$16148744080822* Выход слова(WORD), который будет преобразован в ВВ(IO)-пин, если решение уровня сохраняется как компонент


# com_maker_word_2's input pin
$16178897760565* Слово 1


# com_splitter_bit_8's input pin
$16196769003341* Вход


# com_on's description
$16212935718484* Всегда [T]


# com_mod's name
$16223673009720* Остаток


# com_level_output_4_pin's input pin
$16259545926196* Выход 0


# com_ror's output pin
$16261916666444* Результат


# com_level_output_3_pin's name
$16269858195218* Выход


# com_static_eval's name
$16294314784377* Статический вычислитель


# com_less_u's input pin
$16307028951926* Вход 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* Логика


# com_load_port's name
$16380513614754* Порт загрузки


# com_counter's late input pin
$16380665909610* Перезапись


# com_load_port's description
$16440979564796* Добавить дополнительный пин загрузки к компоненту памяти


# com_concatenator_4's output pin
$16450922709110* Результат


# com_lsl's description
$16482114876737* Сдвигает биты входа влево


# com_mul's name
$16549841656852* Умножение


# com_add's output pin
$16559516323162* Результат


# com_splitter_word_4's name
$16563671560208* Разветвитель


# com_level_input_3_pin's description
$16604606953092* Трёхбитный вход


# com_maker_word_4's name
$16610055905190* Соединитель слова


# com_decoder_3's output pin
$16637198920534* Бит 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* Выходы


# com_xor_word's input pin
$16674052164634* Вход 0


# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* Свои


# com_decoder_1's description
$16685462633615* Переключает между двумя выходами


# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* Уровни


# com_rol's name
$16755142829250* Циклический сдвиг влево


# com_segment_display's description
$16761198694928* Хорошо подходит для отображения чисел


# com_keyboard's description
$16766452660421* Записывает нажатия физической клавиатуры


# com_decoder_3's input pin
$16773243310913* Запретить


# com_level_input_switched's description
$16797889673362* Загружает вход с уровня


# com_and_word's output pin
$16806711173957* Результат


# com_cc_level_input's name
$16810631435170* Вход


# com_xor_word's name
$16843812162355* ИСКЛ-ИЛИ(XOR)


# com_xor_bit's description
$16856280609387*
[T] когда входы разные


# com_level_input_2_pin's name
$16870364449392* Вход


# com_static_eval's description
$16874064281189* Вычисляет значение до симуляции (становится константой во время симуляции)


# com_probe_memory_bit's description
$16875362121056* Отображает значение на пользовательском компоненте или в редакторе программы


# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* Байты


# com_switch_bit's description
$16917313833836* Инвертирует бит


# com_cc_level_output's input pin
$17030391013189* Выход


# com_splitter_bit_8's output pin
$17053062486634* Бит 4


# com_or_word's name
$17053670145576* ИЛИ(OR) 


# com_xnor_word's output pin
$17089816656649* Результат


# com_decoder_3's output pin
$17090003684860* Бит 4


# com_splitter_bit_8's output pin
$17163920171569* Бит 6


# com_static_value's name
$17192199509688* Статическое значение


# com_mod's input pin
$17244932190980* Делитель


# com_or_bit's name
$17247779246257* ИЛИ(OR)


# com_splitter_bit_2's output pin
$17293853955838* Бит 1


# com_switch_word's description
$17345192339084* Переключает значение


# com_delay_line_word's name
$17407828844862* Линия задержки


# com_splitter_word_8's output pin
$17425893786880* Слово 6


# com_nor_bit's description
$17510848535619*
[T] когда ни один из входов не [T]


# com_maker_bit_8's input pin
$17515061804367* Бит 0


# com_full_adder's description
$17559382166174* Складывает 3 бита и выводит сумму и перенос


# com_maker_word_8's name
$17581447274882* Соединитель слова


# com_register_word_config's name
$17630501850089* Автоматический регистр


# com_level_output_3_pin's input pin
$17644027370563* Выход 2


# com_splitter_bit_8's output pin
$17664445405251* Бит 5


# com_full_adder's name
$17669928463861* Полный сумматор


# com_register_bit's description
$17670626909848* 1 бит памяти


# com_maker_word_4's input pin
$17742753106024* Слово 3


# com_register_bit's late input pin
$17744526831576* Разрешить


# com_concatenator_2's output pin
$17758165407719* Результат


# com_counter's late input pin
$17764401720104* Перезаписать значение


# com_equal's input pin
$17767800149691* Вход 1


# com_static_value's description
$17781742628050* Удобная настройка значений или ширины отдельных пользовательских компонентов


# com_add's input pin
$17802619460312* Перенос


# com_cc_input's name
$17814826739168* Входной пин


# com_add's input pin
$17820183531095* Вход 0


# com_equal's output pin
$17864898529357* Результат


# com_store_port's input pin
$17908666907710* Сохранить значение


# com_concatenator_8's input pin
$17908668221433* Слово 7


# com_maker_bit_8's input pin
$17957417956069* Бит 3


# com_level_output_switched's input pin
$17979647868788* Выход


# com_load_port's output pin
$17988237627670* Выход


# com_nand_word's name
$17989404583269* И-НЕ(NAND)


# com_store_port's input pin
$18001316449428* Адрес


# com_counter's name
$18007194288764* Счётчик


# com_splitter_word_8's name
$18008204445107* Разветвитель


# com_add's input pin
$18009367936916* Вход 1


# com_div's input pin
$18043895181775* Делимое


# com_maker_bit_2's output pin
$18060429242565* Результат


# com_probe_wire_asm's late input pin
$18082830776248* Адрес


# com_not_word's input pin
$18100827224098* Вход


# com_and_word's input pin
$18149321315676* Вход 1


# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* Ввод-Вывод


# com_keyboard's input pin
$18168295822085* Прочитать следующий


# com_store_port's input pin
$18196820862263* Разрешить


# com_decoder_3's output pin
$18208851966397* Бит 3


# com_decoder_1's name
$18250587600120* Однобитный декодер


# com_level_output_2_pin's input pin
$18282543476901* Выход 0


# com_level_output_4_pin's description
$18308856504509* Четырёхбитный выход


# com_level_output_switched's description
$18319747827404* Переключаемый выход


# com_level_output_1_pin's description
$18342586404936* Однобитный выход


# com_maker_word_2's input pin
$18365137610205* Слово 0


# com_neg's name
$18379907297327* Инвертировать


# com_load_port's input pin
$18399493738021* Разрешить


# com_register_bit's late input pin
$18405644304073* Значение


# com_full_adder's output pin
$18410639135888* Перенос


# com_concatenator_2's input pin
$18414950181373* Шина 1


# com_splitter_word_8's output pin
$18425501753807* Слово 0


# com_add's description
$18429814030509* Складывает два входа


# com_splitter_bit_8's output pin
$18437214963047* Бит 7


# com_full_adder's input pin
$18480011054605* Перенос на вход


# com_probe_memory_word's name
$18495107507052* Пробник памяти


# com_time's output pin
$18510923212418* Наносекунды с 1 января 1970


# com_maker_bit_4's output pin
$18538545767544* Результат


# com_splitter_word_8's output pin
$18541722201520* Слово 2


# com_asr's input pin
$18563543025377* Значение


# com_register_word_config's late input pin
$18592599175225* Сохранить значение


# com_or_word's output pin
$18599325743999* Результат


# com_nand_word's output pin
$18604301487974* Результат


# com_mul's description
$18631919890554* Умножает два входа


# com_less_u's description
$18645721548287* Проверяет, меньше ли первый вход второго


# com_maker_word_8's input pin
$18747558269936* Слово 7


# com_maker_bit_8's name
$18747779812970* Соединитель


# com_time's description
$18774996925434* Наносекунды с 1 января 1970


# com_clz's description
$18865460617183* Подсчёт нулей от старшего бита до первой 1


# com_and_bit's name
$18912167455465* И(AND)


# com_concatenator_4's input pin
$18970466583796* Слово 2


# com_level_output_counter's description
$19047791955795* Трёхбитный выход


# com_maker_word_8's input pin
$19068496076705* Слово 2


# com_load_port's input pin
$19069820293504* Адрес


# com_concatenator_8's input pin
$19112189486457* Слово 6


# com_lsl's input pin
$19120200575252* Сдвиг на


# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* Пробы


# com_level_input_4_pin's description
$19187328896214* Четырёхбитный вход


# com_register_word_config's description
$19209488297941* Автоматически изменяемая версия регистра


# com_maker_bit_8's input pin
$19209724501083* Бит 2


# com_ctz's name
$19218324472471* Подсчёт последовательности нулей


# com_splitter_word_8's output pin
$19229992367375* Слово 5


# com_div's description
$19251828025705* Разделить 2 числа


# com_verilog_output's input pin
$19276197821142* Вход


# com_concatenator_4's input pin
$19277763516215* Слово 3


# com_nor_word's input pin
$19354802063529* Вход 1


# com_equal's name
$19369982838671* Равно


# com_lsr's description
$19394421220436* Сдвигает биты входа вправо


# com_div's output pin
$19403575811053* Результат


# com_or_word's description
$19406015796751* Побитово OR два значения


# com_delay_line_word_config's name
$19421095581293* Автоматическая линии задержки


# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* Матем


# com_level_output_switched's name
$19513138880387* Переключаемый выход


# com_probe_wire_bit's name
$19521764791439* Пробник провода (бит)


# com_maker_word_8's input pin
$19579002124406* Слово 4


# com_inc's input pin
$19579388993928* Вход


# com_xnor_word's input pin
$19579585753615* Вход 1


# com_or_3_bit's name
$19630419947500* 3-пиновый ИЛИ(OR)


# com_splitter_word_2's input pin
$19630801846451* Вход


# com_and_3_bit's name
$19664974941910* 3-х контактный AND


# com_register_word_config's late input pin
$19717901345023* Сохранение с разрешением


# com_xor_word's input pin
$19719622211817* Вход 1


# com_lsr's output pin
$19748092068880* Результат


# com_maker_word_8's input pin
$19779691531031* Слово 5


# com_verilog_input's name
$19796166910463* Verilog-вход


# com_static_indexer's name
$19804933576629* Статический индексатор


# com_ram's description
$19814732518166* Большой компонент памяти


# com_cc_level_input's description
$19864966939331* Вход, который будет преобразован в пользовательский вход, если решение будет сохранено в Мастерскую


# com_ctz's output pin
$19883191600386* Результат


# com_splitter_word_8's output pin
$19903808503639* Слово 1


# com_rol's output pin
$19903955254861* Результат


# com_screen's description
$19974317694842* Настраиваемый экран


# com_level_output_3_pin's input pin
$21084166025569* Выход 1


# com_level_input_word's output pin
$21448308897245* Вход


# com_level_input_2_pin's output pin
$24473197268827* Вход 0


# com_level_output_word's input pin
$27680966493404* Выход


# com_level_output_4_pin's input pin
$29217965518477* Выход 1


# com_static_eval's output pin
$29937009351190* Результат как размер


# com_level_input_4_pin's output pin
$36196915566111* Вход 3


# com_level_output_8_pin's input pin
$38015555977208* Выход 3


# com_level_output_4_pin's input pin
$39260627694444* Выход 3


# com_level_output_8_pin's input pin
$39299381405096* Выход 0


# com_level_output_3_pin's input pin
$39908016538045* Выход 0


# com_delay_line_word's output pin
$40182352594863* Результат


# com_level_output_8_pin's description
$41781588125341* Четырёхбитный выход


# com_level_input_3_pin's output pin
$42291627335021* Вход 2


# com_delay_line_bit's late input pin
$43397945955203* Вход


# com_level_output_2_pin's input pin
$44555908976270* Выход 1


# com_level_input_4_pin's output pin
$45891070331034* Вход 1


# com_level_output_1_pin's input pin
$50802766489958* Выход


# com_screen's input pin
$55023356915123* Установка индекса


# com_level_input_2_pin's output pin
$55925432534232* Вход 1


# com_register_word's output pin
$58518173140953* Значение


# com_cc_level_input's output pin
$59388037506003* Вход


# com_decoder_3's description
$61176454433312* Переключает между восемью выходами на основе 3-битного входного пина


# com_level_output_8_pin's input pin
$62385154489080* Выход 2


# com_screen's input pin
$63216408139965* Разрешить


# com_level_output_8_pin's input pin
$64999131838438* Выход 4


# com_level_input_3_pin's output pin
$65765566466116* Вход 0


# com_level_input_switched's output pin
$69212597107829* Вход


# com_level_input_4_pin's output pin
$70142958857584* Вход 2


# com_level_output_8_pin's input pin
$72375982885383* Выход 1


# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* Авто


# com_level_input_3_pin's output pin
$79311371309532* Вход 1


# com_level_input_4_pin's output pin
$81933801309767* Вход 0


# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* Прочее


# com_level_output_counter's input pin
$84023157447564* Выход 0


# com_register_word_config's output pin
$84598344098990* значение


# com_static_indexer_config's description
$85065774878853* Продвинутая версия "статического индексатора". Сдвиг и размер вывода определяются автоматически по количеству подключённых проводов ко входам


# com_level_output_counter's input pin
$86331851878040* Выход 1


# com_decoder_2's description
$86848277190736* Переключает между четырьмя выходами на основе 2-битного входного пина


# com_level_output_4_pin's input pin
$87954408093587* Выход 2


# com_screen's input pin
$88137790657923* Значение


# com_level_output_8_pin's input pin
$88250281919265* Выход 5


# com_static_eval's output pin
$89594489498667* Результат как значение


# com_level_output_counter's input pin
$89669851602178* Выход 2


# com_level_output_8_pin's input pin
$90233476470983* Выход 7



=== model/isa_spec/assemble.nim ===

$12097260550100* Значение {num} вне диапазона для {field}

$15585581119466* Инструкция '{instruction_name}' не имеет определения битового поля

$15728875852508* Не удалось разобрать {file}

$18981788561705* Здесь ожидается пробел

$19131785861372* Рекурсивное включение:

$19581803133960* Ожидается '{syntax}' после '{partial_instruction}'

$21828993759952* Неизвестная инструкция

$23413102374088* Недопустимая инструкция

$30066682696902* Утверждение {source} не совпало

$33085034295813* Ожидается число или символ

$35071857261934* Ожидается пробел после 'as'

$35210741057769* Непонятное содержимое в этой строке

$37770431994640* Недопустимая инструкция

$39195841380612* Метка {name} уже объявлена

$42442531119863* {constant_name} уже объявлена

$45433710484419* Ожидается размер перед числом, например: U64 {number}

$47300717145684* Пропущен '=' после 'const'

$51460031660101* Не удалось собрать инструкцию при разрешении метки {name}: {err}

$53378617686677* Значение {num} вне диапазона для {field}

$57794055991905* Ошибка при вычислении утверждения {assertion}: {err}

$59248806788382* Нельзя ссылаться на приватную метку {name}

$60515742509356* Ожидается число после объявления размера

$60631582636278* Неопределённая метка {name}

$62050046600010* Имя файла {name} нельзя использовать как ссылочный псевдоним. Объявите другой псевдоним с помощью ключевого слова 'as', например: 'include .A as A'

$66273157704409* Здесь пропущен операнд '{field_type}'

$66575346967082* Файл не существует:

$67922577781529* Пока поддерживаются только положительные числа, кратные 8 битам

$68530592279217* Ожидается допустимое имя операнда, получено '{operand_name}' среди {all_operand_names}

$69537550553443* Ожидается хотя бы один пробельный символ после '{partial_instruction}'

$71714150108621* Ошибка при вычислении операнда %{operand_name}: {err}

$76017808702292* Ширина инструкции '{instruction_name}' составляет {width} бит, но поддерживаются только значения, кратные 8

$79977943868423* '{field_string}' не является '{field_type}'

$80097289956044* Ожидается пробел между размером и числом, например U{size} {number}

$82512572175623* Неожиданный конец инструкции после {partial_instruction}

$83023561541280* Здесь ожидается имя метки

$83649060120708* Знаковые числа не поддерживаются

$84557608492963* После инструкции обнаружен неизвестный код:

$86607635528717* Неопределённая константа {field_string}

$90294506138532* Значение определения должно быть числом или полем



=== model/isa_spec/expressions.nim ===

$14037712136328* Операнд {op} не найден

$15525193700799* Нераспознанный префиксный оператор 

$16677833364088* Нераспознанный идентификатор: %{operand}

$17795651801484* Ожидалось ':'

$18996202754936* Ожидалось ')'

$21791372106633* Ожидалось '('

$36919792698704* Указатель инструкции недоступен

$49919016022369* Нераспознанный адрес: ${identifier}

$50863314907270* Ожидалось ')'

$62520916869207* Ожидалось ','

$76203559781109* Ожидалось ']' или ':', получено '{sep}'

$86940018019179* Недопустимый идентификатор: %{operand}



=== model/isa_spec/isa_spec.nim ===

$11703098452145* Неизвестное имя настройки {name}

$11824708197936* Ожидалось допустимое имя поля или паттерна, получено '{operand_name}'

$15904571494199* Ожидался синтаксис среза после ссылки на поле или паттерн в битовой схеме

$16564670893367* Здесь ожидалось имя паттерна

$18304638469397* Ожидалась непустая строка для начала однострочных комментариев

$19678805612580* Ссылки на повторяющиеся поля не совпадают

$20574862674671* Ожидался перевод строки после виртуального поля

$20981379307111* Фиксированные биты в %{operand} не совпадают

$24713798894610* Верхняя граница не должна превышать 32767

$25123045290962* Здесь ожидался заголовок [instructions]

$25249187420360* Ожидалось имя параметра или начало следующего раздела

$25285447732570* Верхняя граница не должна быть меньше нижней

$26426549472884* Слишком много виртуальных операндов

$27111936748508* Ожидалась закрывающая скобка после типа паттерна

$28197258085607* Ожидался синтаксис среза после ссылки на поле или паттерн в битовой схеме

$29837913233106* Ожидался перевод строки между инструкциями

$31223930569837* Верхняя граница не должна быть меньше нижней

$32763965727763* Биты расширения знака не совпадают

$33105996916812* Паттерны могут вызывать только те, которые определены до них

$33504435568130* Не удалось интерпретировать виртуальный операнд %{variable_name}: {err}

$33645913580119* Слишком много типов полей, разрешено не более {max_field_types}

$33890983338825* Ожидался список строк

$35053289858864* Слишком много паттернов, разрешено не более {max_patterns}

$35468867558322* Ожидался перевод строки после заголовка раздела

$39427635035157* Дублирующаяся настройка '{name}'

$40392382190976* Ожидалась битовая схема для {field_name}

$40815956642962* Ожидался синтаксис среза после ссылки на шестнадцатеричное число в битовой схеме

$45267257140327* Ожидался перевод строки после заголовка раздела

$45631078896174* Верхняя граница не должна превышать 32767

$48321097736953* Шестнадцатеричное число не должно превышать 32767 цифр

$48942522553057* Ожидался синтаксис среза после ссылки на поле или паттерн в битовой схеме

$50971737349470* Операнды паттернов пока не поддерживаются в дизассемблировании

$51752498682665* Имя поля '{field_name}' не определено

$52261961290701* Перевёрнутый синтаксис среза после ссылки на шестнадцатеричное число в битовой схеме

$52710717731997* Здесь ожидался перевод строки после объявления синтаксиса

$55289908013299* Виртуальный операнд {variable_name} закрывает другой операнд в строке синтаксиса

$55444523984237* Ожидалась закрывающая скобка после типа поля

$55537815420873* Ожидалось ',' или ')' после аргумента паттерна

$55929094649794* Ожидалась таблица строк

$57773886232356* Ожидалось имя для типа поля

$58295598661589* Описание в паттернах должно быть пустым

$59115040206693* Ожидалась непустая строка для начала блочных комментариев

$59388744207582* Здесь ожидался перевод строки в конце битовой схемы

$62103010038950* Ожидался перевод строки после заголовка раздела

$62334191081955* Ожидался синтаксис среза после ссылки на шестнадцатеричное число в битовой схеме

$62712568576067* Дублирующееся имя типа поля: {name}

$63072912015761* Ожидался перевод строки перед телом паттерна

$63246722572594* Ожидался синтаксис среза после ссылки на поле в битовой схеме

$63957561177031* Паттерн '{pattern_name}' с {argument_count} параметрами не определён

$64093416909416* Ожидался идентификатор после '%'

$67219559926029* Имена полей не могут содержать пробельные символы

$67707174963301* Ожидался идентификатор после '%'

$68533544457789* Операнд {variable_name} в строке синтаксиса затеняет другой операнд

$68587613470552* Ожидалось имя значения поля

$70205284263092* Ожидалась непустая строка для завершения блочных комментариев

$70814401439344* Верхняя граница не должна быть меньше нижней

$72400465574342* Поддерживаются только длины полей до {max_field_width} бит

$72620639818015* Ожидался перевод строки после заголовка раздела

$72958581072457* Ожидалось имя для паттерна

$75146029145419* Ожидалось имя для параметра паттерна

$76494975412451* Ожидалось допустимое имя операнда, получено '{operand_name}' среди {all_operand_names}

$77234329031993* Ожидался синтаксис среза после ссылки на поле или паттерн в битовой схеме

$77449878176461* Ожидался идентификатор после '%'

$77851254343918* Ни один операнд не начинается с символа '{c}'.

$78591996283483* Здесь ожидалось имя поля или sized immediate

$79195048703101* Здесь ожидалось '='

$79975911393070* Ожидался синтаксис среза после ссылки на поле или паттерн в битовой схеме

$81691406697268* Ожидалась верхняя граница в синтаксисе среза после ссылки на поле в битовой схеме

$82876816015252* Слишком много путей опций операнда для автоматического дизассемблирования, разрешено не более {num_path}

$83804207975330* Верхняя граница не должна превышать 32767

$85972591916322* Ожидался перевод строки после присваивания настройки

$87843223218582* Ширина инструкции {width} бит, но поддерживаются только кратные 8



=== model/isa_spec/parse.nim ===

$10198498286711* Незавершённая escape-последовательность

$11064758781325* Ожидалось '"', ''' или '`' в начале содержимого ячейки таблицы UI

$12492443144951* Ожидалось ',' или конец таблицы

$13040813748160* Ожидался ключ

$19807940646400* Ожидалось одно из {expected}, получено {actual}

$22378976352410* Строка {num}: 

$22452670489981* Ожидался числовой литерал

$25983481845150* Ожидалось '{symbol}', получен EOF

$27682737127628* Ожидалась открывающая кавычка (одна из ", ' или `)

$29112746104375* Здесь ожидалось bool-значение.

$33400766069212* Ожидалась открывающая скобка (одна из '(', '[' или '{{'), получено '{open}'

$33551107641907* Целочисленный литерал слишком большой

$36313699368590* Недопустимая восьмеричная escape-последовательность

$43326454052643* Здесь ожидалось U для беззнакового или S для знакового

$44942745729831* Недопустимая шестнадцатеричная escape-последовательность

$49180229055343* Ожидалось значение

$51855228989260* Недопустимый литерал беззнакового целого

$56457570130031* Недопустимый символ escape '{nc}'

$64926004981217* Недопустимый целочисленный литерал

$66187706284192* Ожидалось ':' после ключа

$71666516845083* Ожидался беззнаковый числовой литерал

$72110029133381* Ожидалось {prefix}

$73113688099439* Ожидалось одно из {expected}

$73973243772156* Ожидался знаковый числовой литерал

$75565287060042* Неожиданный EOF при разборе строки

$77089554485217* Здесь ожидалось объявление размера

$82386938622647* Ожидался какой-либо символ после символа escape '\\'



=== model/isa_spec/types.nim ===

$12246885387560* переменная {name}


# Assembly label
$17885987456433* метка(label)

$18299156828551* знаковое {n}-битное непосредственное значение

$74639900282369* беззнаковое {n}-битное непосредственное значение



=== model/translations.nim ===


# Million
$22896492410578* М


# Billion
$71072134093858* Г


# Thousand
$84696693690500* К



=== presenter/board_ui.nim ===

$36331525379247* Сохранить схему



=== presenter/board_ui/bottom_panel.nim ===

$55369640789869* Кликните в любом месте поля, чтобы начать провод\nСоедините красные компоненты с вентилем И-НЕ(NAND).

$79416009887091* Кликните в любом месте поля, чтобы разместить элемент

$86840165316981* Правая кнопка — отменить выбор элемента



=== presenter/board_ui/bottom_panel/circular_dependency.nim ===

$13880985462901* Создайте цепь, в которой Вход компонента зависит от его собственного Вывода

$16336401898647* ТЕСТ 1 из 2

$22446480186064* Создайте циклическую зависимость минимум из 2 компонентов

$32314337981189* Проверить

$73467991035922* Нет!

$89309211963063* Тест 2/2



=== presenter/board_ui/bottom_panel/component_description.nim ===

$10634456248075* Вход 1

$10792411581963* {size} МБ

$10967837475411* Вход 1

$12673774208656* Бит 1

$12729457392140* {size} ГБ

$12806857886815* Бит 0

$12955769263032* Вход

$13973719570693* Размер

$14527438551030* Вход

$14913356525578* Цена

$16406822661708* Вход

$17231618567710* Начальные данные

$18430168550669* Результат

$23494294864855* Мин. {unit}

$23854618911893* Дополнительная задержка

$24632471752785* Файл

$26116781897961* Цена

$27295540163510* Вход 1

$30447216087962* Сдвиг

$31208530565026* Вход 0

$32492998000365* Вход 0


# com_static_eval's expression
$32721727081818* Выражение

$34792822299047* Вход 1

$36741466396909* Вход 2

$39848783424235* Вход

$40353371905977* Константа


# Load a level
$41294322771286* Загрузить

$45584048068675* Вход 1

$47647445869837* Нули

$48920514303805* Мастерская

$49848147518867* Вход 2

$50011261574308* Вход 1

$50488075986026* Выход

$52764622766005* Выход

$53201813578269* Ассемблер

$55717355371460* Выход

$56555605872372* Выход

$58366024847549* Вход 0

$58805963760936* Положительные значения сдвигают вправо, отрицательные — влево

$59987930153159* Выход

$60193172250813* Выбранная вами настройка этого компонента займёт {size} памяти на вашем компьютере. Вы согласны с этим?

$61114700325299* Вход 0

$64034551286307* Постоянная

$64695289448271* 8 бит значения включают по одной из 8 областей дисплея.

$65186041856822* Выход

$65254105186908* Выход

$69729205667293* Hex Редактор

$70002762618597* Вниз

$71918065858983* Сохранить

$75293122338496* Глубина конвейера

$76078010638637* Разрешить

$76120552154698* Вход 0

$76125262162505* Вход 1

$77252050278971* Выход

$78475032277779* Вход 0

$80252365204151* Перфокарта

$81678588906692* Сообщение при остановке

$82521178851608* Вход 0

$84542005958715* Метка

$85815999713437* Вход 1

$86658255589213* Изменяемые данные

$88655619989708* Вход 0

$88881918807029* Неизменяемый

$89612128414294* Направление метки

$90286330794518* Выход

$91063734228931* Влево

$95419083709418* Обратный порядок байтов (Little endian)

$95766090310621* Право

$97169317610794* Вверх



=== presenter/board_ui/bottom_panel/introduction.nim ===

$24027424800887* Следующий уровень

$70403032472607* Отлично! Переходим к следующему уровню.



=== presenter/board_ui/bottom_panel/nand_gate.nim ===

$32982011047799* Проверить

$43078933051174* Кликните на любую серую кнопку в последней строке таблицы.

$61241226128494* Попробуйте ещё раз!

$71204033550134* Что делает вентиль И-НЕ(NAND)?



=== presenter/board_ui/bottom_panel/racer_question.nim ===

$95509904060545* Отправить



=== presenter/board_ui/bottom_panel/solution_warning.nim ===

$21618236951146* Посмотреть решение

$65770257567603* Если вы уверены, что хотите увидеть решение, нажмите кнопку ниже.



=== presenter/board_ui/bottom_panel/user_defined_ui.nim ===

$10446152707984* Адрес

$20074247151096* Инструкция

$41540713506719* Инструкция

$64281970848639* Описание



=== presenter/board_ui/common.nim ===

$10463931654475* Вход 0

$14057674753878* Вход 1

$58374689721038* БАЙТЫ

$73841752788709* Вход

$74796974148718* Выход



=== presenter/board_ui/component_menu/flat_list.nim ===

$70994998239232* Нажмите на И-НЕ(NAND), чтобы выбрать его



=== presenter/board_ui/cycle_info.nim ===

$18403698792036* Тип уровня

$41662660252584* Курсор

$53456282160464* Режим песочницы

$72245209470436* FPS

$74564675939961* Скор. симул.

$99534264629442* Тест



=== presenter/board_ui/file_explorer.nim ===


# Placeholder on the name input field of the file explorer
$18871898542185* Новый каталог

$56429258960561* Переименовать

$69090690657232* Клонировать


# Load a schematic
$70369485875359* Загрузка


# Placeholder on the name input field of the file explorer
$84870575118100* Новый элемент

$91861509153454* Удалить



=== presenter/board_ui/function_icons.nim ===

$39440928972984* Сброс ({key})

$42454393978813* Нажмите, чтобы запустить тесты

$53448014080434* Удалить (Правый Клик)

$54853798559740* Быстрый запуск ({key}) (правая кнопка: изменить скорость)

$66405942066048* Предыдущий

$68617247634978* Размер слова (правая кнопка: изменить размер)

$69987793052607* Комментарий (Клик по проводу)

$78287906849040* Цвет Провода

$80451578314373* Увеличить масштаб

$84434122873489* Уменьшить масштаб

$85147529532131* Множественный выбор (SHIFT и перетащите)



=== presenter/board_ui/io_state_view.nim ===


# MEMORY section title on the left panel
$13690653984793* ВЫХОДЫ


# MEMORY section title on the left panel
$34156015279634* ПАМЯТЬ


# INPUTS section title on the left panel
$64033841051521* ВХОДЫ



=== presenter/board_ui/menu_bar.nim ===

$11731996208080* Мастерская

$30516879701896* Песочница

$33761197388580* Показать подсказки

$38557550573896* Диалог уровня

$50924073287410* Переключить формат чисел

$56916384895438* Главное меню

$71951682957395* Карта уровней

$79554853897000* Сменить схему

$85248932172256* Скрыть подсказки

$85430022417382* Показать задержку

$91515053618360* Справочник

$98930461722118* Возврат к уровню



=== presenter/board_ui/menu_bar_campaign.nim ===

$68227209887733* Мастерская


# Placeholder for the search bar in the level tree
$72813322690589* Поиск уровня



=== presenter/board_ui/popup/address_jumper.nim ===


# OK button on popups
$26766209496460* OK

$36265530817755* Перейти на адрес

$40263691211335* смещение в байтах (16, 0xF, ...)



=== presenter/board_ui/popup/assembler_watchee_linker.nim ===

$37885763626223* Ссылки ОЗУ

$51331074553774* Сколько регистров

$67225915898937* Префикс

$67275059688693* Размер

$77103446544344* Пример: reg_

$77741358519166* Количество



=== presenter/board_ui/popup/dialogue/info.nim ===

$52150443679969* Продолжить

$89787506720574* Закрыть



=== presenter/board_ui/popup/dialogue/unlock.nim ===

$10090938799865*
[large]Ручной ввод[/large]
Страница: [color=#68d277]{page}[/color]

$14047403461014* Энергия (вентиль x время)

$16820079067437* Уровень пройден

$20801641140962*

[b]Режим карты уровня[/b]
[color=#cccccc]Нажмите «[color=#e49f44]Далее[/color]», и вы увидите[/color]

$26794262854382* Отменить

$32133561664335* Сохранить оба

$33922330743421*

[b]Цвет провода[/b]
[color=#cccccc]Организуйте провода с помощью цветов.[/color]

$40510295620397* Перезаписать

$41649402437253*

[b]Отрицательные числа[/b]
[color=#cccccc]Переключение между знаковыми 
и беззнаковыми числами[/color]

$43591599177045* Энергия (Вентиль x Задержка)

$44038153424304* Сохранение с именем "{save}" уже существует

$45250062735373* Разблокировано

$51096427131653* Дальше

$53037516781370* Конфликт сохранений: 

$53389567901907* Пользовательский компонент с именем "{comp}" уже существует


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$58769207148712* Компонент

$65428404547905* Статистика


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$69219742310717* Архитектура

$69511102367948* Тип

$76805548224716* Общий размер ОЗУ слишком большой! Это решение не будет оценено на сервере.

$78783902500954*

[b]Онлайн-профиль[/b]
[color=#cccccc]Находится в главном меню.[/color]

$84923734370936* Худший тест


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$90134890578411* Разное

$92313038380926* Уровень

$92673421413755*

[b]Комментарии к проводам[/b]
[color=#cccccc]Добавить комментарии к проводам.[/color]

$94261690850981*

[b]Шестнадцатеричный вид[/b]
[color=#cccccc]Переключение между знаковым, беззнаковым и hex-форматом[/color]



=== presenter/board_ui/popup/ide/editor.nim ===

$11967666262990* Ошибка в спецификации! Откройте редактор спецификации, чтобы исправить

$13400106910274* Линия {nr}: {msg}


# IDE tab name
$88520918982355* Регистры



=== presenter/board_ui/popup/ide/file_browser.nim ===

$63693638857058* Содержит {folders} каталогов.

$66107456188362* Содержит {folders} каталогов и {asm} файлов .asm.

$86093358515620* Это пустой каталог.

$93027749509988* Содержит {asm} файлов .asm.



=== presenter/board_ui/popup/ide/watcher_list.nim ===

$12944436882589* Добавить регистр



=== presenter/board_ui/popup/instruction_overture.nim ===

$10141348037745* Непосредственно: {nr}

$10366913897135* Кликните, чтобы переключить биты

$14831276667273* Инструкции


# The text above the 3 LSBs
$25145891843959* Всегда

$26521666422399* Посчитать

$31185395052385* ВЫВОД


# The text above the 3 LSBs
$39935096343723* Никогда

$41846451178700* Переслать в {to} из {from}

$53665446068319* НЕИСП

$54909668901048* Непосредственно

$81322935207536* ВХОД

$89294533225655* {operation} [color=#DD6576][bold]REG 1[/bold][/color] и [color=#DD6576][bold]REG 2[/bold][/color]

$92046368194170* Условие

$98983752580592* Скопировать



=== presenter/board_ui/popup/schematic_browser/file_browser.nim ===

$14436541903929* Архитектуры: {list}

$17985924005596* Содержит {nr} схем.

$38011567415872* Каталог пуст

$51791491383290* Пользовательский компонент используется в

$57790786178566* Пользовательские компоненты: {list}

$66392158413243* Вы действительно хотите удалить "{file_name}"?

$68586106474430* Примечание: все уровни архитектуры используют общие сохранения, поэтому это будет удалено для всех уровней!

$89354977462546* Нет



=== presenter/board_ui/popup/schematic_browser/item_description.nim ===

$15827374884671* В родительский каталог

$19184997172542* Используется в архитектурах

$23950941073542* Имя

$32598300339944* <Поделиться как новая схема>

$32645745463577* Используется в компонентах

$34084132835354* Виден в меню

$36200352866864* Последнее изменение

$38755675398147* Использовать WOR

$54460367152653* Поделиться

$62604042376934* Экспорт

$74184088067843* Выбрать

$84344684205464* Путь

$87138477300432* BBCode, с отключёнными [image] и [link]

$87579936985765* Согласиться использовать лицензию [link=`CC0`]CC0[/link]

$95386916091656* Описание



=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* Определить размер из входа

$61685569269160* Автоматически

$70256730895162* Статическое значение



=== presenter/board_ui/popup/wire_comment_editor.nim ===

$36027984716180* Комментарий к проводу



=== presenter/board_ui/racer_question.nim ===

$11176073682097* Как будет {number} в двоичном представлении?

$13872783467999* Как будет {number} в знаковом двоичном представлении?

$19099025738142* Старт

$23959994711260* Готовы к гонке?

$37093663674348* Уровень {x}

$41793938939207* Время вышло

$45532697833519* Вы достигли уровня {level}!

$56999237564848* Осталось {x} секунд

$92057009138253* Как будет {number} в шестнадцатеричном представлении?



=== presenter/console.nim ===

$63321577947087* Нажмите Ввод для документации



=== presenter/level_tree_ui.nim ===

$19508086025944* ПРОГРАММИРОВАНИЕ 2

$35696974632265* Цвет линий уровня

$38100016313511* АРХИТЕКТУРА ЦПУ 2

$38843517090942* РАБОТАЮЩИЙ КОМПЬЮТЕР

$44937904689376* ПРОГРАММИРОВАНИЕ

$51337598329530* АРИФМЕТИКА

$65362728703588* ПАМЯТЬ

$75049509201775* БУЛЕВА ЛОГИКА

$81337533438394* Завершено

$81707212583931* Доступно

$87420015169370* НЕОБЯЗАТЕЛЬНЫЕ УРОВНИ КОМПОНЕНТОВ

$95146987030704* Заблокировано

$95559333192525* АРХИТЕКТУРА ЦПУ



=== presenter/main_menu_ui/credits_page.nim ===

$15872341864658*

Искренняя благодарность:

[b]Переводчики[/b]
{translators}

[b]Первые бета-тестеры[/b]
{beta_testers}

[b]Работа со шрифтами[/b]
{font_work}

[b]Музыка[/b]
{soundtrack}

$21717110565858* Титры



=== presenter/main_menu_ui/home_page.nim ===

$12639868461113* Выйти

$13921098180953* Галерея схем

$15234594767991* Титры

$16857608955464* Песочница

$32835651830157* Профиль

$49251062339706* Настройки

$66967233942803* Кампания



=== presenter/main_menu_ui/hub/description.nim ===


# The hub schematic size
$15762392983604* Размер:

$22639280459994* Загрузка списка...

$44524092309946* Загрузка...


# To download hub schematics
$55983490912314* Загрузить

$61693098943939* Продолжить


# To delete hub schematics
$62589392744014* Удалить


# To confirm deleting hub schematics
$66333328482057* Вы уверены?


# The hub author
$71812400203030* От:

$76747661573536* Да

$76770986264566* Поиск

$84668607423763* Для загрузки необходимо отключить ограничение длины пути в Windows. При нажатии «Продолжить» появится всплывающее окно с просьбой подтвердить отключение. Ограничения пути — это устаревшая настройка в Windows, и нет причин оставлять её включённой.

$90731554079332* Схемы не найдены



=== presenter/main_menu_ui/hub/filter.nim ===

$23829497228009* Тип

$25536941657464* Компоненты

$43488408276984* Популярные

$56045953383535* Архитектуры

$70134513915163* Новые

$77788981567936* Уровни

$83319579232915* Сортировать по

$87115430626073* Мои загрузки



=== presenter/main_menu_ui/options/control_tab.nim ===

$15032124477918* Цвет провода 4

$20313704155593* Цвет провода 6

$21380256293472* Выделить всё

$33884219481037* Двигаться вправо

$36372993787575* Цвет провода 1

$50610605761210* Вернуть

$52159578521318* Вставить

$53266310714298* Управление

$55156524671891* Цвет провода 5

$58334563411624* Отменить

$58442122157391* Окрасить провод

$60118970740682* Запуск

$64529333110609* Цвет провода 7

$66251711975517* Цвет провода 9

$67362258372706* Окрасить кластер проводов

$74309706297402* Копировать

$76995246992803* Цвет провода 10

$77819900580235* Цвет провода 2

$78515694621006* Двигаться влево

$78673220868687* Цвет провода 8

$78777350869870* Нажмите новую клавишу

$80031998727851* Двигаться вверх

$83373647697807* Цвет провода 3

$87273391208106* Цвет провода 0

$88236351843942* Повернуть

$88238310953306* Вырезать

$93140495547084* Двигаться вниз

$96339976117958* Пипетка для провода

$96449970906640* Добавить комментарий к проводу

$96601731563408* Открыть консоль



=== presenter/main_menu_ui/options/general_tab.nim ===

$12034378482152* Подтвердить сброс?

$13442839894535* Скорость анимации

$15557473522933* Сброс

$21908594290225* Общее

$23270083417453* Отмена

$24145565754506* Громкость эффектов

$30910326565868* Язык

$49806848871093* Режим для дальтоников

$54328660964287* Оконный режим

$55047615798435* Режим без таймера 

$61172959716558* Путь до каталога сохранения

$67420270098223* Полный сброс

$70994568832660* Удалить всё

$71208664264770*

Это удалит все решения уровней, пользовательские компоненты и архитектуры.
Действие НЕЛЬЗЯ отменить.
Вы уверены, что хотите это сделать?
Игра закроется, сброс произойдёт при следующем запуске.

$93981778736076* Громкость музыки

$95307230990123* Режим Verilog



=== presenter/main_menu_ui/options/page.nim ===

$36195388998735* Общее



=== presenter/markup/markup.nim ===

$66207112287034* ЗАМЕТКА



=== presenter/update_state_common.nim ===

$13327741293223* Вход {nr}

$29169064199243* Выход {nr}

$43118901497406* Задержка

$70170261551278* Энергия

$95192766583497* Вентили



=== presenter/update_state_stream.nim ===

$12823129240050* Нажмите кнопку в верхнем левом углу, чтобы связать экран


# Text on keyboard component
$41639816417947* Записывать при запуске


# Text on keyboard component
$61909856780806* Идёт запись


# Text on keyboard component
$73297471730751* Не записывается



=== presenter/user_input/board_io/action/none.nim ===

$10186190492148* ALT + клик — переместить начало провода

$22780831606716* Загрузить файл

$26085882338208* Редактировать перфокарту

$38481453712356* Редактировать память

$64854367750357* Открыть в hex редакторе

$80005228759908* Значение здесь: 

$98772447663910* Связать компоненты



=== presenter/utilities.nim ===


# Switched Output is the name under 19513138880387
$12249248261034* Вы не можете решить этот уровень без добавления компонента «Переключаемый выход»

$12256736989028* У вас больше одного пробника в одной клетке.

$14665712485657* Этот пользовательский компонент не может быть использован так как у него нет площади.

$15549447390000* Несколько компонентов входа/выхода находятся в одном квадрате. Этот компонент невозможно будет использовать, так как два подключения не могут быть в одном месте.

$18997072674417* <Component> не разблокирован на этом уровне.

$25337574230078* Два пина находятся на одной и той же клетке.

$27322222841583* Короткое замыкание между <> и <>

$29718660090112* Неправильный ответ.

$32087108522443* Размерные пины могут соединяться только с другими размерными пинами

$44947135063289* Циклическая зависимость — выход компонента возвращается на его же вход. См. «Циклическая зависимость» в руководстве.

$45545544521085* Компонент <component> находится в недопустимой позиции.

$45678915971282* Короткое замыкание внутри <этого> пользовательского компонента.

$47880883686501* Циклическая зависимость — выход компонента возвращается на его же вход. См. «Циклическая зависимость» в руководстве.

$48909199348313* Тесты пройдены, но ваше решение использует больше задержки, чем {max_delay}

$51730362111148* <This custom component> использует компонент {name}, который не разблокирован на этом уровне.

$56798729463813* Код уровня сломан.

$73948669941805* Тесты пройдены, но ваше решение использует больше вентилей, чем {max_gates}


# Switched Input is the name under 11278573510238
$95056157627313* Вы не можете решить этот уровень без добавления компонента «Переключаемый вход»



=== presenter/utilities/helper_functions.nim ===


# Fallback for component name on the left panel
$11467644007149* Счётчик {nr}


# Fallback for component name on the left panel
$11980538317261* Память


# Fallback for component name on the left panel
$19471584538385* Вход

$25272818268849*

[b]ИТОГИ[/b]

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

$37319690622142* Хорошая работа, вы дошли до {current_level}-го уровня.


# Fallback for component name on the left panel
$41936481068702* Счётчик


# Fallback for component name on the left panel
$42012207828907* Регистр


# Fallback for component name on the left panel
$44820775847452* Выход

$87016829502381* Хорошая работа, вы достигли уровня {current_level}.

