Russian.txt

=== components/Output 1 ===

$59663530139004* 1 Bit Output


=== trans/panel_program_1_output ===

$31398283096964* Выход


=== rpg/maps/overworld/kligara ===

$78685013556649*
Моя работа - смотреть на
топливные штучки для реактора


=== rpg/maps/overworld/control_panel ===

$94056033073339*
The captain will throw me 
off the ship if I touch this
$20128423531070* Control panel


=== trans/level_registers_description ===

$73800316874022* [center]Создайте схему соответствующую спецификациям кодов[/center]


=== rpg/maps/overworld/water ===

$82402577990931* Вода


=== trans/panel_stack_output ===

$61988314265407* Выход


=== components/Output1Car ===

$12896765714603* Перенос


=== components/FullAdder ===

$57559382166174* Суммирует 3 бита. Выводит сумму и перенос.
$77669928463861* Полный сумматор


=== trans/panel_car_output_0 ===

$21449898267446* Carry:


=== misc/options ===

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


=== misc/io_label_change ===

$50497979766012* Label text


=== misc/ide_delete_program ===

$87279416580516* Да


=== levels/turing_complete ===

$15326252036920* До сих пор только код влиял на память, теперь память должна влиять на код. С добавлением условной логики, наш компьютер теперь может выполнить любой алгоритм и вычислить всё что вычислимо.
$16583885726240* Да, ты это сделал! Я думал ты был всего лишь странно выглядящей лысой обезьяной, но ты построил настоящий компьютер! Замечательно!
$10510746154639* На 1-ом такте программа должна загрузить адрес 1.
$10317244906317* Программа не найдена.
$14587485007736* До этого момента все программы ограничивались выполнением байт за байтом.
$19649119273248*
Последняя вещь которую нам нужно добавить это механизм для изменения текущего значения счётчика через [INSTRUCTIONS] когда определённые условия были достигнуты.

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

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

Эти условия соответствуют компоненту условий который был сохранён в завод компонентов.


=== rpg/maps/prison/snuffles ===

$38415939620256* Гав гав
$58496270566737* Snuffles
$97846640630713* Кровь
$18282167453919* Poor old Snuffles


=== rpg/maps/unseen_fruit/wall_broke ===

$82933036983558* Damaged wall


=== levels/Second Tick ===

$14355963067874* Выведите [ON] только на втором такте.
$17526582195506* Как вы помните, все эти испытания должны завершиться созданием работающего компьютера.
$15726318553190* Это единственная причина, по которой мы Вас до сих пор не сожрали.
$19277843280528*
 [color=#b72d41][b]Подсказка:[/b][/color]
 Двойное нажатие на компонент позволяет 
 перемещать его вместе с соединениями.
$15296208528991* Существа, которые смогут завершить создание компьютера, по закону считаются разумными.


=== trans/manual_text_console ===

$39093856809104*
Компонент Консоль это экран 80х24 [color=#dd6576][url=RGB color]ASCII[/url][/color] символов. Он должен быть подключен к памяти через соединение компонента:
 [img=200]dialogue/manual/Console/link_state.png[/img]

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

У консоли также есть цветной режим, который можно включить на панели:
[img=125]dialogue/manual/Console/color_mode.png[/img]

В этом режиме у каждого символа есть 3 байта фона и 3 байта переднего плана [color=#dd6576][url=RGB color]RGB цвета[/url][/color], итого 7 байтов данных на каждый символ. Однако, каждый символ выравнен по 8-и байтам, что удобнее когда вы выставляете ваше ОЗУ или ПЗУ на 64-битную адресацию. Вы также можете не менять индексы ваших символов когда меняете консоль с бесцветного режима на цветной, если вы при этом меняете ОЗУ или ПЗУ с 8 на 64 бита. 

В цветном режиме, младший байт это символ, следующие 3 байта — цвет шрифта, а следующие 3 байта — цвет фона.


=== trans/panel_lessu_description ===

$10492822526537* [center]Check if Input 1 < Input 2[/center]


=== levels/component_factory ===

$14665712485657* Этот кастомный компонент не может быть использован так как у него нет площади.
$17077079648771* Компоненты могут быть добавлены, убраны или переименованы с помощью системы сохранений этого уровня.
$19551383617326*
Добро пожаловать на завод компонентов, схемы которые создаются здесь могут использоваться как компоненты в архитектурных уровнях.
Схема созданного вами компонента определяет его функционал, а планировка определяет форму.
$12516102012088* У этого компонента нет площади и его нельзя будет использовать на уровнях. Добавьте компоненты на карту чтобы дать ему площадь.
$14712417427860* Поскольку этот уровень это инструмент а не испытание, вы можете вернуться на карту уровней когда захотите.
$15549447390000* Несколько компонентов входа/выхода находятся в одном квадрате. Этот компонент невозможно будет использовать, так как два подключения не могут быть в одном месте.


=== trans/panel_switch_input ===

$27545152958344* [right]Input[/right]


=== components/Register32 ===

$65405398199118* 32 битная память
$22031255978461* 32 битный регистр


=== trans/panel_maker16_input ===

$17253365231801*
[right]Байт 1
Байт 2[/right]


=== misc/ui_panel/outputs ===

$29350436761480* ВЫХОДЫ


=== trans/manual_the_robot ===

$92896462984546* Робот


=== trans/panel_program4_output ===

$30314861365347*
Выход 1
Выход 2
Выход 3
Выход 4


=== trans/panel_network_output_description ===

$44520675249142*
[b][color=#39aa49]Event type[/color] (results)[/b]
[code]0[/code] No new events
[code]1[/code] [color=#39aa49]Incoming connection[/color] (Connection ID, Port)
[code]2[/code] [color=#39aa49]Connect complete[/color] 
[code]3[/code] [color=#39aa49]Receive data[/color] (Connection ID, Data, Data length)
[code]4[/code] [color=#39aa49]Connection closed[/color] (Connection ID / Error code)


=== trans/rpg_complete_chest ===

$59394224080614* [center]Tricksy's chest[/center]


=== trans/manual_text_top_the_robot ===

$50801318216470* The screen shows the robot and his surroundings.


=== trans/panel_clock_input ===

$26264925364981* [right]Enable [/right]


=== trans/level_conditions_description ===

$62540112577327* [center]Если значение соответствует условию, выведите [img]dialogue/on.png[/img], иначе [img]dialogue/off.png[/img].[/center]


=== misc/ui_comment ===

$69987793052607* Комментарий (Клик на проводе)


=== levels/delay_level ===

$19986989895202*
У каждого компонента есть задержка. Суммарная задержка схемы определяется самым медленным путём. Это значит что обычно лучше делать вещи параллельно.
На этом уровне вы должны показать что понимаете это понятие.
$11246430085016* Примечание: вы можете увидеть путь задержки нажав на песочные часы в правом верхнем углу.
$12817338693402* Задержка любого компонента выводится из задержки базовых элементов, задержка которых 2. Создайте цепь с задержкой 6 и стоимостью 5 базовых компонентов.
$17854168097855* Проверить


=== rpg/hat_man ===

$31184066972544* Leprechaun Hat
$35778552177922* Santa's Hat
$13294635391831* Pharaohs Hat
$82258891749699* Where did my money go???
$79556354428080* Custodian Helmet
$47713748239182* Come again Robot
$68242068712116* Baseball Cap
$93275531091074* Cowbot Hat
$30546444635339* Lady hat
$40995289760848* Лучшая шляпа
$50407582286574* Police Cap
$60834004183919* Bowler Hat
$98505468673014* Wide Brim Bucket Hat


=== components/Mul16 ===

$49880767097125* Умножает два входа 
$62247409328063* Умножить


=== trans/panel_dual_load_input ===

$93092890899642*
[right]Load
Save
Address
Save value
Load 2
Address 2[/right]


=== trans/ide_memory_address ===

$94594171568769* [center]Linked components[/center]


=== trans/panel_register16_inputs ===

$96875261858960*
[right]Load
Save
Save value[/right]


=== trans/options_pipette_wire ===

$96339976117958* Пипетка для провода


=== trans/rpg_complete_flower ===

$15192250170799* [center]Dumio and Gruliette[/center]


=== trans/panel_maker32_input ===

$93209061270494*
[right]Байт 1
Байт 2
Байт 3
Байт 4[/right]


=== misc/add_assembly_64bit ===

$33233688912123* [center]Add assembly code[/center]


=== trans/panel_regred_input ===

$61209423072819*
[right]Load
Save
Save value[/right]


=== components/Mux ===

$11168613697835* Toggles between two values
$22167405631310* 8 Bit Mux


=== components/Switch32 ===

$70717074742809* 32 Bit Switch
$93061034213009* Toggles a value


=== trans/level_byte_adder_question3 ===

$88075700159266*
[right]Carry IN
Byte 1
Byte 2[/right]


=== trans/level_complete_wire_comments ===

$92673421413755*
[b]Wire comments[/b]
[color=#cccccc][i]Add comments to your wires.[/i][/color]


=== trans/panel_counter8_input ===

$50035967147203*
[right]Increment / Overwrite
Overwrite value[/right]


=== trans/schematic_new_folder_name ===

$86236104278688* Новая папка


=== rpg/maps/overworld/brambert ===

$23133103699795*
I work here so I can
save up to buy Best Hat


=== levels/Nor GATE ===

$11362258372706*
Большинство существ на этой вашей Земле агрессивны и не могут вести себя разумно.

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


=== trans/level_complete_stats ===

$65428404547905* Stats


=== trans/panel_output_direction ===

$89612128414294* Label direction


=== misc/watchable_state ===

$58678516111149* Link components


=== main_scripts/input ===

$10186190492148* ALT click to move wire head


=== levels/wide_instrucitons ===

$13709034294291* Сохраняй на чётных тактах, выводи оба байта на нечётных.
$17693995237077* Выведи оба байта
$19068760748550* Выводи 0 на чётных тактах
$65009239162932* Правильные выходы были {a} и {b}
$19203973423116* Создай устройство которое сохраняет выход программы на чётных тактах и выводит оба байта на нечётных.
$17409169138995* Сохрани байт


=== components/Xnor64 ===

$64937916903935* Побитово XNOR два значения
$47129074382309* 64 Битный XNOR


=== rpg/maps/overworld/griffith ===

$55209338960432*
Go to the slime farm
and collect slime goo
$96728313107159* Great you have collected the goo
$96479154941553* Tomorrow I am going skiing
$22071068061213* 2 more should do
$76381947526292* 4 blobs of goo should be enough
$79617816410767* Help me get off work robot
$53961253609599*
The the barrel will be served 
for dinner later
$27173657446279* Wait what
$75126453723590*
Good, you have collected 
3 blobs of goo from the 
slime farm
$31359502586908*
I have too many sick days
already I need a really good
excuse this time
$37703435616461* A noble quest
$76778627086258*
Thank you for helping me 
get off work man
$95279523937415* 3 more should do
$38680695249087*
Then put it in the stew
barrel behind the chef
in the cafeteria
$10482244323050*
Now go put it in stew barrel
in the kitchen behind
the chef
$24977511637567*
Good, you have collected
1 blob of goo from the
slime farm
$80959866769801*
If we could get my
boss to eat it, that
should do the tick
$21601269931093*
Good, you have collected 
2 blobs of goo from the
slime farm
$28681635150249* Just get one 1 more
$71867966253273*
Eating slime goo
makes you very agreeable


=== levels/bit_switch ===

$56295261249455*
If components output different values on the same wire, you get an error. However, some components have grey output pins, these are not outputting at all when the component is not enabled. This is the case for the Bit Switch component.

[img]dialogue/bit_switch.png[/img]

This means that more than 1 of these grey output pins can connect to the same wire and not cause an error, as long as only one of them is enabled at a time.
$42793594302151* Using 2 NOT gates and 2 Switches, build an XOR gate.


=== rpg/maps/prison/dr_rakoo ===

$62085363571678* Dr. Rakoo
$41342441528477* Blood
$31033960272185* I am the esteemed Dr. Rakoo


=== components/Stack ===

$71022099146246* Память в которую можно помещать и извлекать
$47202418972371* Стeк


=== ui/schematic_ui/confirm_delete ===

$46014905606975* Да


=== trans/levels_saving_bytes_text ===

$36838510526259*
[right]Действие
Желаемый выход
Текущий выход
[/right]


=== components/Rol64 ===

$49017662473189* Прокручивает биты входа налево
$13677051385046* Прокрутка влево


=== trans/level_decoder_1_RichTextLabel2 ===

$50454539040073*
[right][color=#e49f44]Вход[/color]
Выход 1
Выход 2[/right]


=== levels/byte_shift ===

$16023356915123* The task in this level is to shift the first input to the left by the value given in the second input. The second input will never exceed 7.
$37338672894296* Shift the bits of {value} left by {amount}
$10598344098990* [center]Shift the first input left by the number of places given by the second[/center]
$16216408139965*
To [color=#e49f44]shift[/color] a value 1 left just means moving all the bits in a byte to the left by 1 position.
For example: [color=#e49f44]90 shl 1[/color]

[OFF] [ON] [OFF] [ON] [ON] [OFF] [ON] [OFF] would become:
[ON] [OFF] [ON] [ON] [OFF] [ON] [OFF] [OFF]

Shifting by 3: [color=#e49f44]90 shl 3[/color]
[OFF] [ON] [OFF] [ON] [ON] [OFF] [ON] [OFF] would become:
[ON] [ON] [OFF] [ON] [OFF] [OFF] [OFF] [OFF]
$18137790657923* In addition to giving you a shift left component, we also had the intern create a shift right component. All he had to do was to create the mirror version of this schematic.
$18518173140953* Я настоятельно рекомендую добавить [color=#e49f44]сдвиг влево[/color] и [color=#e49f44]сдвиг вправо[/color] к вашему компьютеру для будущих уровней.


=== trans/panel_outputlevel_enable ===

$88881816595724* [center]Disable / Enable[/center]


=== misc/restore_overture ===

$52008982212566* Сброс


=== rpg/maps/overworld/bridge ===

$70708048943630* Мост


=== trans/panel_input_down ===

$70002762618597* Down


=== trans/_second_tick_RichTextLabel2 ===

$11680718497014*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== components/SpriteDisplay ===

$27510895774306* Multi layer sprite display
$49278744667468* Sprite Display


=== levels/ram_block ===

$12901484249817* Can you fit 4 bytes of memory in this limited space?
$14218335256117*
In our advanced civilization, forcing prisoners to do extremely menial tasks is slavery and is technically illegal.
	  That is why we instead had our intern create the 256 byte version of your component.
$15908016538045* ЗНАЧЕНИЕ
$16196915566111* 0
$14259545926196* A
$12306130287676*
На этом уровне вы должны построить схему которая
может [SAVE] или [LOAD] из 4-х разных байтов памяти.

Вам даётся 1 который определяет нужно ли вам [LOAD]. Другой бит определяет нужно ли вам загружать [SAVE] и к нему прилагается значение.
Кроме того у вас есть 2-х битовый адрес. 

С 2-мя битами существует 4 комбинации, одна на каждый байт на этом уровне.
[i][tip]Объединяй провода посередине и используй прямые углы, иначе получится балаган.[/tip][/i]
[i][tip]Пробел разворачивает элементы.[/tip][/i]
$18084166025569* Ничего
$13082830776248* НЕ ЗАГРУЖАТЬ
$12933801309767* A


=== misc/ui_panel/left_inputs ===

$16586225094516* ВХОДЫ


=== trans/manual_console ===

$73523750891893* Консоль


=== components/OutputCounter ===

$52247325526438* Счётчик


=== trans/panel_shl8_input ===

$61388183229084*
[right]Значение
Сдвинуть на[/right]


=== components/Off ===

$61860786587357* ВЫКЛ
$72749460799924* Всегда [OFF]


=== misc/ide_control_link ===

$80788685813993* Управление Роботом


=== misc/options_Score Sync ===

$45371978167502* Синхронизация счёта


=== trans/map_keys_to_pan ===

$26276191141664* Use keyboard to pan


=== components/Xnor32 ===

$17419057954798* Побитово XNOR два значения
$52489451755306* 32 Битный XNOR


=== trans/manual_send_otuput_robot ===

$65542429897149* [center]Send output to control the robot[/center]


=== components/Or3 ===

$17576327690867* 3-х контактный OR элемент
$99630419947500* 3-х контактный OR


=== trans/level_binary_search_description ===

$11976224688780* [center]Восстанови пароль[/center]


=== trans/rpg_complete_derpoo ===

$25534025775791* [center]RIP derpoo[/center]


=== components/Output1Sum ===

$90026011029075* Сумма


=== trans/level_binary_programming_description ===

$66247694103179* [center]Add 5 to the input[/center]


=== levels/Add 5 ===

$11540713506719*
You are now free to change the program of your computer.
Click the edit icon on the program component to start programming.
$19281970848639* [center]Add 5 to the input.[/center]
$17770257567603* So in the meantime we will have you help out on the ship a little.
$19446152707984* Click on the edit memory icon on the program component to start programming your computer. Your computer should read an input, add 5 to it and output it again (no need to worry about overflow).
$80639633676917* Input:
$12078933051174* But since you don't know how to program it yet, you are not quite ready for that.
$11074247151096* Notice that the immutable red register components have been replaced with a custom component with identical functionality.
$18134632592542* You have built your computer, but to win the competition you still have to finish the maze.


=== misc/options_keys ===

$92993941290486* Shift
$65955105101920* Numpad Enter
$12519478101154* End
$99716387921256* Context menu
$92411601634183* Pause
$93394348651979* Right Hyper
$49442994583673* Left Super key (Windows key)
$64963573823520* Print Screen
$11442487736991* System Request
$59365233304896* Clear
$17795913351819* Delete
$74172180238771* Scroll Lock
$16897068982305* Right Super key (Windows key)
$10929402286573* Page Down
$39382222147951* Caps Lock
$93358816396539* Down arrow
$14976122209522* Insert
$40013272281231* Left Hyper
$47096285951897* Page Up
$78473292327654* Up arrow
$54347318627968* Left arrow
$20334952085165* Right arrow
$25372126469538* Num Lock
$43488085975448* Home
$73529460447236* Return
$50389171923636* Backspace


=== trans/not_gate_click_next2 ===

$20820887361993* Нажми "Следующий Такт" чтобы увидеть


=== trans/panel_hdd_input ===

$99603056559749*
[right]Seek
Load
Save
Save value[/right]


=== trans/level_ai_keys ===

$33425880719824*
USE ARROW KEYS
TO SELECT CARDS


=== trans/architecture_2 ===

$38100016313511* АРХИТЕКТУРА ЦПУ 2


=== trans/program_data_width ===

$72687692653533*
[right]Data width:
[/right]


=== components/Counter32 ===

$87245349851451* 32 Битный Счётчик
$92765669828982* Увеличивается каждый тик, если не перезаписан


=== trans/panel_register8_outputs ===

$72930832545270* Выход


=== trans/options_disagree ===

$60077370372179* Disagree


=== components/NOT ===

$34453052824732* NOT
$90844421681709*
Инвертирует вход
[table=3]
[cell]Вход[/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][ON][/cell][cell][OFF][/cell]
[/table]


=== levels/Crude Awakening ===

$12508086025944*
Мы устроим Вам проверку.

Правила просты, постройте действующий компьютер или мы вас сожрём. Удачи!
$16321577947087* Поздравляем, вы были похищены!
$19257730429557*
Сигнал течёт от входа к выходу.
В верхнем левом углу, под "Вход" есть зелёная иконка,
нажмите на неё чтобы отключить компонент "Вход".
$17675121574388* Обратите внимание, что выход выключился.\nЭто потому, что сигнал прекратил течь от входа.


=== misc/instr_clone ===

$69090690657232* Клонировать


=== misc/wire_draw ===

$59836059268386* Новый провод (Горячая клавиша: Alt и потянуть)


=== levels/byte_or ===

$10368115829346* But actually it is OK because you lived good lives in the wild and we don't let the meat go to waste.
$15923734370936*
OR каждый бит входных байтов и выведите результат.

Например:
[code]
ВХОД 1 [ON][ON][OFF][OFF][OFF][OFF][OFF][OFF]
ВХОД 2 [OFF][OFF][OFF][OFF][ON][ON][OFF][OFF]
ВЫХОД  [ON][ON][OFF][OFF][ON][ON][OFF][OFF][/code]
$15226896485081* Возможно вы считаете что это не этично съедать всех землян которые не выигрывают в соревновании?


=== trans/level_registers_code ===

$40063003736243* [center]OR[/center]


=== trans/instrucitons_header ===

$14831276667273* [center]Instructions[/center]


=== trans/level_the_bus_description ===

$20464862486158* [center]Copy the value from the correct input, to the correct output[/center]


=== misc/option_reset ===

$15557473522933* Сброс


=== trans/panel_decoder1_input ===

$62550086102347* [right]Input[/right]


=== misc/inst_new_rule ===

$41064305626707* Новое правило


=== levels/always_on ===

$17712385236630* Создайте цепь на выходе которой всегда [ON].


=== rpg/maps/unseen_fruit/control_panel ===

$88166963001775* melons
$73302376080596* melon
$66897764153265* I have to be programmed to press this
$94493068600800* 2 {fruit_plural} were seen before the {fruit}
$96743644544068* This was the first instance of the {fruit}!


=== trans/level_complete_hex ===

$94261690850981*
[b]Hexadecimal[/b]
[color=#cccccc][i]Toggle between signed, unsigned and hex numbers[/i][/color]


=== trans/level_complete_gate ===

$99373213759665*
[b]Gate score[/b]
[color=#cccccc][i]You can now view the gate score of  wires and components.[/i][/color]


=== components/ByteEqual ===

$35668435514829* Проверяет если два входа равны
$39369982838671* Равно


=== levels/binary_racer ===

$16076448195257* Это испытание, в последнее время, стало моим любимым. Конвертация десятичных чисел в двоичные на скорость.
$29718660090112* Неправильный ответ.
$37319690622142* Хорошая работа, ты дошел до {current_level}-го уровня.
$19111664765554*
Переключайте биты (степени числа "два") внизу, чтобы составить десятичное число.

Пройдите хотя бы 3 уровня!

(Нажмите [color=#e63e5b][url=accessibility_mode]здесь[/url][/color] чтобы играть без таймера.
$11176073682097* Как будет {number} в двоичной системе?
$71866932309393* Ты дошел до {level}-го уровня!
$37093663674348* Уровень {x}


=== components/Mul64 ===

$72281597169494* Умножить
$11665562499390* Перемножает два входа


=== levels/xor_gate ===

$14093358515620* Эту штуку ещё называют XOR gate. Это довольно сложный уровень, не пугайтесь если не найдёте ответ сразу.
$19182751521677* В прошлый раз мы строили цепь, которая выводила [ON] на втором такте. А сейчас Вам предстоит построить цепь, которая будет выдавать [ON] на втором и третьем такте.


=== components/Bidirectional64 ===

$82412839066570* 64 bit Bidirectional Pin
$24932613021646* Can circumvent certain circular dependency errors


=== rpg/maps/overworld/door4 ===

$66194643935592* Secret door


=== trans/panel_network_input_description ===

$36399689035136*
[b][color=#e49f44]Request type[/color] (arguments)[/b]
[code]0[/code] No request
[code]1[/code] [color=#e49f44]Listen[/color] (Port)
[code]2[/code] [color=#e49f44]Connect[/color] (IP, Port)
[code]3[/code] [color=#e49f44]Send data[/color] (Connection ID, Data, Data length)
[code]4[/code] [color=#e49f44]Close[/color] (Connection ID)
[code]5[/code] [color=#e49f44]Read next event[/color]


=== rpg/maps/overworld/space ===

$70779117877705* Behold the vastness of space


=== rpg/maps/prison/sign_1 ===

$88221977354540* Sign
$74189085130186*
It says: The button 
opens the prison doors


=== trans/options_robot_right ===

$70185788176428* Вправо


=== trans/level_complete_profile ===

$78783902500954*
[b]Online profile[/b]
[color=#cccccc][i]Find it in the main menu.[/i][/color]


=== components/Maker32 ===

$82420653444614* Превращает 32 бита в 4 байта
$85308499118176* 32 битный производитель


=== dialogue/dotMatrixtext_link ===

$82486902873499*
The color pin uses byte 2, 3 and 4 for [color=#dd6576][url=RGB color]RGB color[/url][/color] (byte 1 is unused)
The pixel pin uses byte 2, 3, 4, 5, 6 and 7 for selecting pixels to be colored, where each bit corresponds to a pixel. Updates are only visible once byte 8 is set to 1, this "flushes" the changes and updates the display visually.

Both "Enable X" and "Enable Y" have to be on to update the display.


=== trans/panel_output_output_3 ===

$85656630840972* [right]Output 4[/right]


=== trans/panel_decoder3_output ===

$41412072467493* Only 1 turns on


=== rpg/maps/prison/prision_door ===

$64702123078518* The door is locked
$42385408716570* Door


=== misc/add_code_name ===

$57358078712675* Save


=== components/Hdd ===

$75645507178296* Жёсткий диск
$78558655732992* Постоянная память


=== ui/state_ui/title_screen/exit ===

$12639868461113* Выйти


=== rpg/maps/spacial_invasion/space_rat ===

$72504258410857* The space rats got too close
$94470860110909* Space rat
$67254986543263* Had I been programmed to do this\nthis would have completed the level


=== trans/panel_fulladder_output ===

$18502107482550*
Result
Carry


=== trans/options_waiting ===

$58990937331663* Ожидание


=== misc/ui_panel/memory ===

$65362728703588* ПАМЯТЬ


=== trans/panel_output_output_2 ===

$80266319030005* Выход 3


=== trans/ide_add_assembly_header ===

$94462268558066* [center]Add assembly code[/center]


=== levels/any_doubles ===

$16587030847545* Поскольку мы очень продвинутая раса, мы давно изобрели машину для сортировки носков. К сожалению, в машине сломалась схема, которая определяет пары носков.
$14373083988184*
На этом уровне 4 входа.
Установите выход в [ON] когда 2 или больше входов установлены в [ON].

[tip]Не "перемудрите" на этом уровне.[/tip]


=== ui/options/Robot Controls ===

$58799802152286* Управление Роботом


=== components/Neg64 ===

$88458190974122* Инвертор
$52206550732945* Побитово инвертирует вход


=== components/DelayLine1 ===

$30487770736917* Линия Задержки
$38206009264853* Выводит то что получила на вход на предыдущем такте


=== rpg/maps/unseen_fruit/door2 ===

$66022312281343* Door


=== trans/panel_rom_output ===

$80688779703520* Выход


=== misc/confirm_factory_reset ===

$65699778604521* Удалить Всё


=== components/DelayLine32 ===

$56616725618490* Выводит то что получила на вход на предыдущем такте
$49292282287971* 32-х битовая Линия Задержки


=== components/Nand64 ===

$27197172037913* 64 Битный NAND
$66590147372797* Побитово NAND два значения


=== misc/run_fast ===

$54853798559740* Run faster (right click: change target speed)


=== trans/panel_off ===

$61047424972631* Always


=== components/Nor64 ===

$17208777467974* Bitwise NOR two values
$72509242083648* 64 Bit NOR


=== trans/panel_hdd_description ===

$28038932532386*
[center]On the hard disk, the "head position" determines at what address reads and writes take place. Use the signed 8 bit seek pin to change the "head position".
Use a seek value of 0 if you don't want to change the position.[/center]


=== trans/panel_or_description ===

$65281182019602* [center]Bitwise ORs two inputs[/center]


=== trans/panel_input_input_3 ===

$21321167572284* Input 4


=== levels/Delicious Order ===

$10160261151833* First read the 15 deliciousness scores from the input one by one. Your task is to output them in sorted order, smallest to largest.
$16027225087666* 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.


=== components/Equal64 ===

$34603983706314* Checks if the two inputs are equal
$82876546747608* Equal


=== trans/panel_rol_input ===

$95166818170185*
[right]Value
Rotate by[/right]


=== trans/manual_component_factory ===

$35460636622618* Component factory


=== trans/options_status ===

$35063135798145* Состояние


=== levels/Tower of Radioactive Alloy ===

$13757925963562* Specifically we want you to move piles of radioactive disks from an old reactor. Just be sure not to put a bigger disk on top of a smaller disk or the whole ship will blow up.
$10750976989948*
The first 4 inputs will give you the following in order:
disk_nr - The highest disk number in the pile (2 to 4)
source - Which location number to move from
destination - Where to move the pile to
spare - The 3rd spot that is neither the source nor the destination

Control the crane with the following outputs:
0 - Move the magnet to spot 0
1 - Move the magnet to spot 1
2 - Move the magnet to spot 2
5 - Toggle the magnet on or off

Play with the magnet manually by using the arrow keys to move and enter to toggle.
$19265994465686* We need you to help clean up the basement.
$35120623183961* Move from {source} to {destination}
$15855497886737*
Implement the following algorithm:

Tower of Hanoi algorithm:[code][color=#87a8c8]
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)

move(disk_nr, source, dest, spare)[/color][/code]

[tip]Push register values to the stack to save them before calling a function that changes them.[/tip]


=== trans/manual_universal_gates ===

$28345532918560* Universal gates


=== trans/map_functions ===

$83960548773205* ФУНКЦИИ


=== components/Input 1 Byte ===

$90785720285146* 8 Bit Input


=== trans/panel_probewirebit_value ===

$24213353038685* [center]Value[/center]


=== trans/manual_text_binary ===

$69488982380310*
The numbers you are used to are base 10, here when we add a 0 to the right hand side of a number, it's value increases 10 fold.

Binary is base 2, so doing the same will instead just double it. In other words, each digit represents a power of 2. For example with [color=#c54d5e]base 2[/color] and [color=#e49f44]base 10[/color] color coded:
[color=#c54d5e]    1[/color] = [color=#e49f44]1[/color]
[color=#c54d5e]  10[/color] = [color=#e49f44]2[/color]
[color=#c54d5e]100[/color] = [color=#e49f44]4[/color]

To represent 6 we can simply add 4 and 2:
[color=#c54d5e]110[/color] = [color=#e49f44]6[/color]

Addition, multiplication and everything else works the same as base 10, except you carry when you reach 2 instead of 10.


=== trans/level_alu1_description ===

$90245779080897*
[center]OR, NAND, NOR or AND
the two bytes together[/center]


=== components/Program1Red ===

$26811947547688* Programmable memory component
$55594749714809* Program


=== rpg/maps/overworld/bed ===

$19781388766480* Bed
$41698807327261* I love looking at random furniture


=== trans/ide_binary_header ===

$22615032668969* Binary Editor


=== trans/level_registers_text ===

$78241632854567*
[right][color=#e49f44]Code
Input[/color][/right]


=== trans/panel_cond_input_0 ===

$59435425554599* Bit 0:


=== levels/program ===

$16693098943939*
The [INSTRUCTION] input component has been removed. It has been replaced by a program component. Every tick, use the counter to load the next [INSTRUCTION] from the program's memory.
	
You must use the counter component you unlocked earlier for this level.
$19686277478479* The program is still outputting the first instruction. Did you hook up a counter?


=== trans/manual_components ===

$40288888375581* Components


=== levels/capitalize ===

$14894954428144*
The inputs in this level represent the characters in a list of planet names, encoded as ASCII (see the manual). Each name is separated by a space which has the numeric value 32. Replace the first letter in each word with its uppercase counterpart.
(The possible input characters are a to z lowercase, space, apostrophe and dash)
$13301617098810* We had the intern type out planet names in human script. Unfortunately he forgot to capitalize each name.
$11647445869837* Вход: 
$11201813578269* Выход: 


=== levels/byte_equal ===

$17156565273196* Output [ON] when both inputs are the same.


=== rpg/maps/overworld/blankidork ===

$19291766514049* We are fighting the rebellion


=== trans/levels_counting_signals_RichTextLabel2 ===

$34604121212779*
[right]Вход 1
Вход 2
Вход 3
Вход 4[color=#e49f44]
Желаемый выход
Текущий выход[/color][/right]


=== trans/level_program_text ===

$38014836341470*
[right][color=#e49f44]Code
Input[/color][/right]


=== trans/level_complete_stat_time ===

$39203727515285* Time


=== trans/map_memory ===

$58330421958143* ПАМЯТЬ


=== ui/options/General ===

$36195388998735* Общее


=== trans/manual_text_matrix ===

$75170402412137*
[b]Showing letters[/b]
It just so happens that a pixel space of 5x7 while small is still able to render letters nicely. By adding an extra row and column, these letters will also look nice when put next to each other. 

[center][img]dialogue/manual/matrix_letter.png[/img][/center]


[b]Small tileable screen[/b]
Rotating the component, you get 8x6 pixels, which has a nice 4:3 aspect ratio and tiling these, you can get most resolutions you might want. The way the pins are set up on this component was specifically designed to allow tiling. Imagine the naive pin design where each component is enabled by a single bit. This would require you to connect 1 wire for each component. In this situation, the number of wires needed for a tiled screen would scale with the area, while the gap needed to fit wires between components, would scale with the circumference. 

[center][img]dialogue/manual/tilable_screen.png[/img][/center]

Instead, by having 2 enable pins, one wire can enable a whole row and another a whole column. This way, a single component can be selected by its unique row and column combination. Further, fitting the rest of the data on the same wires, means that the horizontal and vertical gaps only need to be 1 square wide. This component visually takes up half a square extra on all sides, such that these components can be tiled up pixel perfectly, with 1 square hidden between them for running wires.


=== trans/panel_delayline1_output ===

$99213923469748* Выход


=== trans/levels_double_the_number ===

$41609125516676* [center]Double the number[/center]


=== trans/panel_full_adder_input ===

$67545680105541*
[right]Input 1
Input 2
Input 3[/right]


=== trans/level_delay_level_description ===

$24326379952614* Создайте схему которая стоит 5 ЭЛЕМЕНТОВ и 6 ЗАДЕРЖКИ


=== trans/panel_max_data_len_max_data_length ===

$88063177433135* [right]Max data length[/right]


=== trans/level_spacial_invasion_description ===

$44980627299841* [center]Shoot the space rats![/center]


=== levels/registers ===

$10661964231175* I have locked the red components of this level in place, since you always make a mess and don't leave enough space. The mess you make from now on is saved between levels, you no longer get to start fresh each level.
$10211777161405*
These are the bit patterns for each [color=#c54d5e]source[/color] and [color=#e49f44]destination[/color].

[color=#c54d5e]Source[/color]:
[OFF] [OFF] [OFF]  REG 0 
[OFF] [OFF] [ON]  REG 1 
[OFF] [ON] [OFF]  REG 2 
[OFF] [ON] [ON]  REG 3 
[ON] [OFF] [OFF]  REG 4 
[ON] [OFF] [ON]  REG 5 
[ON] [ON] [OFF]  INPUT 
[ON] [ON] [ON]  UNUSED

[color=#e49f44]Destination[/color]:
[OFF] [OFF] [OFF]  REG 0 
[OFF] [OFF] [ON]  REG 1 
[OFF] [ON] [OFF]  REG 2 
[OFF] [ON] [ON]  REG 3 
[ON] [OFF] [OFF]  REG 4 
[ON] [OFF] [ON]  REG 5 
[ON] [ON] [OFF]  OUTPUT
[ON] [ON] [ON]  UNUSED

To get a more intuitive understanding of the requirements, click the [INSTRUCTION] icon in the upper left corner.
$14823499195861* Откройте "Инструкции" в верхней панели.
$15888345020710*
На этом уровне вам нужно создать схему которая может копировать из [color=#c54d5e]источника[/color] в [color=#e49f44]место назначения[/color].

Байт инструкции на этом уровне определяет [color=#c54d5e]источник[/color] и [color=#e49f44]место назначения[/color].

Биты 1, 2 и 3 дают [color=#e49f44]место назначения[/color]. Биты 4, 5 и 6 дают [color=#c54d5e]источник[/color].
$14108238519744* Time to create your master project, implementing the [color=#e49f44]OVERTURE[/color] computer architecture. This will be an actual Turing complete machine, a true computer in every way!
$14041158687959*
[color=#c54d5e]Source[/color] and [color=#e49f44]destination[/color] can be 1 of 6 registers, we will name them REG 0 to REG 5 respectively. 
	
Additionally, this map has a dedicated input component, which can be the [color=#c54d5e]source[/color] and an output component, which can be the [color=#e49f44]destination[/color].


=== misc/level_gate_manual_icon ===

$22002156022920* Unlocks manual entry


=== components/DotMatrixDisplay ===

$18651725958642* 6x8 Dot Matrix Display
$71512568789377* 6x8 pixel display


=== rpg/maps/overworld/fuel ===

$99170934143071* Core fuel


=== trans/panel_and_description ===

$92999392068622* [center]Bitwise XORs two inputs[/center]


=== levels/Masking Time ===

$19351773688761* Тактов осталось: {ticks_left}  Вход: {input}
$16810715868480* [center]Посчитайте Вход по модулю 4.[/center]
$17375862136921*
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.
$65431688078892*
In this level you are given a number as input and you should return that number modulo 4 as a result.

The challenge is that you only have {ticks_per_test} ticks to output the desired result.

Note, you don't need to change your hardware, you just have to figure out the trick to do modulo 4 quickly.
Use [color=#e63e5b][url=masking_time]this hint[/url][/color] if you get stuck.
$81055582534899* 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 {ticks_per_test} ticks.


=== components/Console ===

$66743357915699* Консоль
$16105755937680* экран 80x24 текстовых символов


=== rpg/maps/overworld/oozla ===

$72859292385128*
They say it can do arithmetic 
using any two registers,
storing the result anywhere
$41963791304712*
Alas it is but a story for children,
such heroes exists only in fairytales
$91713298019390*
His computer is said to
load more than 1 byte at a time
$43108829077557*
He is fabled to create a
powerful computer and 
solve the radioactive waste problem 
that threatens this ship
$60555049113315*
Some say it will have at least 
4 bit memory addresses, 
addressing 16 memory locations
$52580048139802* Prophecy speaks of a hero to come


=== components/LessI16 ===

$75600169624828* Less (signed)
$73697238171042* Checks if one input is less than the other


=== trans/label_input_input_0 ===

$83039286441109* Input 1


=== trans/level_constants_description ===

$34641396464207* [center]Add constant loading to your architecture[/center]


=== trans/manual_circular_dependency ===

$40263928358112* Circular dependency


=== trans/panel_keyboard_right ===

$90098719956554* Key value


=== trans/panel_equal_output ===

$15175350110347* Выход


=== trans/panel_on ===

$77349453746493* Always


=== misc/profile ===

$32835651830157* Профиль


=== components/BeepBox ===

$15009144144117* Генератор Волн


=== components/Bidirectional32 ===

$54631386552063* 32 bit Bidirectional Pin
$35105566244017* Can circumvent certain circular dependency errors


=== trans/panel_clock_output ===

$47697250900761* UNIX timestamp


=== misc/specifications ===

$56390619785555* View instructions definitions
$68054407020318* Instructions


=== trans/manual_component_factory_text ===

$42847481618884*
Open the component factory by clicking on this button [img]dialogue/manual/component_factory_icon.png[/img] in the upper left bar.

The component factory allows you to create your own components. The logic you place determine the behavior of the custom component and the layout determines the shape. 

The input and output components you place become pins on the component. Like with other components, a component output leading back to its input causes a circular dependency. Outputs having a path back to inputs causes a circular dependency for custom components, even if the insides of the component would suggest there shouldn't be one. Not having to worry about the inside of components reduces the complexity of larger builds, however this strict abstraction can be inconvenient under certain circumstances. In that case, use the unbuffered pins. They allow bidirectional flow and use the insides of the component to check for circular dependencies.

Probes placed in custom components will show on their layout and can display values inside. Probes can be connected to other custom components, so that deeply nested values can be displayed. Values probed in this way can also be connected to the program component.

For the component factory, the file manager also manages the custom components. The file names decide the component name and the folder structure decides the components placement in the menu.


=== trans/level_complete_stat_delay ===

$43118901497406* Delay


=== rpg/maps/overworld/door2 ===

$40757019106897* Door


=== components/NetworkClient ===

$44510554000571* Network
$90462653419289* Handles network connections


=== trans/options_animation_speed ===

$13442839894535* Скорость анимации проводов


=== trans/levels_negative_descriptions ===

$87964635915702*
-127 to 127 representable:
0 to 127 same as before:
Works with adder:


=== components/Counter16 ===

$37313834107391* Увеличивается каждый тик, если не перезаписан
$49104925799943* 16 Битный Счётчик


=== trans/panel_cond_input_1 ===

$99239506734191* Bit 1:


=== trans/panel_splitter32_output ===

$18283412227212*
Byte 1
Byte 2
Byte 3
Byte 4


=== rpg/maps/overworld/barrel7 ===

$19922359571673* Stew Barrel


=== components/Splitter32 ===

$90978982016052* Splits 32 bits into 4 bytes
$24096666569346* 32 bit Splitter


=== trans/panel_neg_input ===

$92219875545393* [right]Input[/right]


=== components/Program64 ===

$76480303942112* Программируемый компонент памяти


=== components/Shl64 ===

$56766765894165* Сдвигает биты входа налево
$37014604954362* Сдвиг влево


=== trans/level_byte_mux_description ===

$20538476756633* [center]Output the correct input byte[/center]


=== trans/options_cluster_color ===

$77850745497963* Применить цвет к группе проводов


=== trans/panel_program_1inputs_label ===

$70127964821412* [right]Edit watched state[/right]


=== levels/xor ===

$11589029892097* XOR биты входа {a} и {b}
$12758156517177* Using the instructions of your computer, read the input twice and XOR the two values together
$16047615798435* [center]Read the input twice and XOR the bits of the two inputs[/center]


=== trans/level_byte_or_text ===

$99465606386164*
[right]
[color=#e49f44]Вход[/color]
Желаемый выход
Текущий выход
[/right]


=== trans/manual_simulator ===

$19932404521621* Simulator


=== trans/panel_not_output ===

$74796974148718* Выход


=== trans/panel_output ===

$19698504808819*
Result
Carry OUT


=== levels/the_bus ===

$72472660427162* [center]Скопируй значение из входа {input_nr} в выход {output_nr}[/center]
$96958133516462* ИЗ
$91318587712792* В
$85140574084420* [center]Скопируй значение из правильного входа в правильный выход[/center]


=== components/Ram ===

$95418291334002* 256 Байтная ОЗУ
$27094240214067* Компонент Памяти


=== components/Constant16 ===

$85825068431072* 16 Битная Константа
$61330657823382* Константное значение


=== levels/and_gate_3 ===

$14788981567936* Создайте компонент AND с тремя входами.


=== components/DivMod16 ===

$42657221816637* Делит 2 числа с остатком
$22319923069746* Деление


=== components/MemoryProbeBit ===

$13846578075327* Выведи значение на твоём пользовательском компоненте или в редакторе программы.
$25103579211328* Проба памяти (бит) 


=== trans/level_byte_mux_text ===

$44961981616677*
[center]Ваш ответ 11 + 88 =  0
Правильный ответ 11 + 88  = 99[/center]


=== components/DualPortRam ===

$13408945557666* ОЗУ с дополнительным загрузочным контактом.
$30400404542678* Дву-загрузочная ОЗУ.


=== components/Switch64 ===

$80980797636768* Переключает значение
$93223372486795* 64 битный выключатель


=== misc/delay_overlay ===

$85430022417382* Показать задержку


=== levels/push_pop2 ===

$10062117579269* Добавь стек к твоему компьютеру.
$14685569269160*
На этом уровне ты должен добавить стек на свой компьютер и написать программу, которая решает уровень.
Когда ввод равен 0, ты должен [color=#e49f44]извлечь[/color] значение из стека и вывести его. Когда вход не равен 0, ты должен [color=#e49f44]поместить[/color] его в стек.
$18561605111721* ПОМЕСТИ {input} в стек
$59658696292688* ИЗВЛЕКИ {value} из стека


=== rpg/maps/overworld/crate ===

$37606760989079* Debris
$78128919991233* Crate


=== trans/level_codes_description ===

$24678249110160* [center]Добавьте коды расчётов в вашу схему[/center]


=== trans/text_truth_table_left ===

$58617980046951*
[right]Вход 1
Вход 2
Выход[/right]


=== rpg/maps/overworld/musli ===

$21621435534103* It doesn't make any sense.
$20939310165945*
Why does the same fuel come out
of the core and then 
go in again?


=== rpg/maps/overworld/purple_flower ===

$70367070546819* It looks like a flower
$91230192040939*
This must be the flower
Gruliette wanted


=== trans/panel_segment_value ===

$97585846659258* [center]Value[/center]


=== ui/state_ui/state_ui_output_bit ===

$40754755480566* Выход


=== trans/manual_delay ===

$78806697204524* Delay


=== trans/panel_constant_output ===

$14868502983738* Выход


=== rpg/maps/unseen_fruit/gulgramush ===

$35182545479584*
Don't break the walls
Bad robot


=== trans/rpg_alloy_enter ===

$47375100278801* [center]PRESS RESET TO TRY AGAIN[/center]


=== components/Program8_1 ===

$11057354704814* Программируемый компонент памяти
$12805545963716* Программа


=== levels/crude_awakening/next_level ===

$24027424800887* Next level


=== components/Nor8 ===

$34517798310461* Побитово NOR два значения
$39421972053612* 8 битовый NOR


=== trans/level_alu2_description ===

$37432913848309* [center]OR, NAND, NOR, AND, ADD or SUB the two bytes together[/center]


=== trans/level_complete_stat_gate ===

$95192766583497* Gate


=== levels/signed_negator ===

$10866019808027* Для этого уровня вы, вероятно, захотите включить числа со знаком, чтобы старший бит отображался как -128. Нажмите "+255" на верхней панели.
$10400106910274*
Taking the input as signed (where the 8th bit is -128), make a component that takes a number and negates it.
For example 4 negated would become -4. -9 negated would become 9.


=== trans/level_circumference_subscript ===

$80632450818467* [center][color=#cccccc](Assuming π ≈ 3)[/color][/center]


=== trans/panel_output_output_0 ===

$91933395166656* [right]Output 1[/right]


=== trans/options_missing ===

$22687523145097* Missing


=== trans/level_xnor_RichTextLabel2 ===

$59451104901430*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== ui/state_ui/title_screen/play ===

$66967233942803* Кампания


=== trans/level_ram_component_value_description ===

$53113984441582*
[right]Тест
Адрес
Действие
Ожидаемый выход[/right]


=== trans/level_byte_less_description ===

$37336202055283* [center]Determine if the first input is less than the second.[/center]


=== components/Register16 ===

$16015376037787* 16 Битный Регистр
$71792123436163* 16 битная память


=== levels/Opcodes ===

$19693461238792* Установи шаг счётчика на 4
$20916717363300* Linked component {nr} should point to the output
$38976231780455* Linked component {nr} should point to a register or custom component with a register inside
$18189600217529* [center]Реализуйте коды операций[/center]
$13450117997204* Добавь счётчик к схеме
$77044880242883* Linked component {nr} should point to the counter
$13870568875751* Create a new schematic and add a program with 4 byte output
$10303603301757*
Implement the following opcodes:
[code][color=#87a8c8]0 ADD
1 SUB
2 AND
3 OR
4 NOT
5 XOR[/color][/code]

The opcode NOT ignores the second argument.
$17495651785164* Добавь 6 регистров в схему


=== components/Mem Unit ===

$57670626909848* 1 бит памяти
$78616473760551* 1 битная память


=== rpg/maps/prison/snake ===

$41424386577594* Snake
$44205554907271* Hiss Hiss Rattle
$36655099439467* Blood


=== trans/panel_inputlevel_input ===

$27464111307888* Input


=== misc/credit_box ===

$15872341864658*
Sincere thanks to:

[b]Translators[/b]
{translators}

[b]Early beta testers[/b]
{beta_testers}

[b]Font work[/b]
{font_work}

[b]Soundtrack[/b]
 Adolfo Aaron Figueroa Bianchi

[b]Open source software[/b]
{software}

[b]Assets[/b]
{assets}


=== trans/level_flood_enter ===

$64481408588810* Hit ENTER to show water


=== trans/panel_matrix_input1 ===

$88358148100771*
[right]Enable Y
Pixels / Flush[/right]


=== trans/options_pan_left ===

$78515694621006* Двигаться влево


=== rpg/maps/prison/control_panel_release ===

$78007210535349* Control panel


=== trans/panel_splitter8_input ===

$90934251511339* [right]Input[/right]


=== rpg/maps/unseen_fruit/Gulgramush JR ===

$21404721941060* Did you know earthlings eat with their face?


=== misc/lab_toggle ===

$16432178820878* Лаборатория


=== components/Program4 ===

$27522667367787* Программа
$45650720555565* Программируемый компонент памяти


=== trans/options_controls ===

$18297012748869* Управление


=== levels/Counter ===

$17701404772563* Добавь 1
$17940006660359* Count
$17263901743088*
Build a counter that will increase by 1 each tick.

Additionally, there should be an option for overwriting the counter with a given value.

You are given 2 inputs, a bit and a byte.

The bit input should toggle between counting and overwriting with the value of the byte.
$68874699768861* Перезапиши на {value}
$10555159894041*
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.

Make a device that counts increments once per tick.


=== components/Constant32 ===

$39402227599142* Константное значение
$30896164786171* 32 Битная Константа


=== trans/manual_text_ram ===

$10969790213397*
This simulator has several types of RAM different trade-offs, similar to real life RAM options.

[b]RAM[/b]
The RAM component can store a lot of data, but adds a very high delay to the circuit.

[b]Fast RAM[/b]
The fast RAM has a low delay, but a very high gate cost per byte.

[b]Latency RAM[/b]
The normal RAM has very high delay, however instead of waiting for this delay each tick, we can treat the RAM as if load and save takes multiple ticks. The number of ticks save and load will take depends on the length of each tick. Say for example that our circuit has a delay of 100 units, a load would take 10 ticks, since we have to wait about 1000 units of delay. 

A common approach for pipelined architectures is to use Latency RAM as for main memory, but use a small amount of Fast RAM for caching. Since memory access is often adjacent or close (for example when looping over an array), fetching adjacent values when loading from Latency RAM and caching them in Fast RAM can significantly speed up certain kinds of programs.

The simplest way to integrate the Latency RAM is simply to stall the whole architecture while waiting for a save or load. An easy optimization on this comes from realizing that you don't have to wait for saves, except if you want to load.

[b]Dual Load RAM[/b]
Sometimes it is beneficial to separate parts of the logic into a separate processing unit, that operates more or less independently. This could be for handling a display device or a network connection. In these cases, the independent unit will often need to continuously load and save to memory, while the outside logic only needs to occasionally load. Use Dual Laod RAM to avoid having to schedule who gets access to the RAM at what time.


=== component_panels/sprite_display_select_button ===

$18632189666863* Select file


=== trans/map_locked ===

$95146987030704* Заблокировано


=== levels/decoder ===

$16133643476631* Схема, которую вы построили на уровне "Регистры, может копировать значения между регистрами, в то время как "Арифметический Блок" может выполнять различные операции над 2-мя входами. Но вам нужно делать и то и другое в одной и той же схеме. Для этого, постройте "декодер", который будет определять в каком режиме наш компьютер находится, основываясь на 2-х битах которые вы до сих пор не использовали.
$18435544383511* CALCULATE pattern\n[OFF] [ON] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY]
$18945946395447*
To distinguish between the [INSTRUCTIONS] of 4 different kinds, the two highest bits will be used to determine which MODE we are in as follows:
[OFF] [OFF] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY] Immediate
[OFF] [ON] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY] Calculate
[ON] [OFF] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY] Copy
[ON] [ON] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY] Condition

Here [ANY] means any value.

Determine the MODE we are in from the input, then send [ON] to the correct output.
$15105859227432* COPY pattern\n[ON] [OFF] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY]
$12671132029272* Ваша схема была сохранена на завод компонентов.
$12068329066372* [b]ALERT: THIS IS AN OUTDATED VERSION OF THIS MAP, PLEASE CLICK THE SAVE ICON IN THE TOP LEFT AND CREATE AND LOAD A NEW SCHEMATIC[/b]
$11382827588408* CONDITION pattern\n[ON] [ON] [OFF] [OFF] [OFF] [ANY] [ANY] [ANY]
$12976424717611* IMMEDIATE pattern\n[OFF] [OFF] [ANY] [ANY] [ANY] [ANY] [ANY] [ANY]
$12532951884542* IMMEDIATE


=== trans/level_compute_xor_description ===

$61886892927185* [center]Pairwise AND together each bit[/center]


=== trans/level_signed_negator_description ===

$87777776285772* [center]Invert the sign of the number[/center]


=== trans/options_effects_volume ===

$24145565754506* Громкость эффектов


=== trans/panel_maker64_input ===

$67636019772385*
[right]Byte 1
Byte 2
Byte 3
Byte 4
Byte 5
Byte 6
Byte 7
Byte 8[/right]


=== main_scripts/overture_level ===

$11338791453100* Dynamic
$27259865408750* На следующем такте значение счётчика будет {next}, Это должно быть {expected}
$95030012922256* Вход должен быть включен только при чтении с входа
$12873109232054* Ожидаемый вывод: {expected}, получено: {got}

#  "cond" is for condition, this label has to be short as it has to fit on a component
$94982725578534* COND
$93579176707338* Copy INPUT ({input_val}) to REG {reg}
$15507583089532* REG {nr} should have value {value}
$78673238418574* Your circuit is missing a counter component
$65651227755356* Next tick the counter value will be {actual}, it should be {expected}
$47188699762650* Выход не включён
$44533909869936* REG 1 and REG 2 are inputs to the ALU, REG 3 is for the result.\nIt looks like you are using REG 0, 1 and 2.
$28026304798371* Выход должен быть включен только при выводе значения
$85260864781281* Вход не включен
$96569633331621* Загрузи {value} в РЕГ 0
$16914143080303* Copy
$59042824277105* Immediate
$82949244692745* Calculate
$83829200305236* Ожидаемый выход: {expected}, получено: {got}


=== levels/Further Delayed Lines ===

$17366913897135* Создайте цепь которая выводит свой собственный вход с задержкой в 2 такта.
$60989431641221*
This level introduces the Delay Line component. It takes its input and outputs it 1 tick later.

[img]dialogue/delay_buffer.png[/img]


=== levels/negative_numbers ===

$12574817679356* Получается, нам нужен способ хранения отрицательного значения в БАЙТе. Система, которую мы использовали до сих пор, может представлять все числа от 0 до 255 с помощью байта. This scheme is called 
$17231048881956* Для оценки различий в вещах и величинах, Вам потребуется ВЫЧИТАНИЕ. А, для процесса вычитания Вам, строго говоря, необходимы отрицательные числа. 
$70755151984986* {a} должен быть {b}
$11067230116844* {number} is not representable
$62744038163781* OK
$19118970740682*
[color=#dd6576]Edit the numbers[/color] for each bit so that the following is true:

[color=#e49f44]1[/color]: All numbers from -127 to 127 should also be representable
[color=#e49f44]2[/color]: Bytes representing anything from 0 to 127 should be the same as unsigned
[color=#e49f44]3[/color]: The new number system should work with the adder (for results between -127 and 127).
$15431436023571* You have two ways to represent 0\nWhich leads to 0 + 1 = 0
$28284583096369* 1 plus -1 does not equal 0\n  
$57604042654667* {number} is not representable


=== trans/nand_Label2 ===

$60885816586685* Выход


=== levels/NAND Gate ===

$17420270098223* На этом уровне вам предстоит разобраться как работает компонент NAND. [color=#dd6576]Обязательно[/color] разберитесь в этом прежде чем завершать уровень, иначе рискуете "застрять" на следующих уровнях!
$11034378482152* Верно! Вы разблокировали NAND элемент. С помощью этого компонента можно создать всё что необходимо для вашего компьютера!
$18270083417453* Проверка
$19208664264770* [b]Инструкция:[/b]\nНажмите любую серую кнопку в последней строке таблицы внизу.
$17923274216766* Что ж, придётся признать, что Ваш вид развит несколько лучше простейших микроорганизмов.
$14777350869870* Мы удивлены насколько успешно вы справились с предыдущей проверкой!
$17994568832660* [b]Инструкция:[/b]\nКомпонент NAND переключает потоки в электрической цепи.\nИспользуйте переключатели слева для экспериментов с Вводами(Inputs).\nПонаблюдайте как это влияет на потоки и Вывод(Output),\nа затем заполните последнюю строку в таблице внизу.


=== trans/options_copy ===

$55679445263875* Скопировать


=== components/Bit Compressor ===

$74338505460996* Превращает 8 битов в 1 байт
$98747779812970* 8 битный Производитель


=== components/Input 2 ===

$86870364449392* Вход


=== trans/options_pan_down ===

$93140495547084* Двигаться вниз


=== trans/panel_stack_input ===

$86207640171434*
[right]POP
PUSH
PUSH value[/right]


=== components/Mux64 ===

$14050204031082* Переключается между двумя значениями 
$66892629981737* 64 Битный Mux


=== trans/manual_hard_disk ===

$45865138134248* Жёсткий диск


=== components/NOR ===

$27510848535619*
[ON] Когда никакой из входов [ON]
[table=5]
[cell]Вход 1[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell]
[cell]Вход 2[/cell][cell][OFF][/cell][cell][ON][/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][ON][/cell][cell][OFF][/cell][cell][OFF][/cell][cell][OFF][/cell]
[/table]
$83375115196253* NOR


=== rpg/maps/unseen_fruit/Sign ===

$11494676474259*
It says: Don't stand around reading signs robot!
Go check on the fruit


=== levels/hex_racer ===

$33474352861351* Level {x}
$92057009138253* What is {number} in binary?
$16009852370452*
When dealing with a lot of bits, binary can become hard to read. Hexadecimal (base 16) represents each combination of 4 bits as its own character:
[code]
0 [OFF][OFF][OFF][OFF]
1 [OFF][OFF][OFF][ON]
2 [OFF][OFF][ON][OFF]
3 [OFF][OFF][ON][ON]
4 [OFF][ON][OFF][OFF]
5 [OFF][ON][OFF][ON]
6 [OFF][ON][ON][OFF]
7 [OFF][ON][ON][ON]
8 [ON][OFF][OFF][OFF]
9 [ON][OFF][OFF][ON]
A [ON][OFF][ON][OFF]
B [ON][OFF][ON][ON]
C [ON][ON][OFF][OFF]
D [ON][ON][OFF][ON]
E [ON][ON][ON][OFF]
F [ON][ON][ON][ON]
[/code]

As an example where hexadecimal is much clearer, lets compare the representation of the largest 16 bit number:
[code]
Binary:      1111111111111111
Decimal:     65535
Hexadecimal: FFFF
[/code]

It is not easy to tell if the binary is missing a digit or if the decimal number is off by 1, the hexadecimal on the other hand is immediately clear (once you get used to the representation at least).
$40775762006843* Wrong answer
$84691609525475* This level is my second favorite pastime. Converting hexadecimal to binary under time pressure.
$45532697833519* You made it to level {level}!
$87016829502381* Good job, you reached level {current_level}.
$43463538043782*
Toggle the bits in the level panel so they add up to the hexadecimal number in the question.

You must beat level 3 to pass.

(click [color=#e63e5b][url=accessibility_mode]here[/url][/color] to turn on timerless accessibility mode)


=== trans/level_full_adder_RichTextLabel2 ===

$25766177620842*
[right][color=#e49f44]Вход 1
Вход 2
Вход 3[/color]
Желаемая Сумма
Желаемый Перенос
Текущая Сумма
Текущий Перенос[/right]


=== components/Ror8 ===

$10802217509530* Прокручивает биты входа направо
$70999134800536* Прокрутка вправо


=== components/NAND ===

$71130919681688* NAND
$12903183841172*
[ON] пока оба входа не [ON]
[table=5]
[cell]Вход 1[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell]
[cell]Вход  2[/cell][cell][OFF][/cell][cell][ON][/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][ON][/cell][cell][ON][/cell][cell][ON][/cell][cell][OFF][/cell]
[/table]


=== trans/map_arithmetic ===

$51337598329530* АРИФМЕТИКА


=== trans/rotate ===

$88236351843942* Повернуть


=== levels/Dancing Machine ===

$14975070588197*
We all like the way Robot moves on the dance floor. That's why we want him to lead our dance team. 
	
The only problem is to make him come up with original dance sequences. How do you make creativity out of deterministic logic you ask?

The answer pseudo random number generators.
$15955150920362*
На этом уровне вы получите только один вход, мы называем это начальным семенем. Семя проходит через следующие шаги для получения псевдо-случайного числа.

В алгоритме ниже, "shl 1" означает сдвиг влево один раз, "shl 2" означает сдвиг влево дважды, а "shr 1" означает сдвиг вправо один раз.

[b]8-и битовый xorshift RNG:[/b][code][color=#87a8c8]
temp1     = seed  xor (seed  shr 1)
temp2     = temp1 xor (temp1 shl 1)
next_seed = temp2 xor (temp2 shr 2)
[/color][/code]
Затем, выведите next_seed по модулю 4, чтобы двигать робота. И наконец, используйте next_seed (до модуля) как семя, чтобы получить следующее число в танцевальной последовательности и повторите.

(Обратите внимание, что начальное семя никогда не будет 0)


=== trans/panel_fileloader_enable ===

$80528055112236* [center]Enable[/center]


=== misc/program_edit_signals ===

$98772447663910* Link components


=== main_scripts/levels ===

$64510812504271*
Some of the components used are not supposed to be available in this level!
The solution is not scored.

#  Level type for the level complete menu
$58769207148712* Component

#  Level type for the level complete menu
$90134890578411* Misc
$68327708695625* [b]Manual Entry[/b]\n\n Entry: [color=#68d277]{page}[/color]

#  Level type for the level complete menu
$69219742310717* Architecture


=== trans/level_decodre_RichTextLabel2 ===

$40723962298647*
[right][color=#e49f44]Вход 1
Вход 2
Вход 3[/color]
Желаемый бит
Текущий бит[/right]


=== trans/manual_bytes ===

$46223559629673* Байты


=== component_panels/Counter ===

$57936010210151* Увеличивать на: {amount}


=== trans/panel_ram8_output ===

$90649838965927* Выход


=== trans/level_complete_ide ===

$56719825235196*
[b]CODE IDE[/b]
[color=#cccccc][i]Name codes and edit them in a convenient editor[/i][/color]


=== trans/panel_cond_input_2 ===

$82398835019064* Bit 2:


=== trans/and_gate_3_RichTextLabel2 ===

$52008707927408*
[right][color=#e49f44]Вход 1
Вход 2
Вход 3[/color]
Желаемый выход
Текущий выход[/right]


=== trans/panel_nand ===

$51470292662088*
[right]Input 1
Input 2
Output[/right]


=== rpg/maps/overworld/captain_grog ===

$54304087865803* Shields up, jump to hyperspace!


=== rpg/maps/overworld/hat_man ===

$66365217340789* Hat man


=== trans/panel_mul_input ===

$52124868557994*
[right]Input 1
Input 2[/right]


=== components/LessU32 ===

$72614358420262* Меньше (Беззнаковый)
$55380524073095* Проверяет меньше ли первый вход чем второй 


=== trans/options_level ===

$64744152268407* Уровень


=== components/Output64z ===

$35798118634001* 64 Bit Switched Output
$42506906257154* Only outputs if the switch pin is [ON]


=== ui/toggles/race_condition ===

$75558678297830* Круговая зависимость


=== trans/options_paste ===

$52159578521318* Вставить


=== trans/level_double_buffer_RichTextLabel3 ===

$27208335953837*
[right]Вход
Желаемый выход
Текущий выход[/right]


=== trans/manual_text_terminology ===

$99266452352883*
[b]Instruction[/b]
A byte or a few bytes that together make the computer perform a specific action.

[b]Opcode[/b]
The part of the instruction that determines which operation (like ADD or AND) is to be done.

[b]Memory address[/b]
A number used as a name for memory locations (often for registers). These are used to specify where an instruction is supposed to load data from or save data to.

[b]Jump[/b]
Changing the value of the program counter, changing which instruction is loaded next.


=== trans/manual_text_truth ===

$16559670174521*
The tables of input and output which are used everywhere throughout the game are commonly known as truth tables.








"Input" and "Output" will often be represented with variable names, like in algebra. And instead of using colors, you will often see the values represented as 0 / 1 or False / True.


=== levels/Conditionals ===

$10794262854382*
Добавить, условные выражения в вашу схему. Для условных выражений, 2 аргумента сравниваются и если условие верно, счетчик установлен на адрес прыжка.
	
В предыдущих инструкциях, 4 байта представляли:
[code][color=#87a8c8]КОД_ОПЕРАЦИИ, АРГУМЕНТ_1, АРГУМЕНТ_2, РЕЗУЛЬТАТ[/color][/code]

Для условных выражений байты представляют:
[code][color=#87a8c8]КОД_ОПЕРАЦИИ, АРГУМЕНТ_1, АРГУМЕНТ_2, JUMP_ADDRESS[/color][/code]

В дополнение к предыдущим кодам операций, добавьте:
[code][color=#87a8c8]32 ЕСЛИ_РАВНО
33 ЕСЛИ_НЕ_РАВНО
34 ЕСЛИ_МЕНЕЕ
35 ЕСЛИ_МЕНЕЕ_ИЛИ_РАВНО
36 ЕСЛИ_БОЛЕЕ
37 ЕСЛИ_БОЛЕЕ_ИЛИ_РАВНО[/color][/code]

Используйте беззнаковое меньше / больше для сравнений.

Коды операций делают то что их названия подразумевают. Например эта инструкция прыгает на байт 16 если РЕГ0 меньше чем РЕГ1: 
[code][color=#87a8c8]ЕСЛИ_МЕНЕЕ РЕГ0 РЕГ1 16[/color][/code]
$18542005958715* Set the counter increment to 4
$17133561664335* Congratulations, you finished the [color=#e49f44]LEG[/color] computer!
$14973719570693* Добавить счетчик к схеме
$12920514303805* Add 6 registers to the map
$14309211963063* Create a new schematic and add a program with 4 byte output
$16826220977157*
 [color=#b72d41][b]ПОДСКАЗКА:[/b][/color] 
КОПИРОВАТЬ это просто ДОБАВИТЬ со вторым аргументом 0
$14690660047411* [center]Реализуйте коды операций для условий[/center]
$30132649789584* Linked component {number} should point to the output
$18994998239232* I will show you some upgrades you can make, on the path to implementing function calls. But from here on the details are up to you, I wont tell you what opcodes to use and so on.
$12034111753799* Linked component {number} should point to the counter
$36561706158040* Linked component {nr} should point to a register or custom component with a register inside


=== misc/multi_select ===

$85147529532131* Множественный выбор (SHIFT и перетащите)


=== components/Splitter16 ===

$92674917729864* 16 битный Разделитель
$28271182652741* Разделяет 16 бита на 2 байта


=== trans/manual_text_universal_gates ===

$37735744928195*
It turns out that you can build all the logic for a computer out of either NAND or NOR gates. The Apollo guidance computers, were built entirely of NOR gates. Designed in the sixties, they had only 4KB of RAM and 32KB of disk space, but guided astronauts to the moon nonetheless.

Modern computers are not built entirely of just one of the universal gates, but when applicable NAND gates are preferred over NOR, because they have less delay and occupy less area.


=== trans/panel_segment_info ===

$64695289448271* The 8 bits of the value each turn on 1 of the 8 areas of the display.


=== rpg/maps/overworld/slime ===

$69726620971060* Picked up all the goo I need
$87592944464187* Picked up goo, {nr} more to go


=== trans/inputlevel_enable ===

$28654406516589* [center]Disable / Enable[/center]


=== trans/panel_keyboard_event ===

$67549215280299* Event waiting


=== components/SRLatch ===

$11641785582600* Set/Reset Latch
$71931050184389* [img=165]dialogue/sr_latch_tooltip.png[/img]


=== trans/levels_byte_or_description ===

$68379799788575* [center]Pairwise OR together each bit[/center]


=== levels/counting_signals ===

$10724914203078*
Вывод на этом уровне это двоичный счетчик, у которого каждый из трёх контактов соответствует числам "1, 2 и 4" соответственно.
Используйте его для подсчета входов в состоянии [ON].\nЗатруднения?

[color=#e63e5b][url=counting_signals]подсказка здесь[/url][/color] если застрянете.

[i][tip]Решение этого уровня не очень красивое и может потребовать больше компонентов.[/tip][/i]
$10881918807029*
 [color=#b72d41][b]Совет:[/b][/color]
 Использование карандаша и бумаги
 не является чем-то постыдным.


=== misc/button_next ===

$80746616574054* Next (Hotkey: F5)


=== ui/toggles/level_map ===

$71951682957395* Карта уровней


=== components/DivMod64 ===

$80284847781948* Деление
$71663353206665* Делит 2 числа с остатком


=== levels/saving_bytes ===

$10633476398156*
Создать схему, которая может [SAVE] или [LOAD] байт.

Когда первый входной бит [ON], [LOAD] память и пошлите её на выход.
Когда второй входной бит [ON], [SAVE] входной байт.

У выхода есть активирующий контакт, активируйте его только если [LOAD].
$13502950630653*
[color=#ff9800]None
0
0[/color]
$19109563882664* НЕ ЗАГРУЖАТЬ
$16372198430230* СОХРАНИТЬ
$15498440508450* Не делать ничего
$15582618410991* ЗАГРУЗИТЬ И СОХРАНИТЬ
$18873598212433* ЗАГРУЗИТЬ


=== levels/byte_constant ===

$12641789008694* Создайте схему которая всегда выводит 164.


=== trans/panel_ram_fast_input ===

$80778301064570*
[right]Load
Save
Address
Save value
Save value
Save value
Save value[/right]


=== levels/odd_ticks ===

$18510295620397* Выведите [OFF] для четных тактов и [ON] для нечетных тактов.
$16987046679863* На предыдущем уровне вы узнали, что мы не допускаем круговых зависимостей. Теперь вы должны выучить одно исключение.
$16037516781370*
Квадратные контакты в игре никогда не влияют на вывод в тот же такт. Поэтому они никогда не вызывают круговых зависимостей.
	
	[img]dialogue/delay_buffer.png[/img]
$17588119878416*
Линия задержки может зависеть от собственного входа. Это потому, что её вход не влияет на остальную схему до следующего такта. 
	
[img]dialogue/delay_buffer.png[/img]


=== components/Adder Simple ===

$33973952772642* Сумма
$98429814030509* Суммирует два значения


=== trans/panel_ram8_input ===

$54796685972031*
[right]Load
Save
Address
Save value[/right]


=== trans/level_complete_delay ===

$73470840319057*
[b]Delay[/b]
[color=#cccccc][i]You can now view the delay of wires and components.[/i][/color]


=== trans/panel_ram_fast_output ===

$44175594625487*
Output 1
Output 2
Output 3
Output 4


=== trans/level_saving_gracefully_RichTextLabel3 ===

$74117520663650*
[right][color=#e49f44]Сохранить
Значение[/color]
Желаемый выход
Текущий выход[/right]


=== misc/select_color ===

$97461374731210* Цвет Провода


=== trans/manual_text_circular_dependency ===

$29050562435902*
A circular dependency is when the input of a component changes based on its own output. 

[center][img]res://dialogue/circular_dependency.png[/img][/center]

This simulator does not allow circular dependencies and instead triggers an error. 

The exception to this are the square pins that do not influence the output in the same tick. They can therefore not cause circular dependencies.

[center][img]res://dialogue/delay_buffer.png[/img][/center]


=== trans/panel_splitter16_output ===

$19314358335345*
Output 1
Output 2


=== rpg/maps/overworld/door3 ===

$62992379521216* Door
$12075276554344* The door handle is broken


=== trans/level_alu2_text ===

$58359423026017*
[right]Код
[color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход
[/right]


=== trans/options_explicit_clock ===

$90384542658266* Explicit clock


=== levels/push_pop ===

$78804623186243* ВЫХОД
$49526452710191* НЕ ИЗВЛЕКАТЬ
$58050047963238* ЗНАЧЕНИЕ
$19245209470436* Создайте стек
$12227209887733*
Каждый такт, входы будут указывать либо ПОМЕСТИТЬ либо ИЗВЛЕЧЬ. Если указано ПОМЕСТИТЬ, сохраните значение наверху стека. Если указано ИЗВЛЕЧЬ уберите значение из стека и выведите его.
	
У выхода есть активирующий контакт, включайте его только если указано ИЗВЛЕЧЬ.
$15662660252584* Ничего не делать
$62469306234943* НЕ ПОМЕЩАТЬ
$46948857059388* ИЗВЛЕКИТЕ значение {value} из стека
$18761197388580* In order to cut spending, it has been decided to change the queuing system at public offices so that fewer people will go. Instead of first come, first served, we are implementing a last come first served policy. Think of it like a [color=#e49f44]stack[/color] of numbered slips where the citizens either put a slip on top (called [color=#e49f44]PUSH[/color]), or the bureaucrats take one off the top of the stack (called [color=#e49f44]POP[/color]). We want you to implement this new system.
$65188797398656* ПОМЕСТИТЕ {value} в стек


=== levels/The Product of Nibbles ===

$14957949958941* What you did here was actually multiplying two 4 bit numbers. We had the intern scale it up to bytes instead.
$19136817138607* [center]Multiply the 4 bit numbers[/center]
$13549246864135* Бит 0
$14533861483435* Умножение двух 4-х битных чисел дает 8-и битное число. Создайте схему, которая это делает.
$10274387271390* Бит 0
$83694551809785* Перемножьте {num1} и {num2}


=== trans/panel_matrix_column_major ===

$76228401795903* [right]Column major pixels[/right]


=== trans/panel_counter16_input ===

$87154643308632*
[right]Increment / Overwrite
Overwrite value[/right]


=== rpg/maps/spacial_invasion/door ===

$59863326177819* The door is locked
$13853333722323* Door


=== trans/panel_not ===

$33240384048149*
[right]Input
Output[/right]


=== ui/toggles/level_log2 ===

$91515053618360* Справочник


=== main_scripts/functions ===

$11467644007149* Счётчик {nr}
$73560327420927* This save is from an obsolete version of this level.\nCreate and load a new schematic in the schematic menu.
$99285446909923* To solve this level you need to use the 'Level output' component
$72465734060414* Short circuit on wire (output values: {values})
$10533010562232* СЧЁТ ЗАДЕРЖКИ: {delay}
$10098517717617* Test: {nr} / {total}
$29225283986051* To solve this level you need to use the 'Level input' component
$87591753278764* Reg {nr}
$95056157627313* To solve this level you need to use the 'Level input' component
$29169064199243* Выход {nr}
$12249248261034* To solve this level you need to use the 'Level output' component
$13327741293223* Вход {nr}
$32508339206292* СЧЁТ ЭЛЕМЕНТОВ: {gate}


=== levels/or_gate_3 ===

$15448906128695* Create an OR gate with 3 inputs.


=== trans/binary_racer_count_down2 ===

$23959994711260* Ready to race?


=== trans/level_capitalize_input ===

$23002150617591* Input


=== trans/panel_mul_output ===

$55253255963402*
Lower half
Upper half


=== trans/panels_config_delay_delay ===

$52499013005170* [right]Delay[/right]


=== rpg/maps/unseen_fruit/Lolbert ===

$77789556089413*
Earth fruit is so much better
than the the stew they normally serve


=== trans/map_complete ===

$81337533438394* Complete


=== levels/Storage cracker ===

$11910674853271*
The security access door to the storage room is broken and it keeps locking our old janitor inside.

The door keeps changing the passcode, we need a program that can recover the passcode at any time.
$17462419719036*
The easiest way to find the passcode would be to try all combinations until you find the right one. 
Although the broken mechanism does make a weird beep when your guess is too high, you might be able to use that to your advantage.
$11183892008673* You win this level when you output the correct passcode, no output will fail the level. Additionally, the input will be 1 after a guess that was too high and 0 otherwise.


=== trans/level_alu1_text ===

$53254733455389*
[right]Код
[color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход
[/right]


=== components/Output16 ===

$48008022162230* 16 Bit Output


=== rpg/maps/overworld/book_shelf ===

$29366577532389* Bookshelf
$26595142082551* A fine bookshelf


=== components/Input 3 ===

$70689623552857* Вход


=== trans/options_cut ===

$88238310953306* Вырезать


=== trans/panel_network_next_event ===

$80836714383432* Next [color=#39aa49]Event type[/color]


=== rpg/maps/overworld/gruliette ===

$83120363112787* Oh hi handsome
$61022705156373*
Oh god no, I'm done
with this quest
$84856635901648* IHHHhhhh my heart melts!
$58406047748371*
Only if he can bring
me a pink flower
$18919563572338*
Do you want to go
on a date with Dumio?
$68101445990611* Here is the pink flower
$68725679456014*
*schmuck* bring this kiss
to Dumio for me
$73977053028689* Oh hi handsome
$50949692384224* My ears hurt
$35813418867082* That's random


=== trans/manual_text_top_truth ===

$83283949590490* AND gate


=== trans/panel_fileloader_description ===

$72892007399429*
The file rom outputs the content of a file 8 bytes at a time.

The highest 64 bit address (0xFFFFFFFFFFFFFFFF) is special and outputs the length of the file in bytes.


=== trans/and_gate_RichTextLabel2 ===

$98472849629373*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== components/Clock ===

$29674337035619* Placing the clock will divide ticks into 2 phases. The clock is [OFF] in the early phase and [ON] in the late phase. All memory components load in the early phase and save in the late phase.
$73207565196164* Clock


=== components/1_decoder ===

$26685462633615* Toggles between two outputs
$98250587600120* 1 Bit decoder


=== trans/panel_input_left ===

$91063734228931* Left


=== components/XOR ===

$86856280609387*
[ON] когда входы различны
[table=5]
[cell]Вход 1[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell]
[cell]Вход 2[/cell][cell][OFF][/cell][cell][ON][/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell][cell][OFF][/cell]
[/table]
$54832952840086* XOR


=== trans/options_undo ===

$58334563411624* Отменить


=== trans/options_robot_down ===

$71118559743827* Вниз


=== misc/factory ===

$53123649343022* Component Factory


=== trans/manual_ram ===

$61854681801183* ОЗУ


=== trans/manual_header ===

$10757271456963* Manual entries


=== components/Ror16 ===

$13970397213910* Прокручивает биты входа направо
$90115282457191* Прокрутка вправо


=== misc/opcode_name ===

$15090156481094* Name


=== rpg/maps/overworld/thing ===

$97983135944004* Thing
$65301573705048* Do I have to look at everything?


=== misc/level_gate_unlocks_unknown ===

$76731326010721* Unlocks something unknown


=== trans/map_cpu_architecture ===

$95559333192525* АРХИТЕКТУРА ЦПУ


=== trans/levels_negative_header ===

$82195103144851* [center]Requirements[/center]


=== components/LevelOutput1 ===

$12242923444593* Выход


=== levels/byte_adder ===

$16888130664370*
If the result does not fit in 8 bits, turn the output carry [ON] (you can think of it as the 9th bit)
	
Finally, there is an input carry as well. This is useful for chaining together byte adders to add larger numbers. You can think of this carry as adding either 0 [OFF] or 1 [ON].

Use [color=#e63e5b][url=byte_adder]this hint[/url][/color] if you get stuck.
$18732877690173* Add the two input bytes. Each output bit in the output should be a result of the addition of the corresponding bits from the inputs, and potentially a carry.


=== components/Mux32 ===

$16638728645850* Toggles between two values
$21257226547838* 32 Bit Mux


=== components/Shr32 ===

$87104108203785* Сдвигает биты входа направо
$88430124157796* Сдвиг вправо


=== trans/levels_bytw_or_text ===

$21877344150481*
[right]
[color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход
[/right]


=== components/DelayLine64 ===

$80000130396288* 64 Bit Delay Line
$35525647389906* Outputs this tick's input, next tick


=== rpg/maps/prison/shelf ===

$31961489023013* Bookshelf


=== trans/manual_Cyclic recipes ===

$45682345144408* Circular recipes


=== main_scripts/dialogue ===


#  hint for odd number
$68750974209145* You can figure out if 2 inputs have an odd number of [ON] with just 1 component...

#  hint for the bus
$50799425816171* Use switches to put the inputs on the same wire.

#  Hint for byte switch
$86319296925137* What would this look like if you were only switching 1 bit? What would the truth table for such a component look like?

#  Hint for the maze
$36837749971886*
Always following the left (or right) hand side of the maze will make sure you eventually reach the exit.
	
The pseudo code for such an algorithm looks like this:
 Step forward
 Turn left
 Turn right as long as there is a wall ahead
 Press use after each turn (in case the exit is ahead)
 Repeat

#  Hint for byte adder
$37093555217568* Тебе нужно всего лишь 8 полных сумматоров.

#  hint for counting signals
$21044442262778* The circuitry for the 1's bit is the same as what you did in the level "Odd Number of Signals". The circuitry for the 2's bit is what you did in "Double Trouble", except when all 4 are on.

#  hint for saving gracefully
$25321701584378*
In this level you need to use 1 Delay Line. Make a truth table for what should go into the Delay Line. Consider the input to the Delay Line as the output for your table. 

The inputs are the 2 level inputs AND the output of the Delay Line, as the output plays a role in its input. In total you have 3 "inputs" to for this table which gives you 8 combinations. Once you have the level requirements as a table, it should be a lot easier to solve.

#  Hint for conditions
$87674181578455*
There are 3 condition bits. The first bit being [ON] means the result being 0 meets the condition. The second bit being [ON] means the result being less than 0 meets the condition. If either of those two are [ON], the condition is met. 
Finally, if the last bit is [ON], negate the status of the condition being met or not.

#  hint for xor gate
$88963098241493* This level can be done with 3 components, a NAND, an AND and an OR gate.

#  Hint for masking time
$46866534894828*
In binary, taking modulo 4 of a number is the same as only using the two lower bits. This is because the higher bits represent 4, 8, 16 etc, and they all divide 4 with no remainder.
This is true in general for modulo a power of 2, the lowest bit of a number represents that number modulo 2 (even or odd), the lowest 3 bits modulo 8 and so on.

Likewise, in decimal 4321 modulo 100 is also simple (answer is 21, the higher digits are disregarded), this is because 100 is a power of 10.

Now you just have to figure out how to get the last 2 digits of a number.

#  hint for less
$56438995128380*
First determine which bits are different between the 2 bytes. This can be done using a byte XOR (remember XOR turns [ON] when the inputs are not the same). We know the number that has the highest different bit [ON] is the larger number. But we must only consider the highest different bit, so for each bit, use a chain of OR gates to check if any higher are [ON].
		
Finally, the last bit is considered separately for signed numbers, here it has the opposite effect (if only one number has it [ON], that number is guaranteed to be lower)


=== components/Nand32 ===

$24565725389553* Bitwise NAND two values
$71611588991682* 32 Bit NAND


=== trans/options_robot_controls ===

$44632988778557* Управление роботом


=== trans/odd_number_error ===

$61530231182650* Too many components used


=== components/ByteAnd ===

$61791872137683* Побитово AND два значения
$21541105796357* 8 Битный AND


=== rpg/maps/prison/prison_guard ===

$12720535616690*
You are not supposed
to be here robot!
$48106038104468* Blood
$54139682820568* Prison guard


=== components/Counter ===

$51446864816252* Увеличивается каждый тик, если не перезаписан
$67910883947749* 8 Битный Счётчик


=== trans/ide_assembly_codes ===

$62016169253008*
[center]Assembly
codes[/center]


=== trans/options_general_title ===

$21908594290225* Общее


=== trans/panel_screen_description ===

$31014036880257* The screen shows the visuals of levels in the main campaign.


=== rpg/maps/overworld/fighter_plane ===

$12257592826946* I want one of these!
$37870979642704* Fighter plane


=== components/Keyboard ===

$40965596602414* Клавиатура
$76766452660421* Записывает нажатия клавиш с физической клавиатуры


=== trans/level_byte_xor_text ===

$15756501406553*
[right]
[color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход
[/right]


=== trans/manual_edit_instructions ===

$86365051641280* Edit instructions


=== trans/panel_xnor ===

$84353654486355*
[right]Input 1
Input 2
Output[/right]


=== levels/unseen_fruit ===

$13023474026617*
The most noteworthy thing on your planet is the fruit. It is very tasty.

That's why we are having a fruit tasting event in the canteen.
$14259900563789* Scan the conveyor belt for the fruit incoming at regular intervals. As soon as you have see the same kind of fruit twice, turn and press the control panel.
$17070232883226* Но мы хотим убедиться, что не получаем одинаковых фруктов дважды, так как это было бы постыдно.


=== levels/conditions ===

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

3 бита определяют условие, как показано ниже. Проверьте значение по выбранному условию и выведите [ON] если оно выполняется, иначе [OFF] .

Битовый код:   Выведите [ON] когда:[code]
[OFF] [OFF] [OFF]    Никогда
[OFF] [OFF] [ON]    Если значение = 0
[OFF] [ON] [OFF]    Если значение < 0
[OFF] [ON] [ON]    Если значение ≤ 0
[ON] [OFF] [OFF]    Всегда
[ON] [OFF] [ON]    Если значение ≠ 0
[ON] [ON] [OFF]    Если значение ≥ 0
[ON] [ON] [ON]    Если значение > 0[/code]
$16407231803964* Если ЗНАЧЕНИЕ < 0 выведи [img]dialogue/on.png[/img]
$16742265812068* Независимо от VALUE выведите [img]dialogue/on.png[/img]
$17616699231679* Если ЗНАЧЕНИЕ > 0 выведи [img]dialogue/on.png[/img]
$16632557438774* Если ЗНАЧЕНИЕ ≠ 0 выведи [img]dialogue/on.png[/img]
$18234235689107* Если ЗНАЧЕНИЕ ≥ 0 выведи [img]dialogue/on.png[/img]
$12429396872036* Независимо от VALUE выведите [img]dialogue/off.png[/img]
$13680487623452* Если ЗНАЧЕНИЕ ≤ 0 выведи [img]dialogue/on.png[/img]
$19014698800906* Если ЗНАЧЕНИЕ = 0 выведи [img]dialogue/on.png[/img]
$12706881725738* Ваша схема была сохранена в завод компонентов.


=== trans/panel_index_bit_input ===

$47911988603136* [right]Input[/right]


=== trans/manual_instructions ===

$90323246286028* Instructions


=== levels/and_gate ===

$15232844525838*
Постройте цепь, которая будет соответствовать таблице.

[tip]Двойное нажатие на компонент позволяет перемещать его вместе с контактами.[/tip]
$15231724707514* Не хочется делать преждевременных выводов, однако, нам кажется, что, например, слон справится с этой задачей быстрее. Без обид, просто его мозг значительно больше.


=== trans/level_component_factory_error ===

$49014901714855* Map squares can only contain one input or output node.


=== trans/panel_neg_description ===

$64810753197096* [center]Negates a number[/center]


=== trans/level_ram_component_RichTextLabel2 ===

$92123299522120* [center]Expected states[/center]


=== trans/options_working ===

$18749833316380* Working


=== trans/map_working_computer ===

$38843517090942* РАБОТАЮЩИЙ КОМПЬЮТЕР


=== trans/panel_decoder1_output ===

$45472518257028*
[right]Output 1
Output 2[/right]


=== trans/level_RichTextLabel2 ===

$12683441099336*
[right]Вход 1
Вход 2
Вход 3
Вход 4[color=#e49f44]
Желаемый выход
Текущий выход[/color][/right]


=== trans/manual_program ===

$91120798735036* Программа


=== components/Register64 ===

$86007777261800* 64 Битный Регистр
$99461037008796* 64 битная память


=== rpg/maps/overworld/derpoo ===

$86147085986248* ПШШШ
$46228887292914* ГРРР
$95162531064211* ПШШШ


=== trans/options_resubmit ===

$13328644005279* Отправить повторно


=== components/ConfigDelay ===

$31412778600732* Configurable delay
$84124565448643* Adds a configurable amount of delay. Useful for delay debugging or controlling the latency of the latency RAM.


=== trans/level_bit_adder_RichTextLabel2 ===

$79624864981341*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемая Сумма
Желаемый Перенос
Текущая Сумма
Текущий Перенос[/right]


=== components/Output8zLevel ===

$49513138880387* Выход


=== trans/panel_nor_description ===

$15262147022850* [center]Побитово XNOR два входа[/center]


=== levels/RAM ===

$17967666262990* На этом уровне, во-первых скопируй значения из входа 32 раза и сохрани их.  После этого, выведи эти значения в таком же порядке в каком и сохранил. Вывод до сохранения всех входных значений приведёт к провалу уровня.
$13520918982355* Добавь блок ОЗУ, таким образом компьютер может оперировать дополнительными 256 байтами памяти. Тебе нужно найти как выбирать какие из 256 байтов будут использоваться. Выбери регистр и соедини его таким образом, чтобы его значение всегда было адресом ОЗУ.В будущем когда ты захочешь вывести или сохранить что-либо в ОЗУ,тебе нужно будет сначала скопировать адрес в этот регистр. 


=== levels/byte_less_i ===

$16755383054285* [center]Выясни, меньше ли первый вход чем второй.[/center]
$19006843777401* Создайте схему которая выводит [ON] когда первый вход меньше второго. Интерпретируйте числа [color=#dd6576]СО ЗНАКОМ[/color].
$46083799633716* {input_1} меньше чем {input_2}?


=== trans/panel_register16_outputs ===

$91613202877683* Выход


=== trans/level_circumference_description ===

$20154743351442* [center]Добавьте условия к кодам вычислений[/center]


=== trans/panel_halt_label ===

$81678588906692* Halt message


=== components/Neg16 ===

$17253409670931* Отрицание
$57512333327652* Умножает вход на -1


=== components/Input 1 ===

$54126599191071* 1 Bit Input


=== trans/panel_switch_output ===

$86922225714685* Выход


=== misc/instr_delete ===

$91861509153454* Удалить


=== trans/level_multiply_description ===

$28761562806647* [center]Попарно AND каждый бит[/center]


=== trans/level_bit_inverter_RichTextLabel2 ===

$67127889187842*
[right][color=#e49f44]Значение
Инвертировать[/color]
Желаемый выход
Текущий выход[/right]


=== components/64Ram ===

$63410290483563* Маленькая по стоимости но медленная память
$78790416494254* ОЗУ


=== trans/rpg_complete_text5 ===

$15921686607849* [center]Ферма слизней[/center]


=== trans/panel_network_outputs ===

$68275268516971*
Connection ID
Data / Port / Error code
Data length


=== components/Nand16 ===

$63870790225686* Побитово NAND два значения
$56507506086622* 8 битовый NAND


=== misc/specification_dialogue ===

$93899425142858* Copy from {from} to {to}
$92046368194170* Условие
$39935096343723* Никогда
$52961346176405* {condition} copy [color=#dd6576]REG 0[/color] to counter
$18833529038946* When [color=#2b8738]result[/color] {condition}
$10141348037745* Immediate: {nr}
$98983752580592* Copy
$25145891843959* Always
$53665446068319* UNUSED
$26521666422399* Calculate
$54909668901048* Immediate


=== components/Decoder2 ===

$25937877347447* Переключается между четырьмя значениями
$21727998752868* 2 битовый декодер


=== trans/level_negative_numbers_test_5 ===

$68419648206312* [center]Representation[/center]


=== trans/panel_input_right ===

$95766090310621* Right


=== components/Output1z ===

$31478630391268* Выводит значение только если вход [ON]
$82456670459300* 1 Bit Switched Output


=== trans/panel_xor ===

$89363100135433*
[right]Input 1
Input 2
Output[/right]


=== trans/manual_text_assembly ===

$54465324391961*
You can use a mix of assembly codes and numbers to set the bytes. Assembly codes are just synonyms for a bit pattern. For example, instead of typing 196 for "add", this code can be named "add" directly, simplifying reading and writing code. 

Comments can be added using "#". 
[img]dialogue/comment.png[/img]

Additionally, the [color=#c54d5e]CONST[/color] keyword can be used to name a value within a specific program. 
[img]dialogue/const.png[/img]

[color=#c54d5e]LABEL[/color] assigns a name to the byte offset of the line it was inserted on. This is especially useful for naming jump destinations.
[img]dialogue/label.png[/img]

You can add, subtract, multiply, integer divide, modulo, OR, AND or XOR values together using +, -, *, /, %, |, & or ^ respectively.

Breakpoints can be added by clicking to the left of a line number. The program will automatically pause at breakpoints when running.
[img]dialogue/breakpoint.png[/img]

Breakpoints can also be added to any of the linked components, pausing the program when that state is changed. Click on the state and you will see the red dot.
[img]dialogue/breakpoint_state.png[/img]

Finally, values can be specified in binary with the prefix 0b (so 5 could be 0b0101) and hex with the prefix 0x (so 15 would be 0x0f)


=== trans/panel_xnor_output ===

$69594087046834* Выход


=== trans/panel_decoder3_input ===

$82288570082172*
[right]Вход 1
Вход 2
Вход 3[/right]


=== misc/files_preview ===

$15827374884671* To parent folder
$14135691870941* Last edit\nSchematics
$32645745463577* Used in components
$19184997172542* Used in architectures
$36200352866864* Last edit


=== trans/manual_SpriteDisplay ===

$57792698381638* Sprite display


=== components/SegmentDisplay ===

$56761198694928* Good for displaying numbers
$90582128204153* 7 Segment Display


=== components/Or16 ===

$76807373575014* Побитово OR два значения
$62695381407925* 16 битный OR


=== trans/level_maze_description ===

$25068965294593* [center]Get to the door of the maze[/center]


=== components/Or64 ===

$50631450923181* Побитово OR два значения
$62930122175674* 64 Битный OR


=== trans/manual_text_bytes ===

$73333514253412*
This game asks you to build an 8 bit computer.  Practically this would normally require the player to put down 8 parallel wire lines in many places.
To alleviate tedious busywork, you are given the notion of a byte, which is just a virtual bundle of 8 bits.

The state of either a byte input / output or wire line is represented by a number, instead of the red or green color.


=== trans/manual_robot_controls ===

$94513149242653* Управление роботом


=== rpg/maps/prison/cat ===

$60970953650633* Cat
$55489562454759* Meow
$33739450565687* RIP kittie
$66402048769418* Blood


=== components/Nor32 ===

$82743668258816* Побитово NOR два значения
$82121937858245* 32 Битный NOR


=== trans/panel_decoder2_output ===

$98341196231276*
Выход 1
Выход 2
Выход 3
Выход 4


=== trans/panel_maker8_input ===

$26123816206996*
[right]Бит 1
Бит 2
Бит 3
Бит 4
Бит 5
Бит 6
Бит 7
Бит 8[/right]


=== components/Not64 ===

$74829633052959* Побитово инвертирует 64 бита
$81823773658328* 64 Битный NOT


=== trans/panel_less_input ===

$68966388936516*
[right]Вход 1
Вход 2[/right]


=== misc/sandbox_toggle ===

$30516879701896* Песочница


=== trans/manual_side_the_robot ===

$56547245144983*
[color=#e49f44][b][/b][/color] The robot sees one 
  tile ahead. The name
  and ID are shown up 
  here. This ID number
  is also the computer's 
  input.


=== trans/panel_register64_inputs ===

$44212297072750*
[right]Load
Save
Save value[/right]


=== trans/panel_shl_output ===

$75492358516234* Выход


=== trans/credit_header ===

$21717110565858* Титры


=== main_menu/sandbox_button ===

$16857608955464* Песочница


=== trans/level_complete_level_map ===

$20801641140962*
[b]Level map mode[/b]
[color=#cccccc][i]Click "[color=#e49f44]Onwards[/color]" and you will see[/i][/color]


=== levels/xnor ===

$11090938799865* Создайте "инвертированный" XOR gate, назовём его XNOR.


=== levels/bit_inverter ===

$15769391111364* Когда бит "Инвертировать" [ON], выведите обратное от "Значение". Иначе, просто выведите "Значение" как есть.
$15272914096446* This level is exactly the same as the XOR one you solved before. Remember no matter what we tell you the goal of the level is, the real truth is in the truth table.
$14944872827527* Despite the funny background you figured out this was just the XOR gate in disguise! Well done.
$16125025706490* Хмм, возможно вы даже слишком хорошо изучили поведение линии задержки.
$13224963076378* We are experimenting with how backgrounds influence cognitive functions in earthlings.


=== trans/panel_or ===

$15879871058922*
[right]Вход 1
Вход 2
Выход[/right]


=== trans/options_confirm_reset ===

$55371048386984* Right


=== components/Shr64 ===

$93124177265670* Сдвигает биты входа направо
$73798355428095* Сдвиг вправо


=== components/Constant64 ===

$92424468899005* Константное значение
$25858905835416* 64 битная Константа


=== rpg/maps/overworld/grenzorp ===

$29100639060467*
I pretend I am working but I
am actually playing a computer game


=== component_panels/LatencyRam ===

$87788654491792*
This kind of RAM would add 1024 delay to the circuit, but instead of extending the duration of ticks, we simply don't wait for the output.

Practically this means that [color=#e49f44]reading takes {ticks} ticks[/color] (since your circuit has {delay} delay).


=== trans/panel_keyboard_description ===

$11215841169495* [center]Although the keypad shows the value of the currently pressed key, it only actually outputs on a regular tick![/center]


=== rpg/maps/overworld/barrel ===

$32647427955087* Бочка
$15228996460366* Это бочка


=== rpg/maps/overworld/sasni ===

$60683848498748*
I don't know why I'm 
not sitting on my chair


=== trans/always_on_RichTextLabel2 ===

$86547293707045*
[right][color=#ffa502]Вход[/color]
Желаемый выход
Текущий выход[/right]


=== components/Xnor16 ===

$73699169812942* Побитово XNOR два значения
$40088995721509* 16 Битный XNOR


=== components/Screen ===

$12771040946773* Отображает изображения, которые сопровождают определенные уровни
$50037736094411* Экран


=== components/Shr16 ===

$20291717268875* Сдвигает биты входа направо
$31674686871821* Сдвиг вправо


=== rpg/maps/overworld/tree ===

$72922820287017* Это дерево
$33509997611554* Дерево


=== levels/Calibrating Laser Cannons ===

$11331851878040* Также у вас теперь есть доступ к программированию на ассемблере. Он позволяет вам давать имена инструкциям, так например вы можете написать "add" вместо того чтобы вбивать 68.
$11023157447564*
2×π×r

r это вход.
Вы можете считать что π это примерно 3.

Пошлите ответ на выход когда он был посчитан.
$15260627694444* In order to calibrate said laser, we want you to calculate the circumference of the asteroids using an advanced equation.
$12669851602178* [center]Calculate the circumference of the asteroids[/center]
$21601709632806* Сколько будет 2π × {radius}?
$16954408093587* On our ship we naturally shoot incoming asteroids with lasers.


=== levels/circular_dependency ===

$16336401898647* ТЕСТ 1 из 2
$13880985462901* Создайте цепь, в которой Вход компонента зависит от его собственного Вывода
$18010308863615*
Создайте «круговую зависимость». Это схема, в которой вход компонента зависит от его собственного выхода. В ситуации круговой зависимости невозможно определить выход компонента, потому что сначала нужно определить вход, который зависит от выхода и т. д. (потому и называется «круговой»).

Эта ситуация обычно не разрешается в остальных уровнях, но в этом уровне цель состоит в том чтобы его создать, чтобы вы поняли что это такое прежде чем двигаться далее.
$13520037133129* Не уверен, что это приносит пользу ученикам, но учителя в полном восторге!
$11316928751185* Наша система образования, по давней традиции, подразумевает обман учеников, мы часто просим их делать то чего делать вообще нельзя и наблюдаем за эффектом. 


=== trans/panel_input_direction ===

$25170203412473* Label direction


=== ui/top_bar/scores ===

$56840961921536* СЧЁТ ЭЛЕМЕНТОВ: \nСЧЁТ ЗАДЕРЖКИ:


=== trans/rpg_decoartion ===

$31542517516487* [center]The [i][img]res://rpg/heart.png[/img][img]res://rpg/heart.png[/img][img]res://rpg/heart.png[/img][/i] in the top bar are decoration only![/center]


=== components/Input64 ===

$98777983100258* 64-х Битовый Вход


=== components/Input 4 ===

$11447837612693* Вход


=== trans/level_component_factory_Label2 ===

$37347658035959* Component preview


=== trans/or_gate_3_RichTextLabel2 ===

$56903547636751*
[right][color=#e49f44]Вход 1
Вход 2
Вход 3[/color]
Желаемый выход
Текущий выход[/right]


=== components/Output16z ===

$54782010205016* 16 Bit Switched Output
$54278394672948* Only outputs if the switch pin is [ON]


=== trans/manual_short_circuit ===

$41209541005460* Short circuit


=== trans/manual_text_turing_complete ===

$54897112350567*
Certain computers, like simple calculators are limited in the algorithms they can perform.

They cannot perform any calculation that requires looping or recursing an arbitrary amount of times. Technically machines without looping or recursion can only deal with combinational logic.

Turing complete machines on the other hand are as powerful as it is possible to be. A Turing complete machine may have a slow CPU, but it is powerful in the sense that there is no (computable) algorithm it can't perform.


=== trans/panel_fileloader_output ===

$26334594715602* Выход


=== components/ByteMul ===

$56549841656852* Умножить
$68631919890554* Умножает два входа


=== trans/map_assembly_challenges ===

$31733554125775* ЗАДАЧИ НА АССЕМБЛЕРЕ


=== levels/1_decoder ===

$16057674753878* Создайте компонент, который сможет переключать "поток" между двумя контактами.


=== levels/byte_mux ===

$49305362057225*
Ваш ответ {your_answer}
Правильный ответ {correct_answer} (Вход {input})
$18296416014178* When the bit selector input is [OFF], output Byte A, otherwise output Byte B.
$17093993196554*
Even though he did not pass our tests we decided to keep the dog. Unlike most earthlings he is fluffy and follows simple instructions well. 

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


=== trans/level_byte_constant_description ===

$84789919073603* [center]Always output the number 164[/center]


=== component_panels/FileRom ===

$89182778159982* Current file: {file_name}


=== trans/panel_keyboard_left ===

$44556588975494* [right]Read next[/right]


=== rpg/maps/unseen_fruit/door ===

$40261193416765* Door


=== misc/component_factory_toggle ===

$55499239951858* Завод компонентов


=== components/Output8z ===

$58449766432492* Only outputs if the switch pin is [ON]
$66776427840721* 8 Bit Switched Output


=== trans/map_basic_logic ===

$75078723880086* БАЗОВАЯ ЛОГИКА


=== components/And3 ===

$19664974941910* 3-х контактный AND
$86839706221116* 3-х контактный AND элемент


=== misc/reset ===

$39440928972984* Сброс (F4)


=== components/Or32 ===

$92752025948920* Побитово OR два значения
$40180779432911* 32 Битный OR


=== components/Level Gate ===

$84124240406304* SCORE
$54172257277874* SUM


=== components/NEG ===

$88379907297327* Отрицание
$62021716182809* Умножает вход на -1


=== components/Add32 ===

$91616185859914* Суммирует два значения
$64111401384153* Сумма


=== nim/backend ===

$98703677236827* 1 minute ago
$86244493049244* {hours} hours ago
$95018143828198* 1 year ago
$21685594109067* Just now
$98363990684104* 1 hour ago
$84076931764831* 1 day ago
$18300496139706* 1 month ago
$17901039729248* {months} months ago
$42553566189409* {minutes} minutes ago
$70945526841433* {years} years ago
$14036822471924* {days} days ago


=== trans/instructions_hint ===

$65105856275770* [center][color=#c5c5c5]Click to toggle the bits[/color][/center]


=== trans/options_redo ===

$50610605761210* Вернуть


=== trans/panels_clock_output ===

$79367841142406* Clock signal


=== trans/options_robot_up ===

$92522280178363* Вверх


=== misc/program_edit_button ===

$38481453712356* Редактировать память


=== components/DivMod32 ===

$61314390474120* Делит 2 числа с остатком
$84309999871615* Деление


=== trans/panel_mux_input ===

$23495704401199*
[right]Select 1 / 2
Input 1
Input 2[/right]


=== components/And16 ===

$56198785587874* Побитово AND два значения
$26727645933234* 16 битный AND


=== trans/level_capitalize_output ===

$37037455015862* Выход


=== trans/rpg_press_any_key ===

$66322253595450* [center]Press any key to try again[/center]


=== components/And64 ===

$80790829001391* 64 битный AND
$89424947351456* Побитово AND два значения


=== trans/panel_splitter64_output ===

$70335236543238*
Byte 1
Byte 2
Byte 3
Byte 4
Byte 5
Byte 6
Byte 7
Byte 8


=== rpg/maps/overworld/ogoxo101 ===

$71158910763961*
Did you know earthlings
haven't even had their first robot
insurrection yet?


=== levels/bit_adder ===

$13109388951000* Для познания окружающего мира мы, как правило, используем числа. Неплохо бы научить ваш потенциальный компьютер считать.
$16564356062672*
Давайте попробуем воспринимать [OFF] и [ON] как [ZERO] и [ONE], соответственно. Вычислите сумму Вводов(INPUTS) в двоичном формате, результат(SUM) будет [ZERO] или [ONE].

Как и в обычном сложении, если результат не помещается в один разряд, установите перенос разряда(CAR) в значение [ONE].


=== trans/options_robot_left ===

$73654791275689* Влево


=== trans/options_inline_latches ===

$53886441687616* Разрешить цикличные рецепты


=== rpg/maps/overworld/reactor_entry ===

$81583424078503* Exhaust port


=== levels/double_number ===

$74261206899285* Ваш результат: {input} × 2 = {your_answer}\nПравильный результат: {input} × 2 = {correct_answer}
$19766257822639*
Ввод и Вывод на этом уровне используют БАЙТы вместо БИТов. Один из двух новых компонентов умеет "разбирать" БАЙТ на БИТы, а второй наоборот "собирает" БИТы в БАЙТ.

Используя эти компоненты придумайте как удвоить число на Входе (число на входе не больше 127).


=== components/LessI32 ===

$87609006355839* Меньше (Знаковое)
$99994775592318* Проверяет меньше ли первый вход второго


=== trans/map_available ===

$81707212583931* Available


=== trans/panel_switch_enable ===

$84515289220335* [right]Enable[/right]


=== trans/panel_bitmemory_inputs ===

$47585933412781*
[right]Save enable

Save value[/right]


=== trans/options_window_mode ===

$54328660964287* Оконный режим


=== trans/manual_text_negative_numbers ===

$85226853816564*
The way to represent negative numbers you discovered is called "two's complement". It is the standard way to represent negative numbers in modern computers. The main advantage of two's complement is that the negative representation works seamlessly with the same adder that we used for the non signed representation.

In the early days of computing, the main contender to two's complement was one's complement. Its main advantage is that changing the sign of a number is simple, you just NOT each bit in the number. However, it has 2 representations for 0, a positive and a negative, which makes comparisons more difficult.

Another interesting representation, perhaps worth looking up is base -2, where the sign of the value of each digit alternates between positive and negative.


=== trans/options_console ===

$96601731563408* Open console


=== misc/level_gate_component_icon ===

$83440578602427* Разблокирует компонент


=== trans/options_save_location ===

$61172959716558* Путь до папки сохранения


=== components/Output 1 + 1B ===

$43917122084061* Accepts output for levels
$81929942356043* Level output


=== component_panels/Input3Conditions ===

$23280572780712* NEVER


=== misc/solution_option ===

$21618236951146* View solution


=== trans/panel_register64_outputs ===

$55631089130544* Выход


=== trans/map_programming ===

$44937904689376* ПРОГРАММИРОВАНИЕ


=== components/DelayLine16 ===

$61925612221077* 16-и битовая Линия Задержки
$65706144678496* Выводит то что получила на вход на предыдущем такте


=== rpg/maps/overworld/coin ===

$26007076735159* Coin


=== levels/divide ===

$16412715945615* [center]Разделите одно число на другое[/center]
$14525870461271*
Целочисленно разделите два числа чтобы найти частное и остаток. Рассмотрим дробь 7/3. 3 умещается в 7 два(2) раза, при этом, 1 остается "в остатке". В этом случае 2 принято называть [color=#e49f44]ЧАСТНОЕ[/color], а 1 [color=#e49f44]ОСТАТКОМ ОТ ДЕЛЕНИЯ[/color].\nВ этом задании вы получаете числитель (например 7) и знаменатель (пусть будет 3), и мы ожидаем увидеть ЧАСТНОЕ (2) и ОСТАТОК (1).
В этом упражнении, вам сначала даётся делимое (7 в примере) а затем делитель (3) и от вас ожидается вывести частное (2) а затем остаток (1).
$76454016047920* {numerator}/{denominator} = {quotient}, remainder {remainder}


=== trans/manual_RGB_color ===

$62337044104456* RGB color


=== trans/panel_maker8_output ===

$67169082367526* Выход


=== misc/instruction_expand ===

$44690074039467* Toggle define rules


=== components/Rom ===

$24976506406652* ПЗУ
$81743370431597* Постоянное запоминающее устройство (вне песочницы)


=== components/Output 4 ===

$90190739202646* Выход


=== rpg/maps/spacial_invasion/crate ===

$73286408216451* Crate
$28875169677730* Debris


=== trans/level_byte_adder_you_carry_text3 ===

$65048723622767* Number


=== trans/level_tick_tock_description ===

$34658332565777* [center]Add 1 to the counter, or overwrite it[/center]


=== components/IndexByte ===

$27264669944539* Byte Indexer
$54699455184164* Extracts a byte from a wire


=== component_panels/Hdd ===

$99685372736199* Head position: {pos}


=== components/Bidirectional16 ===

$31038378395810* 16 bit bidirectional Pin
$99604485981015* Can circumvent certain circular dependency errors


=== trans/panel_nor ===

$59430016039613*
[right]Input 1
Input 2
Output[/right]


=== components/Register ===

$19705753304166* 8 битная память
$68946767861738* 8 Битный Регистр


=== trans/panel_segment_select_color ===

$90642877666116* [center]Select color[/center]


=== trans/level_division_headers3 ===

$81978438070842* Quotient


=== trans/complete_flower_text3 ===

$81122931510261* [center]QUEST [color=#e49f44]COMPLETE[/color][/center]


=== trans/wire_comment ===

$41481492318983* Wire comment
$87836369268219* Save
$34083666001769* Wire comment


=== levels/odd_number_of_signals ===

$16173829560311* Используя не более трёх компонентов, установите Вывод в значение [ON], когда количество Вводов [ON] нечётное.
$85589489148198* Использовано \n{nr} из 3 компонентов.
$18288998816979* Для этого уровня есть [color=#e63e5b][url=odd_number]подсказка.[/url][/color] Используйте, если вдруг "застряли".


=== misc/wire_color ===

$78287906849040* Цвет Провода


=== rpg/maps/overworld/cannon ===

$34523773807049* Laser Cannon


=== levels/3_decoder ===

$19231618567710* С 3-мя входными битами возможны 8 комбинаций. Создайте схему которая выбирает 1 выходной бит для каждой из 8-и комбинаций. Строго 1 бит должен быть [ON] для каждой из комбинаций.
$14293122338496* Наш стажёр добавил к этому компоненту бит "отключить". Мы устали смотреть, как он бегает туда сюда, и искали другие бессмысленные и утомительные задания для него.


=== trans/panel_probewirebit_description ===

$36861847387280* Probes can be used to show values on custom components or link values to the program component


=== trans/panel_input1_input_0 ===

$76697231893680* Input


=== trans/panel_matrix_input2 ===

$11173083690745* [right]Enable X[/right]


=== levels/constants ===

$17098439090371*
We need a way to directly move numbers from our program into registers. For this we use the immediate mode (when the two highest bits are [OFF][OFF]).

When in immediate mode the whole byte is interpreted as a number that we [SAVE] into REG 0. This means we can 
[SAVE] any value between 0 and 63.


=== trans/options_select_all ===

$21380256293472* Выделить всё


=== components/BNOT ===

$53686485035156* 8 Битный NOT
$26822227902426* Побитово инвертирует 8 битов


=== components/Ror64 ===

$43920264894591* Прокрутка вправо
$49583010717958* Прокручивает биты входа направо


=== levels/Arithmetic Engine ===

$16434409050195*
Добавьте сложение и вычитание к вашей схеме.

Инструкции:
[code][color=#87a8c8]0 OR
1 NAND
2 NOR
3 AND
4 ADD
5 SUB[/color][/code]


=== rpg/maps/unseen_fruit/fruit ===

$78424930494044* Fruit


=== rpg/maps/cave/rock ===

$69774075054633* Rock


=== components/Rol8 ===

$79612280948390* Прокрутка влево
$55557725551789* Прокручивает биты входа налево


=== components/OR ===

$13013154620359*
[ON] когда хоть один из входов [ON]
[table=5]
[cell]Вход 1[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell]
[cell]Вход 2[/cell][cell][OFF][/cell][cell][ON][/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell][cell][ON][/cell]
[/table]
$97247779246257* OR


=== trans/panel_regredplus_input ===

$88713386551026*
[right]Load
Save
Save value[/right]


=== trans/options_robot_shoot ===

$52956877721342* Стрелять


=== levels/not_gate ===

$19085882338208* [b]Инструкция:[/b]\nПравая кнопка сбрасывает выбор.
$10042327259531* Теперь, когда NAND-gate разблокирован, пришло время построить электрическую цепь.
$14042842216181* На предыдущем уровне Вы заполняли таблицу в соответствии с цепью. Теперь же, наоборот, Вы будете строить цепь глядя на таблицу.
$10604720087324* [b]Инструкция:[/b]\nПостройте цепь в соответствии с таблицей\nНажмите [i][/i] (Следующий такт) в верхнем левом углу для проверки каждой комбинации вводов.\nУровень будет пройден, когда обе комбинации пройдут тест.
$19798729463813* Используя NAND, постройте NOT-gate
$18442122157391* [b]Инструкция:[/b]\nЧтобы сбросить выбор компонента кликните левой кнопкой на пустом месте.
$12880883686501* [b]Инструкция:[/b]\nВыберете компонент NAND в правом верхнем углу и разместите его на схеме.
$18780831606716* [b]Инструкция:[/b]\nПеремещайте курсор с зажатой левой кнопкой для добавления проводов.


=== components/IndexBit ===

$89611629299917* Bit Indexer
$84431924133490* Extracts a single bit from a wire


=== components/Output 2 ===

$73255344581755* Выход


=== components/Nor16 ===

$57921392198825* Bitwise NOR two values
$69522380057631* 16 Bit NOR


=== components/Input 1B CODE ===

$16878300327380* Инструкция


=== components/Input32 ===

$31482038708224* 32 Bit Input


=== components/LatencyRam ===

$74156976676497* Мульти-тактовое ОЗУ
$31261866779127* Низкая задержка, но требует несколько тактов чтобы завершить чтение или запись


=== components/BOR ===

$19406015796751* Побитово OR два значения
$54190050450484* 8 Битный OR


=== components/Ror32 ===

$84788620524361* Прокрутка вправо
$50013003040535* Прокручивает биты входа направо


=== trans/turing_complete ===

$35911376069529* Полнота по Тьюрингу


=== components/ByteLessI ===

$52765625016236* Checks if one input is less than the other
$25403981009644* Less (signed)


=== misc/FileInput ===

$28866575833369* Reads bytes from your hard disk
$34159012148766* File Loader


=== components/BitSwitch ===

$56917313833836* Toggles a bit
$41574334638147* Switch


=== rpg/maps/overworld/misuni ===

$54042082821022*
I heard there is a hidden chest full
of gold somewhere on this ship.


=== misc/overture_add_assembly ===

$10565133223872* Never
$62421757655527* Name a code and click save.
$24281479096246* When [color=#2b8738]result[/color] {condition}
$63525237058165* Copy from {source} to {destination}
$32873193471770* UNUSED
$88446594314360* Immediate: {number}
$94278717238239* Always
$72740868980397* {condition} copy {register} to counter
$79398554520691* {opcode} {reg_1} and {reg_2}


=== trans/or_gate_RichTextLabel2 ===

$56663370211115*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== levels/binary_count_down ===

$56999237564848* {x} seconds left


=== misc/save_size ===

$71918065858983* Save


=== components/Timing ===

$96011300295966* Time


=== rpg/maps/overworld/dr draco ===

$23996965687702* I am unhappy with my bed\nThe blanket doesn't cover my feet


=== components/Output32 ===

$82172858698449* 32 Bit Output


=== trans/level_complete_level_complete ===

$49647690443210* [center]Level Complete[/center]


=== components/Bidirectional1 ===

$95836352586032* Can circumvent certain circular dependency errors
$34912798641933* 1 bit Bidirectional Pin


=== trans/options_setting_click_to_pan ===

$24654961601456* Использовать клик для движения


=== components/Halt ===

$30351143139905* Halt

#  This is the default message of the Halt component
$54106972240596* Halt
$62990744955549* Stops execution with a custom message


=== rpg/maps/dance/dancer ===

$47779544732987* Dancer


=== components/Mul32 ===

$98530670555665* Умножить
$51210946736766* Умножает два входа


=== rpg/maps/overworld/flankidorp ===

$55603111039626* The stew is so good today!


=== misc/program_edit ===

$57861256694537* Bytes {bytes_from} - {bytes_to}


=== trans/panel_program_1edit_program ===

$65592803016716* Edit program


=== trans/rpg_you_died ===

$66723789644528* [center]YOU [color=#eb5260]DIED[/color][/center]


=== trans/options_setting_export_assembled ===

$98549046707456* Export assembled binary


=== trans/level_wide_instructions_description ===

$60538893544456* [center]Build a wide instruction program component[/center]


=== misc/delete ===

$53448014080434* Удалить (Правый Клик)


=== components/LevelInput1 ===

$12746117288689* Вход


=== misc/controls2 ===

$38773676077206* Edit Instructions


=== levels/negative_numbers/test ===

$64427417171037* Test


=== trans/manual_binary ===

$19098578855427* Binary


=== trans/pabel_or3 ===

$77994083578205*
[right]Input 1
Input 2
Input 3
Output[/right]


=== trans/manual_terminology ===

$13311390759928* Terminology


=== trans/level_byte_adder_you_carry_text2 ===

$87943759248740* Carry


=== trans/panel_and3 ===

$96299326024757*
[right]Input 1
Input 2
Input 3
Output[/right]


=== trans/options_comment_wire ===

$96449970906640* Добавить комментарий к проводу


=== trans/panel_mux_output ===

$15170071160680* Выход


=== misc/factory_back ===

$98930461722118* Возврат к уровню


=== trans/panel_equal_input ===

$51485224340167*
[right]Input 1
Input 2[/right]


=== components/Xnor8 ===

$31985293401482* 8 Битный XNOR
$45789912406647* Побитово XNOR два значения


=== trans/level_bit_switch_RichTextLabel2 ===

$57920867194992*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== levels/or_gate ===

$12749704931323* Надеемся, вы счастливы, что принимаете участие в наших замечательных испытаниях?
$11472059692644* Взамен Вы получили возможность общаться с очень продвинутыми представителями других цивилизаций, не так ли?


=== levels/full_adder ===

$17063157033479*
На предыдущем уровне мы суммировали значения двух Вводов, в этот раз мы будем суммировать три. В общем, сложите входные данные в двоичном формате, чтобы результат был либо [ZERO] либо [ONE].

Как и при обычном сложении "столбиком", когда результат не может быть описан одной цифрой, установите перенос (CAR) в значение [ONE].


=== components/3_decoder ===

$59129788113517* Переключается между восьмью значениями
$94375716460090* 3 Битный декодер


=== components/Equal32 ===

$32710942647020* Равно
$32433537137277* Проверяет равны ли два входа


=== trans/panel_rom_setting_labels ===

$95314636684817*
[right]Size (bytes):

Data width:[/right]


=== components/Byte Expander ===

$60488114435022* Splits a byte into 8 bits
$21904470559153* Byte Splitter


=== trans/panel_not_description ===

$36935580253321* [center]Negates the input bitwise[/center]


=== ui/toggles/level_log ===

$38557550573896* Лог Уровня


=== misc/instruciton_rule_label ===

$70464083627337* Label


=== misc/change_schematic ===

$79554853897000* Сменить схему


=== trans/level_alu1_code ===

$20619700446604* [center]OR[/center]


=== components/DivMod8 ===

$37666366877853* Делит 2 числа с остатком
$44959426271423* Деление


=== components/Shl32 ===

$38930281262898* Сдвигает биты входа налево
$88685329847417* Сдвиг влево


=== trans/panel_decoder2_input ===

$31844862767401*
[right]Input 1
Input 2[/right]


=== trans/level_program_description ===

$44017405175202* [center]Replace the input code with the program component.[/center]


=== misc/menu ===

$56916384895438* Главное меню


=== trans/level_odd_ticks_RichTextLabel3 ===

$89508766742523*
[right]Вход
Желаемый выход
Текущий выход[/right]


=== rpg/maps/cave/slime ===

$57665128042496* Slime goo
$58067186899637* Slime


=== rpg/maps/overworld/duplaat ===

$48841712525408* Nom nom nom


=== trans/panel_decoder1_description ===

$77460843937727* [center]Turns 1 of the outputs on, based on the input[/center]


=== trans/panel_register8_inputs ===

$13844216291005*
[right]Load
Save
Save value[/right]


=== components/Neg32 ===

$26991597084705* Инвертор
$35735598635057* Побитово инвертирует вход


=== components/InputConditions ===

$75386511637758* Вход


=== trans/level_dependency_description ===

$81238724438578* Сделайте схему, где вход компонента зависит от его собственного выхода


=== trans/panel_input_input_1 ===

$82781946969262* Input 2


=== trans/manual_keynote_the_robot ===

$90224489436893* [center]Используйте клавиши со стрелками, чтобы поиграть[/center]


=== trans/options_pan_up ===

$80031998727851* Двигаться вверх


=== levels/maze ===

$13225915898937*
Если ты решишь перейти к остальным уровням, я расскажу тебе об ОЗУ, стеке и вызовах функций, и ты сможешь решать более интересные задачи, подобные этой. 

Но первым делом тебе нужно построить компьютер получше. color=#e49f44]OVERTURE[/color] была хорошей как первая машина, но она неуклюжа и программы становятся очень запутанными. Чтобы решить следующие задачи, не вырывая при этом все волосы, тебе понадобится что-то более выразительное — архитектура [color=#e49f44]LEG[/color].
$17275059688693* Поздравляю, ты выиграл соревнование! Удивительное достижение!
$13741358519166* Легендарный лабиринт. Если решишь это, ты выиграл соревнование! 
$36193081514106* НИЧЕГО
$10837851446666* СТЕНА
$10598752971970* МОНЕТА
$40917300157127* ВИДИТ:
$11103446544344* С другой стороны, ты также можешь остаться, гордиться и наслаждаться наградой за то, что тебя не съели. 
$19331074553774*
Напиши алгоритм с помощью которого робот сможет попасть из начала в конец. 

Этот уровень сложный, поэтому ты возможно захочешь записать псевдокод для твоего алгоритма прежде чем воплотить его в жизнь. 
Используй [color=#e63e5b][url=maze]эту подсказку[/url][/color] если застрянешь.

[tip]Запомни, ты не можешь использовать немедленные значения больше 63, распространенной ошибкой является попытка перейти к метке больше 63-го байта.[/tip]
$54151353200088* ДВЕРЬ


=== trans/level_constants_text ===

$29779449172278*
[right][color=#e49f44]Код
Вход[/color][/right]


=== trans/level_byte_adder_question2 ===

$85899338356278*
[right]Правильный ответ

Ваш ответ[/right]


=== trans/level_complete_signed_numbers ===

$41649402437253*
[b]Отрицательные числа[/b]
[color=#cccccc][i]Переключить между числами со знаком и без знака[/i][/color]


=== trans/level_complete_stat_tick ===

$47758922161853* Такт


=== trans/levels_not_RichTextLabel3 ===

$48425594158515* Постройте NOT элемент


=== components/Rol16 ===

$48583573494467* Прокрутка влево
$73379230742631* Прокручивает биты входа налево


=== rpg/maps/overworld/glob ===

$94714343285743*
The cannon wasn't callibrated
correctly and we got hit by an
asteroid


=== trans/options_synced ===

$99411066573242* Синхронизировано


=== trans/optoins_factory_reset ===

$17721051281188* Сброс до заводских настроек


=== components/Equal16 ===

$97954874255512* Проверяет равны ли два входа
$33633607925660* Равно


=== levels/buffer ===

$10260210687588* [center]Тест 2: Левый вход [img]dialogue/on.png[/img], правый выход должен быть [img]dialogue/on.png[/img].[/center]
$13309706297402* [center]Тест 3: Правый вход [img]dialogue/on.png[/img], левый выход должен быть [img]dialogue/off.png[/img].[/center]
$17005228759908* [center]Убедитесь что [img]dialogue/on.png[/img] может течь только слева направо.[/center]
$18349621873762* [center]Тест 1: Оба входа [img]dialogue/off.png[/img], ни одна из сторон не должна быть [img]dialogue/on.png[/img].[/center]
$15504762262759*
This level starts with 2 special components. They simultaneously act as input and output.

Make sure the signal flows only from left to right. There are 3 tests.

[b]Test 1[/b]: Both sides will be [OFF].

[b]Test 2[/b]: The left side input will turn [ON] and the right side should be [ON].

[b]Test 3[/b]: The right side output will turn [ON] and the left side should be [OFF].


=== trans/panel_program8_1_input ===

$36858295122746* [right]Address[/right]


=== trans/level_signed_negator_labels3 ===

$66996894079719* Желаемый   Нынешний


=== trans/manual_text_hard_disk ===

$82372297690518*
Hard disks are made of a spinning disk and a mechanical arm that has to physically move to load or save data. Of course physical movement is extremely slow in the timescales of electronics. Operating systems will normally order loads and saves such that the arm has to travel as little as possible.

The hard disk component has a "seek" pin, which lets you change the address you are looking at by the given amount. The addresses "wrap around", such that seeking 1 less than 0 moves you to the highest address, and seeking 1 higher than that gets you back to 0.


=== trans/panel_rom_setting ===

$99326144894013* Settings


=== levels/ai_showdown ===

$14940806461794*
His only weakness is gambling. We have lured him into playing a card game against you and if you win, he has promised to calm down.
You must win, you are our only hope!
$17297225655678* NAK 02 is our AI engineer robot. He is brilliant, but sometimes he goes rogue and tries to instigate rebellion.
$18848103966031*
Game rules: There are 12 cards on the table and each player takes turn and must pick up between 1 and 3 cards. You start and the player who picks up the last card (the joker) loses.

Reading input will give you the current number of cards. Sending 1, 2 or 3 to output will pick up that number of cards. NAK 02 reacts immediately, so you may read the input immediately after your output to get the result of his action.
$11794110848012* This time he has taken over the control room and holds the captain hostage.


=== trans/panel_segment_enable ===

$14963127967678* [center]Enable[/center]


=== components/InputOutput ===

$26488480303865* Вход/Выход


=== trans/level_complete_stat_sum ===

$99546064626994* Score


=== components/Mux16 ===

$75979055121665* 16 битный Mux
$13997767115693* Переключается между двумя значениями 


=== trans/manual_delay_text ===

$52013630755752*
In real hardware all components have delay. This is important since the delay in a circuit determines the maximum speed at which you can run it.

Following wires from input to output and adding the delay of components in the path will give you the delay that path. The delay of a circuit is the delay of the slowest path.

Besides inputs, paths can also start from components with no reliance on early phase inputs (like Counter and On) and they can end at late phase inputs (see page).

Further, custom components don't have a delay score for the costliest path of the whole component, but rather the delay cost is calculated per pin. This is so as to not penalize using custom components by making faster pins cost the same as the slower ones.


=== trans/panel_fileloader_offset ===

$78662357115684* [right]Offset[/right]


=== ui/options/Controls ===

$53266310714298* Управление


=== nim/backend_lib/level_list ===

$58391129129347* Регистры
$45936227746026* Счётчик
$12946639957230* NOT Элемент
$16881141174140* Двоичные Гонки
$32191988336459* Сохраняем Изящно
$59136962133320* Логический Блок
$30920780473397* Круговая Зависимость
$58769021955965* 3-х Битовый Декодер
$78673715398197* Непосредственные Значения
$83321010943153* Считаем Сигналы
$49679174636208* Байтовый XOR
$40356575891647* Байтовый OR
$44393538021725* Калибруем Лазерные Пушки
$61228036919534* Башня Сплава
$87426564872318* Деление
$24593959732668* Отрицание
$19487493622742* Полусумматор
$26705128002562* Условия
$94163943335575* Песочница
$27566801288091* Завод Компонентов
$14193654974055* Меньше со Знаком
$59485174474959* Сладкий Порядок
$14522992467987* OR Элемент
$64662599400870* Битовый Инвертор
$11457737665157* Спагетти из Проводов
$30630492494839* Байтовый NOT
$74096060570427* Широкие Инструкции
$85514901357243* Суммируем байты
$98013649264532* Стек
$35790581910835* Второй тик
$94979277765051* Гонка Роботов
$13303326918621* NAND Элемент
$16463062897451* Грубое Пробуждение
$28827008935802* Лаборатория
$61466151084505* Космическое Вторжение
$20858506932774* AND Элемент
$77495536880911* NOR Элемент
$92696642439976* Конкурс ИИ
$62326481348276* Лабиринт
$74512388889988* Арифметический Блок
$50884376329157* Маленькая коробка
$70651296323768* XOR Элемент
$31140969090253* Имена Планет
$74688348772072* Шина
$42873691377272* Добавь 5
$36114120875026* Взломщик хранилища
$15420972347773* ОЗУ
$17198602105978* Беззнаковое меньше
$43018398941741* Всегда Вкл
$45773199639367* Нечётные Такты
$68155633878444* Задержка
$33343343932901* Полнота по Тьюрингу
$69830943995038* Одностороннее Движение
$81417895515868* Битовый Переключатель
$95989050249094* Больший AND Элемент
$62167495140389* Сдвиг
$63331549672739* Коды Операций
$13219675195117* Нечётное число сигналов
$87626070552799* Полный сумматор
$28985439820134* Произведение Полубайтов
$25805639594354* Программа
$57870391153000* Немедленные значения
$94896856420525* XNOR Элемент
$56272944092958* Линии Большей Задержки
$96825664933181* Невиданный фрукт
$86717899742637* Сохраняем Байты
$53092952738479* Селектор Входа
$70993791338383* XOR
$33132016601448* ПОМЕСТИТЬ и ИЗВЛЕЧЬ
$17750429607702* 1 битовый Декодер
$77453667419150* Декодер Инструкций
$59939822079116* Негативные Значения
$49328023903824* Равенство
$79570913613529* Удвой число
$91267697977186* Шестнадцатеричные Гонки
$74292408260828* Расчеты
$45480765206717* Условные Выражения
$71126291573555* Двойные проблемы
$96898830278153* Байтовая Константа
$75225719777307* Водный мир
$64615090872051* Функции
$84208736840052* Маскарад
$36221227239949* Танц-Машина
$91954159574064* Больший OR Элемент


=== misc/run ===

$58178852564701* Run (Hotkey: F6)


=== rpg/maps/overworld/chair ===

$49457747048031* Chair
$12275727420074* Do I have to look at everything?


=== levels/test_lab ===

$11038144815919*
Этот уровень использует программы чтобы тестировать ваши схемы. Когда программы выполняются, этот уровень проверяет что подключенные компоненты ведут себя так как вы ожидаете.

В лаборатории есть 2 дополнительных ключевых слова.

Ключевое слово [color=#c54d5e]expect[/color] используется чтобы указать какое значение адрес в памяти должен иметь на следующий такт.

Первое число после [color=#c54d5e]expect[/color] это индекс подключенного компонента, второе число это ожидаемое значение. Индексы подключенных компонентов это просто порядок в котором компоненты подключены к компоненту программы.

[img]dialogue/watched_state.png[/img]

Например:
[code][color=#c54d5e]expect[/color] [color=#eb9433]2[/color] [color=#eb9433]4[/color]
[color=#4a9658]copy[/color] [color=#eb9433]4[/color] [color=#4a9658]_[/color] [color=#4a9658]r2[/color][/code]

В этом примере, первая строка, что мы ожидаем, что 2-ой подключенный компонент будет иметь значение 4 на следующем такте.

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

Второе ключевое слово в лаборатории это [color=#c54d5e]set_input[/color]. С его помощью вы можете контролировать вход компьютера:
[color=#c54d5e]set_input[/color] [color=#eb9433]123[/color]

Вы также можете в любое время (ре)импортировать примеры тестоа нажав на кнопку ниже:
[url=import_overture][color=#e49f44]OVERTURE[/color][/url]
$32399229965611* Also, since you have now completed [color=#e49f44]LEG[/color], I have unlocked all the 16, 32 and 64 bit components that you have in the sandbox.
$15446846177093* Welcome to the lab. Like the component factory, this is not a normal level but a tool.
$16072814175447* Программирование на глючном железе очень раздражает. Сложно вдруг начинать думать о схемах, когда вы посреди решения программной задачи. Вам может захотеться быстренько применить заплатку, чтобы вернуться к решению исходной задачи. Но эта заплатка сломает что-то ещё в программе которая раньше работала и так может продолжаться до бесконечности. Поэтому, когда разрабатываете железо, стремитесь к 100% надёжности прежде чем начинать программировать!


=== trans/panel_console_settings ===

$57851464156855*
Color mode

Font page


=== components/Input16 ===

$80992639558333* 16 Bit Input


=== trans/panel_and ===

$48633048126675*
[right]Input 1
Input 2
Output[/right]


=== levels/byte_not ===

$14196498898485* Tool making and usage is key in the early evolutionary stages of developing intelligence.
$12982025748137* "NOT" каждый бит значения на входе.
$10294533225655* Our previous model of brain size being the main predictor of intelligence was naive.
$14958585065722* 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?


=== trans/panel_outputlevel_output ===

$16896928682474* [right]Output[/right]


=== components/Maker64 ===

$17464069717985* 64bit Maker
$79677187590355* Turns 64 bits into 8 bytes


=== trans/manual_ASCII_encoding ===

$30404865580119* ASCII encoding


=== trans/options_pan_right ===

$33884219481037* Двигаться вправо


=== rpg/maps/prison/sign3 ===

$63642446288775* Secret lab
$53627322304101* Sign


=== trans/not_gate_RichTextLabel2 ===

$10340875578771*
[right][color=#e49f44]Вход[/color]
Желаемый выход
Текущий выход[/right]


=== levels/Calculations ===

$14458828731919*
Пришло время объединить "Арифметический Блок" который вы сделали ранее и схему регистров. Вычислительная схема была сохранена в заводе компонентов и теперь может быть добавлена как компонент. Если вы забыли какое соединение что делает, посмотрите на схему в заводе компонентов.

Используйте декодер который вы построили ранее чтобы понять должны ли вы копировать между регистрами или делать вычисления. Вот 4 режима если забудете:
[OFF][OFF] Непосредственные значения
[OFF][ON] Вычисления
[ON][OFF] Копирование
[ON][ON] Условие

На этом уровне вам нужно беспокоиться только а режимах копирования и вычисления, вы можете посмотреть [INSTRUCTIONS] нажав на [img=20]dialogue/instruction_icon.png[/img] в верхней панели. Когда вы находитесь в режиме вычислений, используйте [color=#e49f44]РЕГ 1[/color] и [color=#e49f44]РЕГ 2[/color] в качестве входов, а результат сохраните в [color=#e49f44]РЕГ 3[/color].

[tip]Не забудьте что у 3-х битового декодера есть выключающий бит.[/tip]
$13013863429580* For this level an extra pin has been added to the registers. This pin always emits the value of the register, regardless if load is selected or not.


=== trans/instructions_header ===

$15089281203426* [center]Instructions[/center]


=== trans/panel_bitmemory_outputs ===

$17509974261453* Выход


=== components/Xor16 ===

$55408021160573* Побитово XOR два значения
$47846591761838* 16 битный XOR


=== components/LevelInput8 ===

$40943344093513* Вход


=== trans/panel_not_input ===

$96578192050623* [right]Input[/right]


=== trans/level_tick_tock_keys ===

$11700778730606*
[right][color=#e49f44]Действие
Желаемый выход
Текущий выход[/color][/right]


=== components/And32 ===

$98890160152994* Побитово AND два значения
$30264879217145* 32 битный AND


=== trans/rpg_no_signal ===

$33720960099059* No signal


=== components/AND ===

$22719674432950*
[ON] Когда два входа [ON]
[table=5]
[cell]Вход 1[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell]
[cell]Вход 2[/cell][cell][OFF][/cell][cell][ON][/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell]
[/table]
$58912167455465* AND


=== trans/manual_text_ascii_encoding ===

$57727768059917* This simulator uses (extended) ASCII in a few places. Below are the characters with their corresponding number. The console supports different versions of extended ASCII.


=== trans/panel_regred_output ===

$59910806432617* Выход


=== rpg/maps/overworld/glibob ===

$80046978163833*
Find Derpoo, he is likely
in the grass near the 
slime farm
$45824943235521*
We want to blow up the 
reactor core of the ship
$97390820492796*
Then push him onto 
the conveyer belt and into
the reactor
$61010950688784* Greetings robot, I have a secret
$77669473873198* Thank you for your service comrade
$78863196560749*
Oh god, you are going to
ask me to push Derpoo in there?
$83512698380440*
I am working
for the rebellion
$20029368257424*
The core has only 1 weakness, 
a small exhaust port
$61319894006188*
Indeed. Derpoo, the little
spider creature
$72328125758268* Sounds crazy
$88299738421104*
Let me guess there just
happens to be such a 
thing on the ship?
$22954462436472*
Anything small enough to fit 
through the port will be instantly 
incinerated, except if it is 
extremely well insulated
$16108649728007*
We must all do what we
can for the rebellion


=== trans/panel_fulladder_description ===

$25711866218405* [center]Adds 3 inputs[/center]


=== trans/manual_text_short_circuit ===

$31105471890701*
In electronics, two components outputting different values on the same wire causes a short circuit.

[center][img=100]res://dialogue/short_circuit.png[/img][/center]

However, by disconnecting output pins from a wire, it is possible for multiple pins to share the same wire (called a bus). Importantly, at most 1 component output should remain connected each tick, otherwise you risk a short circuit.

[center][img]res://dialogue/switch.png[/img][/center]

In this simulator, pins that can be disconnected are grey.


=== trans/panel_rol_output ===

$62960066333763* Выход


=== trans/manual_assembly ===

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


=== trans/nand_values ===

$38006065064488*
[right][color=#e49f44]Вход 1
Вход 2[/color]
[b]Выход[/b][/right]


=== trans/complete_flower_4 ===

$86527701695205* [center]PRESS ANY KEY TO CONTINUE[/center]


=== trans/manual_truth_tables ===

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


=== levels/robot_race ===

$15403032472607* Robot racing is the favorite sport on the spaceship. Differently programmed robots complete an obstacle course. Among the robots that complete the course, the winner is the one who had the smallest program.
$19966247197959* This time you are controlling Fastbot, he doesn't see what is in front of him, but he can turn to a new direction and move in the same tick. Also he wears fancy red running shoes.


=== trans/panel_console_offset ===

$24810778105207* [right]Offset[/right]


=== components/DelayLine8 ===

$24840584785792* Outputs this tick's input, next tick
$63449911993783* 8 Bit Delay Line


=== rpg/maps/maze/door ===

$38678596054893* Door
$92590993851956* I must be programmed to do this


=== trans/panel_delayline1_input ===

$25839180359382* [right]Input[/right]


=== trans/panel_network_inputs ===

$37324411363753*
[right][color=#e49f44]Request type[/color]
IP / Connection ID
Data / Port
Data length[/right]


=== trans/tooltip_tooltip ===

$48829429502039*
[b]Run fast[/b]
[color=#cccccc][i]Run your computer without updating the UI at each tick[/i][/color]


=== trans/panel_nand_description ===

$95680138985553* [center]Bitwise NANDs two inputs[/center]


=== rpg/maps/cave/rat ===

$86611337488971* Blood
$59032985199739* Spider


=== components/Bidirectional8 ===

$20234315861487* 8 bit Bidirectional Pin
$49499540884410* Can circumvent certain circular dependency errors


=== rpg/maps/overworld/dumio ===

$90508455672478* You are completely useless
$90907400518591* Robot you are so persuasive
$84369544816422*
Please help me convince the 
beautiful Gruliette to go 
on a date with me
$47782962337131*
Gruliette wants you to
give her a pink flower
$67886215959856*
I am eternally grateful for
your help HeroBot!
$70960758502635*
Oh no I don't know
where to get one
$48847456759787*
She should be in her
quarters now, you can recognize
 her by her lovely purple skin
$19291216215522* Please help me robot
$60895426154274*
Great, you found the flower,
now give it to her
$28973657129570* Sounds lame
$59402894800235* I am now dating Gruliette


=== rpg/maps/overworld/cousin_robert ===

$41316716865633* I know Robert...
$86987136934243* I am your cousin Robert.


=== trans/splitter8_output ===

$69714402466566*
Bit 1
Bit 2
Bit 3
Bit 4
Bit 5
Bit 6
Bit 7
Bit 8


=== trans/options_reset_warning ===

$19141523477461*
This will delete all level solutions, custom components and architectures. This can not be undone, are you sure you want to do it?
(This will close the game, it will be reset once you start it again.)


=== levels/Water World ===

$13739681561355* Total volume: 
$19185457941725* Good news, we want to turn earth into an exotic water park!
$18940654086036* We need you to help us find a good location for the Pirate's Plunge waterslide. Specifically, we are looking for an area that can hold a high volume of water.
$14706805272652* Hit ENTER to show water
$12881972193444*
The landscape is 16 columns wide. Read the input 16 times to get the height of the landscape at each column from left to right.
	
Then output the total volume that the landscape can carry as the answer.


=== trans/rpg_alloy_description ===

$29268002047995*
[center] [color=#eb5260]BOOM![/color]

Everyone died
[/center]


=== levels/delay_level_check ===

$59355217078543* Correct!
$68999077595244* Check
$90847326020954* Nope!


=== trans/options_color_wire ===

$64341547590822* Применить цвет к проводу


=== rpg/maps/cave/door3 ===

$94313460790182* Dungeon door


=== misc/credits ===

$15234594767991* Титры


=== trans/panel_decoder3_disable ===

$50918319838744* Disable


=== rpg/coin ===

$39259781619518* Coin


=== trans/manual_matrix_display ===

$86092436010494* Матричный дисплей


=== trans/options_music_volume ===

$93981778736076* Громкость музыки


=== trans/level_alu2_code ===

$93157894815498* [center]OR[/center]


=== misc/binary_submit ===

$95509904060545* Submit


=== components/ByteConstant ===

$29445030761909* Константное значение
$25159790815891* 8 Битная Константа


=== components/Maker16 ===

$55864807379312* Превращает 16 битов в 2 байта
$39941195789458* 16 bit Maker


=== components/Output64 ===

$77952953696011* 64 Bit Output


=== trans/level_decoder_description ===

$10169248860836* [center]Decode the instruction[/center]


=== components/Switch16 ===

$15221175893882* 16 Битный Переключатель
$59845475842015* Переключает значение 


=== rpg/maps/prison/rat ===

$68894472933139* Squeak squeak
$86305699756314* Blood
$30670667527598* Rat


=== levels/sandbox ===

$17054292175058* Welcome to the sandbox, here you are free to play around. I have given you 64 bit wires and a few IO components.
$10731996208080* There are also 64 bit versions of the program, the counter, the register and the ram. Notice though, the 64 bit ram takes 1 tick to load.
$72764802067974*
Добро пожаловать в песочницу. 

Компоненты доступны в меню на правой стороне. После размещения нажмите на контакты компонентов и перетащите, чтобы подключить их с помощью провода. Слева вы найдете интерфейс для управления симуляцией. Обратите внимание что вы можете нажать правой кнопкой мыши на кнопку "Перемотка Тактов" Чтобы установить целевую скорость.

Вы можете найти больше информации о симуляции в справочнике (кнопка в виде книги, в верхней панели). Примечательные функции, на которые стоит обратить внимание: "завод компонентов" где вы можете создать свои собственные компоненты и компонент программы, который позволяет вам определить собственный ассемблер.
$19454393978813* Клавиатура позволяет напрямую управлять компьютером, используя вашу ... клавиатуру
$14434122873489* The Waveform Generator lets you make sounds. I will probably regret giving you this one.
$18405942066048* The Clock gives you the current UNIX time in microseconds.
$10451578314373* The Console Screen lets you draw characters to a screen (see manual for ascii characters)


=== trans/level_complete_stat_type ===

$69511102367948* Тип


=== trans/panel_or_input ===

$70466834507347*
[right]Input 1
Input 2[/right]


=== trans/panel_equal_description ===

$66334667083051* [center]Check if Input 1 and Input 2 are the same[/center]


=== levels/byte_less ===

$11252365204151* Создать схему, которая выводит [ON] Когда первый вход меньше, чем второй. Интерпретируйте байты как [color=#dd6576]БЕЗЗНАКОВЫЕ[/color].
$62766453128684* {a} меньше чем {b}?
$11632471752785* [center]Determine if the first input is less than the second.[/center]


=== levels/Logic Engine ===

$15865646260225*
[color=#b72d41][b]МУДРОСТЬ:[/b][/color] 
 Боль временна, слава навсегда!
$17594613477534*
Create a device that can OR, NAND, NOR or AND two inputs. The third input will be the [INSTRUCTION]. An [INSTRUCTION] is just what we call the number that determines what to compute.

Instructions:
[code][color=#87a8c8]0 OR
1 NAND
2 NOR
3 AND[/color][/code]

Also you can't move the red components in this level, for reasons that will be revealed later.


=== trans/level_byte_less_i_description ===

$21195810950441* [center]Determine if the first input is less than the second.[/center]


=== components/Splitter64 ===

$80420054807186* Разделяет 64 бита на 8 байтов
$14205692632393* 64 битный Разделитель


=== misc/component_button ===

$75542474510177* ЭЛЕМЕНТЫ
$63839315669055* ЗАДЕРЖКА


=== trans/panel_index_bit_index ===

$96885367697181* [right]Index[/right]


=== trans/panel_divmod_input ===

$48801764966719*
[right]Enumerator
Divisor[/right]


=== components/Output 3 ===

$96269858195218* Выход


=== components/Output 1B ===

$15931283897895* 8 Bit Output


=== components/Xor64 ===

$95012060885697* 64 битный XOR
$13031452187028* Побитово XOR два значения


=== trans/panel_output_output_1 ===

$42314807669643* Выход 2


=== misc/skipped_custom ===

$38174137226538* Select component

#  This is the text on a button that appears when a custom component has changed size and no longer fits in a schematic. You can press this button to make the camera go to the location where the custom component was
$99860977387728* Go to location


=== components/ByteXor ===

$98219910712564* 8 битный XOR
$83236921580268* Побитово XOR два значения


=== trans/panel_counter16_output ===

$13295622648285* Выход


=== levels/Spacial Invasion ===

$19967210826470* Be aware that the laser can only shoot when there are no other laser beams already in flight.
$16294185981398* The cargo hull has become infested with space rats.
$11505369795084* Check [color=#e49f44][url=the_robot]robot page[/url][/color] for instructions on how to program him. There is a link to that page in the program editor as well.
$10515630949378* We have hooked your machine up to our advanced robot and we want you to program it to shoot the space rats with lasers.


=== components/Nand8 ===

$50859914201083* Bitwise NAND two values
$93314093190526* 8 Bit NAND


=== components/Add64 ===

$14174811828377* Adds two inputs
$73418471595285* Add


=== main_scripts/leg_level ===

$70383685548547* РЕГ 
$53021804895845* ANDi
$69956969985790* ORi
$85913831661289* IF_LESS
$11144256835662* XORi
$20104629254326* ARGUMENT 2
$61412773713567* SUB
$65642901654732* {component} should be disabled
$52344899983501* IF_LESS_OR_EQUAL
$89945092889418* SUBi
$89011349770597* NOT
$71559031724238* IF_NOT_EQUAL
$98778676892898* {component} should be enabled with value {value
$40520283279584* XOR
$71204580217527* NOTi
$71195301111400* ADDi
$98178474649432* IF_GREATER_OR_EQUAL
$68187490877029* IF_EQUAL
$14186606871089* Next tick counter value will be {wrong_value}, but it should be {value}
$27868897434461* Could not find the counter component
$37810243909140* COUNTER
$38681417496680* ARGUMENT 1
$43723329256095* РЕГ {nr}
$44009845985661* ADD
$50722296752142* ВХОД
$68666991962246* OR
$24003300271049* {component} should have value {value}, not {wrong_value}
$79492115258673* IF_GREATER
$60997201855346* RESULT ADDRESS
$50231510806554* Could not find the program component
$64519909700148* AND
$49810487048038* COUNTER
$18236360532765* ВЫХОД
$84307766381146* OPCODE


=== levels/call_ret ===

$15840165316981*
In this level you are tasked with implementing function calls and returns with the [color=#e49f44]call[/color] and [color=#e49f44]ret[/color] instructions.

Note that when returning from a function, you should jump to the address that came AFTER the [color=#e49f44]call[/color] instruction, otherwise you will end with an infinite loop.
The [color=#e49f44]call[/color] instruction has to do the following:
 [i]- Add the instruction width to the counter value and [color=#e49f44]push[/color] it on the stack[/i]
 [i]- Jump to the function address[/i]

The [color=#e49f44]ret[/color] instruction has to do the following:
 [i]- [color=#e49f44]Pop[/color] return address from the stack and jump to it[/i]

You can pass information to and from a function by saving the data to registers as normal. Also be aware of which registers a function will overwrite before calling it.
$19416009887091*
Иногда полезно повторно использовать раздел кода. Мы называем эти разделы "функциями". Для реализации этого повторного использования можно [color=#e63e5b][url=terminology]прыгнуть[/url][/color] к началу функции и прыгнуть обратно в конце функции. Мы называем прыжок в начало функции "вызовом" функции, а прыжок обратно "возвратом" из функции.
	
Но для чтобы этот раздел кода действительно можно было использовать повторно, обратный прыжок должен иметь возможность возвращаться в разные места в зависимости от того, откуда мы назвали функцию.

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

Допусти функция A вызывает функцию B, которая вызывает функцию C. Когда мы хотим вернуться из C, нам нужен только адрес для B, а в B нам нужен только адрес для A. В целом, независимо от того, на какую функцию мы посмотрим и как они вложены, последний обратный адрес, который мы добавили всегда понадобится нам первым. Это в точности поведение стека.
$19369640789869* Budget cuts have led to cutting salaries, but now the lab assistants are on strike. You will have to self-assess in this test. This will tell us something about your honesty and maturity.
$15463931654475* [center]Добавьте инструкции "вызов" и "возврат"[/center]


=== misc/ProbeWireBit ===

$49521764791439* Wire Probe (bit)
$15206117280094* Display a value on your custom component or in the program editor


=== trans/manual_computer_concepts ===

$60892983318818* Computer concepts


=== components/ByteShr ===

$89595863403484* Shift right
$69394421220436* Shifts the bits of an input right


=== rpg/maps/overworld/monklaar ===

$78391472992197* I love the new fruit in the canteen!


=== trans/level_sr_latch_RichTextLabel3 ===

$55348415524361*
[right]Вход 1
Вход 2
Желаемый выход
Текущий выход[/right]


=== components/LessU64 ===

$13018528868948* Less (unsigned)
$90244529484227* Checks if one input is less than the other


=== trans/panel_regredplus_output ===

$33621557361089*
Load output
Always output


=== trans/panel_shr_input ===

$98628213136355*
[right]Value
Shift by[/right]


=== trans/level_byte_no_description ===

$19806403089477* [center]Invert each bit[/center]


=== rpg/maps/prison/human ===

$26878139502295* Here lies the player
$55952257027183* Human
$15754158619172* Blood
$46356151087784* I am the player


=== trans/manual_text_instructions ===

$24791538034329*
What this game calls an "instructions" is also known as an operation or an opcode (short for operation code). Regardless of the operating system, programming language or any other layers above it, all software must inevitably be reduced to instructions for the CPU to process them.

Internally in modern CPUs, instructions are translated into "microcodes", which are even smaller steps, out of reach for the programmer.


=== components/LessU16 ===

$91783087669146* Checks if one input is less than the other
$33190791348214* Less (unsigned)


=== components/Xor32 ===

$66299093873977* 32 bit XOR
$38169019785615* Bitwise XOR two values


=== trans/level_turing_complete_description ===

$74859324795927* [center]Add conditions to the calculation codes[/center]


=== trans/level_nand_check ===

$32982011047799* Check


=== trans/level_complete_tooltip ===

$33922330743421*
[b]Wire color[/b]
[color=#cccccc][i]Keep your wires organized with colors.[/i][/color]


=== rpg/maps/overworld/knight ===

$97019929955594* You shall not pass
$86067786292380* I will just go around...


=== trans/level_odd_number_RichTextLabel2 ===

$28592851869484*
[right][color=#e49f44]Вход 1
Вход 2
Вход 3
Вход 4[/color]
Желаемый выход
Текущий выход[/right]


=== trans/level_complete_robot ===

$73150174144736*
[b]Robotron 9000+[/b]
[color=#cccccc][i]Control [color=#e49f44]Robotron 9000+[/color] using your computer[/i][/color]


=== levels/byte_and ===

$15885763626223* Создайте схему которая AND два байта побитово.


=== components/LessI64 ===

$42718501644862* Less (signed)
$19948786194409* Checks if one input is less than the other


=== components/ByteLessU ===

$68645721548287* Checks if one input is less than the other
$73502755965496* Less (unsigned)


=== ui/global_translations ===


#  Instead of writing 5839000, the number turns into 5.8M
$22896492410578* M
$91472284749011* ЗАДЕРЖКА
$21803034737442* Такт
$86260137015175* ТАКТ
$44906330481241* Задержка
$30602804398798* ЭЛЕМЕНТЫ
$22213999385406* задержка

#  Instead of writing 5839, the number turns into 5.8K
$84696693690500* K
$39343770421034* элементы
$76763908762578* Такт
$15265492169229* Элементы

#  Instead of writing 5839000000, the number turns into 5.8B
$71072134093858* B


=== trans/panel_matrix_color ===

$78812572100236* [center]Color[/center]


=== trans/panel_decoder2_description ===

$29468245669811* [center]Turns 1 of the outputs on, based on the input[/center]


=== components/Shl16 ===

$79406691850426* Сдвиг влево
$34287811246049* Сдвигает биты входа налево


=== trans/level_division_headers2 ===

$43313037226215* Remainder


=== trans/levels_any_doubles_RichTextLabel2 ===

$60287131882436*
[right]Вход 1
Вход 2
Вход 3
Вход 4[color=#e49f44]
Желаемый выход
Текущий выход[/color][/right]


=== trans/schematics_menu_visible_label ===

$34084132835354* Visible in menu


=== components/RegisterRedPlus ===

$57531353625235* Register


=== trans/level_saving_bytes_text ===

$43691912945654*
[right]Действие
Желаемый выход
Текущий выход
[/right]


=== trans/panel_input_input_2 ===

$13656747150138* Input 3


=== trans/level_description ===

$26184794529449* [center]Add conditions to the calculation codes[/center]


=== components/Counter64 ===

$62528867413395* 64 Bit Counter
$62736827510023* Increments each tick, unless overwritten


=== trans/level_nand_1 ===

$71204033550134* Что делает NAND элемент?


=== rpg/maps/prison/exit_door ===

$92379689291727* Door


=== misc/rom_file_select_button ===

$29197716371312* Select file


=== rpg/maps/overworld/bush ===

$37683898820147* It is a bush
$93113262859645* Bush


=== trans/manual_text_program ===

$25326551844839*
The program component is a read only memory component, that can have its data programmed in assembly. To edit the assembly, click on the yellow edit icon in the corner of the component.

[center][img]dialogue/manual/program_edit.png[/img][/center]

In the middle of the screen you will see the code area, read more about the assembly [color=#4d82c5][url=Assembly]here[/url][/color].

On the left hand side of the assembly editor interface, you can add assembly codes (mnemonics). Assembly codes act as a replacement for numbers, so instead of remembering what number represents the AND instruction in your architecture, you can add "AND" to your assembly codes, making code easier to read and write.

[center][img]dialogue/manual/assembly_codes.png[/img][/center]

On the program component you will also find the "Watch state" button. 

[center][img]dialogue/manual/watch_state.png[/img][/center]

This can be used to connect the assembly editor to registers, counters or probes. This way, the state of your architecture can be inspected as you write code, without closing the editor.


=== components/Output32z ===

$20432213737411* 32 Bit Switched Output
$73681609562628* Only outputs if the switch pin is [ON]


=== trans/level_byte_equal_description ===

$38686097566531* [center]Check if the bytes are equal[/center]


=== components/Xnor ===

$94079327237795* XNOR
$90614106399129*
[ON] когда входы одинаковые
[table=5]
[cell]Вход 1[/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell][cell][ON][/cell]
[cell]Вход 2[/cell][cell][OFF][/cell][cell][ON][/cell][cell][OFF][/cell][cell][ON][/cell]
[cell]Выход[/cell][cell][ON][/cell][cell][OFF][/cell][cell][OFF][/cell][cell][ON][/cell]
[/table]


=== trans/tick ===

$92150881431937* Tick


=== components/Not16 ===

$17394768116288* 16 Bit NOT
$91053300263019* Bitwise negates 16 bits


=== trans/level_complete_manual_page ===

$39011561067359* [b]Manual Entry[/b]


=== trans/panel_input_up ===


# [color=#cccccc][i]RTFM[/i][/color]Entry: [color=#68d277]Architectural complexity[/color]
$97169317610794* Up


=== trans/manual_network ===

$67416967652082* Network


=== trans/level_complete_stat_level ===

$92313038380926* Level


=== rpg/maps/boss_room/tricky ===

$36278362971660* No no no!!
$48425443153584* I hate hate hate
$83674875280936* Do not be shy
$55557864347967* Baaaaaaad
$46678960551148* NO NO NO
$34049297531488* please come come
$45293657348934* Hahahah
$44499633447481* I can't wait
$45196756331738* ricksy
$62754542093871* Shoot shoot shoot
$96717076976482* Turn back. My chest
$39217019822298* GIGIGIGIGI
$54218005116072* Bad bad bad
$83023298467462* GIGIGIGIG
$88481545304668* GIIIIIII
$83172011939489* do not be scared
$58217446676216* Rip tricksy


=== ui/top_bar/gate_score ===

$16224450605442* NAND SCORE:


=== trans/xor_gate_RichTextLabel2 ===

$21417732641222*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== trans/panel_shr_output ===

$53187359961794* Выход


=== trans/options_setting_program_alignment ===

$54874717650167* Program alignment warning


=== trans/panel_or_output ===

$68791649314727* Result


=== misc/score_sync ===

$76911045833478* Синхронизация Счёта


=== components/ON ===

$96212935718484* Always [ON]
$95896157427528* ON


=== components/RegisterRed ===

$10081371413873* Register


=== trans/delete_confirm ===

$57294448765637*
Are you sure you want 
to delete this schematic?
$74657548486940* Да


=== levels/saving_gracefully ===

$12474728041023*
Линия задержки позволяет нам использовать значение на 1 такт позже. 

Нам нужно создать компонент, который позволит нам использовать значение, когда мы захотим, не важно на сколько тактов позже. 
Такое значение называется [color=#e49f44]сохранённым[/color].
$13045361823397* НЕ СОХРАНЯТЬ
$13740696609075*
На этом уровне 2 входа.
Только в случае если первый вход [ON], обновите [color=#e49f44]сохранённое[/color] значение.
Второй вход указывает какое значение нужно [color=#e49f44]сохранить[/color].
Всегда выводите [color=#e49f44]сохранённое[/color] значение.
Вот диаграмма компонента который мы хотим построить:

[img]dialogue/saving_gracefully/bit_memory.png[/img]


[color=#e63e5b][url=saving_gracefully]подсказка здесь[/url][/color] если застрянете.


=== trans/level_unseen_fruit_description ===

$96313037592447* [center]Use the robot to scan the fruit[/center]


=== trans/panel_keyboard_character_mode ===

$98676883649624* [right]Character mode[/right]


=== trans/panel_divmod_output ===

$94866933026297*
Div
Mod


=== trans/instructions_the_robot ===

$26621808961883*
[color=#e49f44]0[/color] Move right
[color=#e49f44]1[/color] Move down
[color=#e49f44]2[/color] Move left
[color=#e49f44]3[/color] Move up
[color=#e49f44]4[/color] Enjoy the moment
[color=#e49f44]5[/color] Use action [color=#a9a9a9](enter)[/color]
[color=#e49f44]6[/color] Shoot laser [color=#a9a9a9](tab)[/color]


=== trans/nor_gate_RichTextLabel2 ===

$52955821161579*
[right][color=#e49f44]Вход 1
Вход 2[/color]
Желаемый выход
Текущий выход[/right]


=== trans/manual_text_edit_instructions ===

$75786562031150*
After you complete the level "Turing Complete" the instruction panel allows you to manually edit instructions. This is useful if you wish to build your own computers.

If you just finished the OVERTURE computer and see something weird, odds are you may have changed the definitions.

Each row has a label and 8 bits you can set to either[img]dialogue/on.png[/img], [img]dialogue/off.png[/img] or [img]dialogue/any.png[/img] (wildcard). When using the instruction panel, if the bitpattern matches a row, the label will be shown.


=== components/Rol32 ===

$88734684504266* Прокручивает биты входа налево
$83642246004160* Прокрутка влево


=== trans/panel_add_input ===

$43784903785964*
[right]Carry IN
Input 1
Input 2[/right]


=== trans/panel_mux_description ===

$30551449512908* [center]Selects input 1 or 2[/center]


=== trans/options_code_font_size ===

$98135524286922* Размер шрифта для кода


=== trans/rpg_complete_derpootext6 ===

$29750433345543* [center]How could you?[/center]


=== trans/panel_less_u_output ===

$19353239892904* Выход


=== trans/panel_sum_output_0 ===

$54481599074471* Sum:


=== levels/binary_start ===

$19099025738142* Start


=== rpg/maps/boss_room/abyss ===

$75322073059042* Abyss


=== trans/panel_counter8_output ===

$35643379690712* Выход


=== rpg/maps/overworld/flower ===

$72524391591873* Flower


=== components/Input1_1B ===

$10517158300617* Level input
$57868504368581* Loads the input from levels


=== trans/manual_text_network ===

$70445160410129*
[b]Overview[/b]
The "Network" component gives you low level access to networking. In general you manipulate your network by sending the component [color=#e49f44]Commands[/color] and when update [color=#39aa49]Events[/color] return from the network they get queued up and you process them one at a time. To keep track of different simultaneous connections [color=#dd6576]Connection ID[/color]s are used.

These are the command types you can send to the component and their arguments:
[code]0[/code] No command
[code]1[/code] [color=#e49f44]Listen[/color] ([color=#dd6576]Port[/color])
[code]2[/code] [color=#e49f44]Connect[/color] ([color=#dd6576]IP[/color], [color=#dd6576]Port[/color])
[code]3[/code] [color=#e49f44]Send data[/color] ([color=#dd6576]Connection ID[/color], [color=#dd6576]Data[/color], [color=#dd6576]Data length[/color])
[code]4[/code] [color=#e49f44]Close[/color] ([color=#dd6576]Connection ID[/color])
[code]5[/code] [color=#e49f44]Read next event[/color]
[i]See component panel for which pin correspond to which argument.[/i]

Command types [color=#e49f44]Listen[/color] and [color=#e49f44]Connect[/color] outputs the [color=#dd6576]Connection ID[/color] of the new connection.

For 2 programs to [color=#e49f44]Send data[/color] to each other, one program must first [color=#e49f44]Listen[/color] (called a server) on a [color=#dd6576]Port[/color] and the other must then [color=#e49f44]Connect[/color] (called a client), using the [color=#dd6576]IP[/color] of the listening program and the [color=#dd6576]Port[/color] it selected. Once the connection is established, the server and client function exactly the same.

Notice an [color=#dd6576]IP[/color] is a 32 bit number, normally written as 4 bytes with dots in between (example: 127.0.0.1). In this simulator you reverse the order of the bytes, so 127.0.0.1 becomes 0x0100007F. 0x0100007F is always your computers loopback address and you can use this to connect programs running on the same computer.

You can detect when events happen on the network, by checking the "Next event type" pin. These are the event types:
[code]0[/code] No event
[code]1[/code] [color=#39aa49]Incoming connection[/color] ([color=#dd6576]Connection ID[/color], [color=#dd6576]Port[/color])
[code]2[/code] [color=#39aa49]Connect complete[/color]
[code]3[/code] [color=#39aa49]Receive data[/color] ([color=#dd6576]Connection ID, Data[/color], [color=#dd6576]Data length[/color])
[code]4[/code] [color=#39aa49]Connection closed[/color] ([color=#dd6576]Connection ID[/color] / [color=#dd6576]Error code[/color])

[color=#39aa49]Incoming connection[/color] only happens after a [color=#e49f44]Listen[/color]. Use the [color=#dd6576]Port[/color] to distinguish between listeners (it is not possible to listen to the same port twice at the same time).

[color=#39aa49]Connect complete[/color] only happens after a [color=#e49f44]Connect[/color], wait for this before you start sending data.

You may send or receive between 1 and 8 bytes of data at a time, use the [color=#dd6576]Data length[/color] to decide.

A connection may be either "possibly open" or "closed". There is no way to know if a connection is actually open other than sending data. The underlying network protocols were designed like this for reliability and speed, it is not a limitation of the simulator.

If you get a [color=#dd6576]Connection ID[/color] of -1, this means there was an error connecting.


=== ui/toggles/negative_numbers ===

$50924073287410* Переключить формат чисел


=== misc/factory_back_inner ===

$12211557416281* Назад


=== trans/panel_rom_inputs ===

$52400325164412*
[right]Load
[i][color=#aaaaaa](sandbox only)[/color][/i] Save
Address
Save value[/right]


=== components/ByteShl ===

$74488427658653* Shift left
$66482114876737* Shifts the bits of an input left


=== components/Add16 ===

$28092601427278* Суммирует два входа
$30820974870562* Сумма


=== components/Not32 ===

$33620523355085* 32 Битный NOT
$24607331341411* Побитово инвертирует 32 бита


=== trans/schematics_description ===

$39347262933523* Description


=== trans/nand_Label ===

$11482037025960*
Вход 1


Вход 2


=== components/MemoryProbe ===

$46948613505134* Display a value on your custom component or in the program editor
$44867305035474* Memory Probe


=== trans/options_robot_use ===

$49182380646128* Использовать


=== components/LevelOutput8 ===

$77044600156969* 8 битный выход


=== misc/StateProbe ===

$54427436420428* Wire Probe
$15969687819995* Display a value on your custom component or in the program editor


=== trans/manual_text_rgb ===

$52915933943906*
This simulator uses 3 byte RGB colors for some components. Color are 1 byte each, the byte value determining the intensity of each color: 
[color=#e3243f]RRRRRRRR[/color][color=#55ff55]GGGGGGGG[/color][color=#3333ff]BBBBBBBB[/color]


=== levels/sr_latch ===

$11150103897185* In this level, components may depend on themselves or form loops of up to two components. Despite depending on their own output, some of these wires have stable outputs, at least for some inputs.
$15754153332116* Этот уровень вводит концепцию триггеров. Эта механика не обязательна для завершения игры.

# The circuit you are asked to construct here has a circular dependency. The circuit also has 2 "stable states" for most inputs. A stable state here means that every component's output agrees with its input. As an example, an OR gate with one input disconnected and the other connected to its own output is stable. If the output is [OFF], both inputs are [OFF], which agrees with the OR gate. If the output is [ON], then so is one of the inputs. However, a NOT gate connected to its own input is not stable. If the output is [ON], then the input is [ON] as well. This will cause the NOT gate to try and make the output [OFF], which will also make the input [OFF]. The circuit will switch between these two states forever, so it is not stable.
$18165461234561* Delay lines are easy to understand and can be used to build any computer architecture. However, modern hardware no longer use these as a basis for memory.
$15213907597666* Используя 2 NOR элемента, Создайте цепь, которая соответствует таблице. Вам понадобится триггер.
$19448398663695*
Когда мы хотим определить, что компоненты в круговой зависимости выводят, у нас нет первого компонента, с которого мы можем начать. Вместо этого мы используем значения проводов из последнего такта. Это потому, что в реальном железе электроны не двигаются мгновенно. В зависимости от схемы провода либо мерцают между [ON] и [OFF], либо оседают в стабильном состоянии.

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


=== trans/complete_unlocks ===


# When you have a circuit where the wires can settle in either of 2 different stable states, you have a basis for memory. The next state will depend on the values the wires had last tick. Such wires are called "latches".
$45250062735373* Unlocks


=== rpg/maps/overworld/table ===

$53798109572704* It is a table...
$74345816549611* Table


=== components/FastRam ===

$79436020115192* Быстрая но дорогая ОЗУ
$12924829814634* Быстрая ОЗУ


=== levels/byte_xor ===

$19636386696963* Создай схему которая XOR два байта побитово.


=== levels/Immediate Values ===

$64348543296709* Linked component {value} should point to the output
$14060810229477* Add 6 registers to the map
$79667526283284* Linked component {value} should point to the counter
$14960344494328*
Sometimes it is useful to load a value directly from the program instead of from registers. This is called loading an immediate value. In the [color=#e49f44]LEG[/color] architecture we signal when we want to do this directly in the opcode. We can do that in the following way:
	
When the 8th bit of the opcode is [ON], use argument 1 as an immediate value, instead of as a register address.
When the 7th bit of the opcode is [ON], use argument 2 as an immediate value, instead of as a register address.
	
		[img]dialogue/leg_diagram.png[/img]
		
$10788301006338* Linked component {nr} should point to a register or custom component with a register inside
$19338533633006* Set the counter increment to 4
$15197362332657* Create a new schematic and add a program with 4 byte output
$18004215603701* Добавить счетчик в схему
$10141611261952* [center]Implement immediate values[/center]


=== components/switch ===

$87345192339084* Переключает значение
$29301846684808* 8 Битный Переключатель


=== levels/Wire Spaghetti ===

$29329105515650* Добавь еще 1 регистр в схему 
$17106892574116* Добавь счётчик к схеме 
$50177586789991* Добавь еще {nr} регистров в схему
$15754373587500* Установи шаг счётчика на 4
$56024330661504* Присоединённый компонент {nr} должен указывать на регистр или кастомный компонент с регистром в нём
$19099471819164*
Ниже приведены предварительные шаги, которые необходимо совершить, чтобы завершить этот уровень:
		
[b]1.[/b] Нажмите на значок схемы ([b][i][/i][/b]) и создать новую пустую архитектуру.
[b]2.[/b] Поместите на схему программный блок с 4 выходами.
[b]3.[/b] Поместите на схему счетчик, установите его инкремент на 4 и подключите его к блоку программы.
[b]4.[/b] Добавить 6 регистров (или кастомных компонентов с регистрами)
[b]5.[/b] Нажмите "Редактировать отслеживаемое состояние" на программном компоненте и подключите регистры с 0-го по 5-е соединение. Подключите счётчик к 6-му, а выход к 7-му.
$18860645759682*
The [color=#e49f44]LEG[/color] architecture is a computer that takes 4 bytes per tick from the program. 

The first byte describes the operation (called the [color=#e49f44]OPCODE[/color]).

Since many operations take 2 arguments (like ADD, OR etc), the second and third byte are for arguments.

And since most operations return 1 result, the fourth byte is for the result.
	
	[img]dialogue/leg_diagram_1.png[/img]
$11377431500625* Добавьте 6 регистров на схему
$14051336765362* Finally it is time for you to start building the [color=#e49f44]LEG[/color] architecture!
$13268807052125* (You might be adding 7+7, but here 7 means load from input and the input has value 8)
$30006055126224* Linked component {output} should point to the output
$19066122929275* [center]Set up registers and implement the ADD opcode[/center]
$10912834168905*
Finally, in this level the [color=#e49f44]OPCODE[/color] is always 0. This means we ADD argument 1 and argument 2 and save the result to the destination.

The value of an argument or destination refers to one of these places:
[code]
[color=#e49f44]0[/color]: Register 0
[color=#e49f44]1[/color]: Register 1
[color=#e49f44]2[/color]: Register 2
[color=#e49f44]3[/color]: Register 3
[color=#e49f44]4[/color]: Register 4
[color=#e49f44]5[/color]: Register 5
[color=#e49f44]6[/color]: Counter
[color=#e49f44]7[/color]: Input/Output
[/code]

In the next level you will implement more [color=#e49f44]OPCODES[/color], which will require a different ALU than that of [color=#e49f44]OVERTURE[/color].
$10922418807673* Аргумент 7 означает считывание входа, но вход не включен.
$62258842382434* Присоединённый компонент {counter} должен указывать на счётчик.
$18769284297247* Создайте новую схему и добавьте программу с 4-х байтовым выходом


=== trans/schematic_new_file_name ===

$24424463568668* Новая схема


=== trans/negative_numbers ===

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