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


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

$22440157378882* Capitalize

$36850349097673*
The inputs in this level are sentences encoded as ASCII ([link="Computer concepts/ASCII encoding"]see manual[/link]). Each word 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 and space.



=== campaign/capitalize/test.si ===

$37137490280093* You did not read character {character} from the string yet

$52976618691411* Output should have been {char}, not {output}



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

$78380513477546* Click the spec.isa tab to see the other jump instructions



=== campaign/maze/hint_0.txt ===

$10423837492124* [left][b]Turn left[/b][/left]

$18756407685566* [left][b]Turn right as long as there is a wall ahead[/b][/left]

$51767168505953* [left][b]Repeat[/b][/left]

$63325960964451* [left][b]Step forward[/b][/left]



=== campaign/nim/meta.txt ===

$19817843844200* Nim

$47072576894526* Also, schematics are shared across architecture levels, so you can solve this with either Overture or Symphony. Click the file icon in the upper left corner to change shematics.

$53912339443439*
In this level you need to beat the AI in a simple card game. These are the 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. The opponent reacts immediately, so you may read the input immediately after your output to get the result of his action.



=== campaign/nim/test.si ===

$27262056315410* You lost!

$29769682738867* You may only take 1, 2 or 3 cards

$42147812867053* You won!

$49299754864790* Hit enter to take {card_count} cards

$64085588225039* Hit enter to see what the oponent does

$85502688597126* Use the arrow keys to take cards

$90440029783715* You took the last card



=== campaign/nim/ui.txt ===

$79378464416004* Use the arrow keys to pick cards



=== campaign/odd_number_of_signals/test.si ===

$36609687959808* {count} of 3



=== campaign/odd_number_of_signals/ui.txt ===

$74552564780850* Components spent



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

$15531830527231* r3

$17025449350330* r5

$42538649427331* Program

$47858891143005* r2

$57877356797542* DoneCount

$59383212597903* r0

$76878335565401* r4

$78214997465973* Counter

$89909032864119* r1



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

$35331465118106* Overture

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

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

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



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

$24524168624111* Counter memory should be {expected_value}.

$35224907301551* Register {reg_i} should have value {value}.

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



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

$22306447815263* Optimize Overture



=== campaign/preview_architecture/meta.txt ===

$46932595269557* Hub Preview



=== campaign/preview_foundry/meta.txt ===

$78694087261378* Hub Preview



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

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

$83969937380086* Random Number Generator

$90664310835282*
In this level you only get one input, we call this the initial seed. The seed is put through the following steps to produce a pseudorandom number.

[b]32 bit xorshift RNG:[/b]
[box][left]
temp1  = seed  xor (seed  lsr 13)
temp2  = temp1 xor (temp1 lsl 17)
result = temp2 xor (temp2 lsr 5)
[/left][/box]

Finally output "result" and then use it as the seed of the next iteration.



=== campaign/rng/test.si ===

$77825640575531* The next seed should be {result}, not {output}



=== campaign/saving_bytes/test.si ===

$60269032570207* Expected output {expected_output}.



=== campaign/score/hint_0.txt ===

$71529804454649* Make a byte version of half adders, then add Input and 1



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

$75346310834154* The [T] signal is constant, so we can simplify the circuit there



=== campaign/score/hint_solution.txt ===

$50044461577278* The last AND result is unused, so we can safely delete it



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

$34375498293137* This level introduces efficiency scoring, which is based on time and energy.

$38383835706006*
To solve this level, add 1 to the input number and output the result.

If the result doesn't fit in 8 bits, discard the bit that doesn't fit.

Do this with no more than 40 gates and 10 delay.

$40775045205647*
The cost of the components you have unlocked are based on your score in the levels where you unlocked them.

If you want to improve the cost of a component, you can go back and optimize your solution in the level that unlocks it.

In fact, to beat this level, your XOR gate should cost 3 gates and have a delay of 2.

$59781832788691*
Each of the basic gates (NAND, NOR, AND, OR) have a delay of one, meaning they take a unit of time to complete.

However, different parts of a circuit can happen simultaneously, so we only have to wait for the slowest path, called "the critical path".

Click the hourglass in the upper right to see the critical path.

$70169388789757*
These equations are equal, yet not the same:

((A + B) + C) + D
(A + B) + (C + D)

They produce the same result, but parallelism allows one to be faster than the other.

$72877144436007*
Each of the four basic gates consume one unit of energy in each unit of time.

So the total energy cost of your solution is the delay of the critical path multiplied with the number of fundamental gates used.

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

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

In fact, we measure beauty in units of energy.

$85893273691863* Objective beauty



=== campaign/score/test.si ===

$15039285047182* Output should be {expected}.

$46433606967015* Add 1 to {cycle}



=== campaign/score/ui.txt ===

$85765173996083* Increment the input by 1



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

$23043475637417* In this level your job is to sort 16 numbers. Read the input 16 times one by one, sort them and output them smallest to largest.

$53593011909329* Delicious order

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



=== campaign/sort/test.si ===

$25018662661467* Index {index} in the sorted list should be {expected}, not {output}



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

$17745932940157* You should have read address {expected_value} from the Main Memory, not {actual_counter}. You must have not updated the counter correctly last cycle.

$21000091589999* Output should have been {expected_output}, not {output_value}.

$22469925230320* Persistent Memory address {i} is supposed to have value {expected_value}, not {value}

$29078414770160* The 'zr' register should always be zero (address 0 in the 'Register File').

$60841927788704* The time component shouldn't have been enabled since the last time_0 instruction's execution.

$70740757119887* {register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}

$74663212299349* Main Memory address {i} is supposed to have value {expected_value}, not {value}

$85916420035294* Output should have been enabled.



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

$29798404581087* Stack

$68315222097089*
The challenge of this level is to implement a common programming structure called a "stack". You are supposed to do this in assembly. You can do two things with a stack:
[left]
  [color=#66ccff]PUSH[/color] - Adds a number to the stack
  [color=#66ccff]POP[/color]  - Removes the last added number from the stack
[/left]
You can think of the stack data structure like a physical stack of plates in a busy restaurant. The dishwasher will [color=#66ccff]push[/color] plates on top of the stack and the chef will [color=#66ccff]pop[/color] them off.

Read the input in this level to get the next operation. 
A non-0 input is a push, in this case store the value so it can be popped later. 
A 0 value is pop, remove and output the last number you stored.

$90806029597852*
Since the stack is so useful for programming, a "push" and "pop" instruction will be added to the next Symphony level. Both of these are synonyms for two other instructions and they both use the "sp" register (short for stack pointer) to keep track of the stack.

"push" is a synonym for:
[box][left]
sub sp, sp, 4
store_32 [sp], %value
[/left][/box]
"pop" is a synonym for:
[box][left]
load_32 %destination, [sp]
add sp, sp, 4
[/left][/box]
You may notice that "push" subtracts from "sp" so that the stack grows downwards from the high addresses. This leaves the low addresses for you to use as you see fit.



=== campaign/symphony_10_stack/test.si ===

$35910734851012* {expected_value} is supposed to be on top of the stack, not {actual_value}.

$77129086767196* You did not output the last popped value.



=== campaign/symphony_10_stack/ui.txt ===

$35820332981557* Implement the stack operations for Symphony



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

$28617596738571*
Sometimes it is useful to reuse a section of code. We call these sections "functions". To reuse code, jump to the start of the function and jump back again at the end. We call jumping to the function "calling" the function, and jumping back from the function "returning". 
  
But for this section of code to actually be reusable, the return jump will have to be able to return to different locations, depending on where we called the function from.

We could store the counter value to a register before jumping to the function and use this value when returning. However, if done this way, a function would not be able to call another function, since this would overwrite the original return address.

Say function A calls function B, who calls function C. When we want to return from C, we only need the return address for B and in B we only need the address for A. In general, regardless of which function we look at and how they call each other, the last return address we added is always the first one we will need again. This is exactly the behavior of the stack.

$41513122622358* Functions

$42088257134737* This level is only here for you to observe how functions work, there is no test. Be sure you read the assembly and step through to the end so you understand how everything works. It will be necessary for future levels.

$56028205797304* As functions likely change the value of registers, we may want to push values on the stack to save them and pop them off again afterwards to restore them. It isn't important whether this is done inside or outside the called function, however it is good practice to establish a convention for this (called a "calling convention"), such that all functions are compatible with each other.

$64240772623662*
In this level a "call" and "ret" instructions have been added to your list of instructions. Both of these are complex synonyms.

"call" is used to enter a function. It pushes the address of the next instruction on the stack (by reading the counter and adding an offset). It then jumps to the start of the function.

"ret" is used to return from a function. It pops the return address off the stack and jumps to it.



=== campaign/symphony_11_functions/new_program.asm ===

$10902022971046* Except for r1 and r2, a function should return with all registers having the original value

$11016773181609* The last multiply call already put the result in r1

$14412657671278* Push r3 and r4 so we can use them within the function but still restore them before returning

$18457350783754* First input is 2

$21553876748933* Accumulator

$21707356398727* Load two numbers given from the level

$27088227324511* Remaining right hand side of the multiply

$27592840036827* Second input is 5

$30769341721428* Left hand side of the multiply

$32724600358227* Restore outside value

$33479507858734* Calculate 2 to the power 5

$42717933764735* r1 and r2 are used for arguments, r1 is the function result

$42740851915963* Remaining power

$43461252553161* Calling convention:

$59000482794872* Should output 32

$63878589013500* Keep multiplying until "remaining power" is 0

$65068280556611* Restore outside values

$68500361393623* Give names to registers to make things easier to read

$70634976221207* Push r3 so we can use it within the function but still restore it before returning



=== campaign/symphony_11_functions/ui.txt ===

$51514522389782* Observe how function calls work



=== campaign/symphony_12_budget/meta.txt ===

$68182570848466* The objective of this level is simple, reduce the delay of Symphony to 175 or below. Go back through previous levels and improve scores if you have to.

$69806637130600* Fast Symphony



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

$17052191264122* Lower the delay of Symphony



=== campaign/symphony_4_immediates/hint_solution.txt ===

$61996387838431* The purple wires implement the immediate mode



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

$46968415562883* Immediates

$74993560224545*
Update the architecture to look like this diagram:

[image="symphony_diagram_2.png"]

$85471608475185*
Sometimes it is useful to load a value directly from the program instead of from registers. A value directly encoded in an instruction is called an immediate value. With [color=#e49f44]Symphony[/color], we can replace argument B with an immediate in any instruction. This is done by setting the fourth bit to 1 and encoding the value in the last two bytes like so:

[left]
              [color=#ff9800]M[/color] = Mode
              [color=#ff6680]O[/color] = Opcode
            [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Immediate mode
              [color=#ffe666]D[/color] = Destination register
              [color=#66ff99]A[/color] = Argument A
              [color=#66ccff]B[/color] = Argument B (possibly immediate)
              [color=#bbbbbb]0[/color] = Unused / zero
[/left]

Instruction encoding if argument B is not an immediate value:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

Instruction encoding if argument B is an immediate value:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]



=== campaign/symphony_4_immediates/ui.txt ===

$90023711394112* Add immediate values to Symphony



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

$30888506574129* The orange wires implement the JUMP mode



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

$39122914366346* Jumps

$57225943470132*
These are the [color=#ff9800]Modes[/color] of [color=#e49f44]Symphony[/color]:

0 IO
1 ALU
2 JUMP
3 RAM

In this level we implement the JUMP mode. As always the instruction encoding is as follows:

[left]
              [color=#ff9800]M[/color] = Mode
              [color=#ff6680]O[/color] = Opcode
            [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Immediate mode
              [color=#ffe666]D[/color] = Destination register
              [color=#66ff99]A[/color] = Argument A
              [color=#66ccff]B[/color] = Argument B (possibly immediate)
              [color=#bbbbbb]0[/color] = Unused / zero
[/left]

Instruction encoding if argument B is not an immediate value:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]
Instruction encoding if argument B is an immediate value:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]

In JUMP mode, the value in the register specified by [color=#66ff99]argument A[/color] are the flags and should be compared with the condition, which is the [color=#ff6680]opcode[/color]. To compare them, use the "cond" custom component you built earlier.

If the flags match the condition, overwrite the counter value with [color=#66ccff]argument B[/color].



=== campaign/symphony_5_jumps/ui.txt ===

$88550064597726* Add jumps to Symphony



=== campaign/symphony_6_ram/hint_solution.txt ===

$78759770178685* The purple wires implement the interaction with the main memory



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

$41276257356528* RAM

$43585926436336* Note that ports act from top to bottom. A load port will read after a store port if it is placed lower, but before if it is placed higher. This matters when the ports load and store to the same address. In general all ports wait for store ports above them and therefore have a dependency on them. In this level the load ports must be above the store ports or you will get a circular dependency.

$65386575947998*
In this level we implement the RAM mode. For now, there are six [color=#ff6680]opcodes[/color] in this mode:
[left]
                          [color=#ff6680]0[/color] load_8
                          [color=#ff6680]1[/color] load_16
                          [color=#ff6680]2[/color] load_32
                          [color=#ff6680]3[/color] [color=#bbbbbb]reserved[/color]
                          [color=#ff6680]4[/color] store_8
                          [color=#ff6680]5[/color] store_16
                          [color=#ff6680]6[/color] store_32
                          [color=#ff6680]7[/color] [color=#bbbbbb]reserved[/color]
[/left]
The 'load' instructions should load the value from program memory at address [color=#66ccff]argument B[/color] and store the result in the [color=#ffe666]destination[/color] register.

The 'store' instructions should store the value in the [color=#66ff99]argument A[/color] register to program memory at address [color=#66ccff]argument B[/color].

The numerical suffix determines the width in bits of how many bits should be written to or read from memory, so a 'load_8' instruction should load 8 bits of data & a 'store_16' should store 16 bits of data starting at that address.

$69462908463194*
In this level we add loading from and storing to the same memory that is used for the program. We want to be able to read and write 32-bit words, 16-bit words and 8-bit bytes, so add 3 extra load ports and 3 store ports to the RAM component.

Insert the newly provided port components in between the 'Instructions' load port & the 'Main Memory' RAM component.

$73426457129430*
Once again, these are the [color=#ff9800]Modes[/color] of [color=#e49f44]Symphony[/color]:

[left]
                            [color=#ff9800]0[/color] IO
                            [color=#ff9800]1[/color] ALU
                            [color=#ff9800]2[/color] JUMP
                            [color=#ff9800]3[/color] RAM
[/left]

And the encoding looks like this:
[left]
              [color=#ff9800]M[/color] = Mode
              [color=#ff6680]O[/color] = Opcode
            [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Immediate mode
              [color=#ffe666]D[/color] = Destination register
              [color=#66ff99]A[/color] = Argument A
              [color=#66ccff]B[/color] = Argument B (possibly immediate)
              [color=#bbbbbb]0[/color] = Unused / zero
[/left]

Instruction encoding if argument B is not an immediate value:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]
Instruction encoding if argument B is an immediate value:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]



=== campaign/symphony_6_ram/ui.txt ===

$51703376131802* Add load and store instructions to Symphony



=== campaign/symphony_7_ssd/hint_solution.txt ===

$28652182390799* The new purple wires implement the interaction with the persistent memory



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

$23620554597332*
In this level we add an another RAM component, but for storing data between restarts.

Then add two new memory instructions 'pload', 'pstore', which should function like the 32 bit variants of the load and store instructions from the previous level, but accessing the 'Persistent Memory' RAM component instead of the program memory.

These are all of the [color=#ff6680]opcode[/color] encodings when in memory mode:
[left]
                        [color=#ff6680]0[/color] load_8
                        [color=#ff6680]1[/color] load_16
                        [color=#ff6680]2[/color] load_32
                        [color=#ff6680]3[/color] pload
                        [color=#ff6680]4[/color] store_8
                        [color=#ff6680]5[/color] store_16
                        [color=#ff6680]6[/color] store_32
                        [color=#ff6680]7[/color] pstore
[/left]

$76705374584193* Persistent Memory



=== campaign/symphony_7_ssd/ui.txt ===

$89678353617146* Add persistent memory to Symphony



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

$28545157055801* Pushes %a on to the stack. This instruction is a synonym for:   sub sp, sp, 4   store_32 [sp], %a

$34859363394334* Moves a value to %a.

$40508048121543* Toggles the bits of a value and stores it in %a.

$48332460366102* Returns from the last function call. Overwrites the flag register. This instruction is a synonym for:   load_32 flags, [sp]   add sp, sp, 4   jmp flags

$53941960758392* Moves a value to %a from %b.

$54469754973269* Pops %a off the stack. This instruction is a synonym for:   load_32 %a, [sp]   add sp, sp, 4

$55357258069734* Toggles the bits of %b and stores it in %a.

$57504570243305* Negates a value and stores it in %a.

$57788320241950* Calls %a. Overwrites the flag register. This instruction is a synonym for:   counter flags   add flags, flags, 20   sub sp, sp, 4   store_32 [sp], flags   jmp %a

$72894099288447* Negates a %b and stores it in %a.



=== campaign/symphony_8_io_devices/hint_solution.txt ===

$48843089545173* The new grey wires implement the interaction with the IO devices



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

$29247683714165*
So far IO mode has had only 3 instructions, but now it is time to add several more. This is the updated list of IO instructions:
[left]

[b]Index  Name     Operands       Description[/b]
  0    nop                     Do nothing
  1    in       dest           Input
  2    out      src_A          Output
  3    keyboard dest           Read keyboard value
  4    screen   src_A, src_B   Set screen setting
  5    time_0   dest           Read lower 32 time bits
  6    time_1   dest           Read upper 32 time bits
  7    counter  dest           Read counter value

The details of each new instruction:

[b]keyboard[/b]
The keyboard component has two output pins we want to read "Key Down" and "Key Value". Merge them into one value like so:
D = Key Down
V = Key Value
[highlight]0000000D VVVVVVVV[/highlight]

[b]screen[/b]
The screen has three inputs, "Enable", "Setting index" and "Value". When executing the [highlight]screen[/highlight] instruction, "Enable" pin should be [T], "Setting index" should be the first operand and "Value" the second operand.

[b]time_0[/b] and [b]time_1[/b]
The time component outputs the time since 1st of January 1970 in nano seconds, as a 64 bit number. Since this architecture only deals with 32 bits, reading the value is split into two instructions. However combining times from two different cycles can produce weird behavior. To avoid this issue, only [highlight]time_0[/highlight] actually reads the time component. It stores the upper half for [highlight]time_1[/highlight] to read later. This means that [highlight]time_1[/highlight] should read 0 if [highlight]time_0[/highlight] has not been executed yet.

[b]counter[/b]
Read the value of the Counter custom component you built earlier.
[/left]

$67457044658869*
For this level you need to place three new IO components: the Screen, Time and Keyboard components.

Also link the screen to the RAM component named "Main Memory".

$78454657849319* IO Devices



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

$10169473219025* 1 second = 1_000_000_000 nano second = 0x0000_0000_3B9A_CA00

$11549850182703* y coord

$16841324702501* Robot

$22405816552972* direction

$23344524651761* update next cycle

$25470599373421* draw ghost on new position

$25474902303790* increment direction

$26430777268618* robot down

$28230914387367* coin

$29369794309677* TODO: handle coin and empty differently

$31647601023268* Sprite addresses jump table

$33327526977497* Ghost

$33450896282702* placeholder

$34042928458359* modulo 3

$35647670060017* empty

$36791496238134* 2 * instruction length = 8

$37230877526029* ghost right

$37647180126584* draw robot on new position

$38695844571056* overflow

$40959483784712* robot right

$45301848117435* ghost down

$50069163371185* ghost left

$50501450979711* robot up

$55263046326109* hit wall -> cancel movement

$55673115734516* padding to preserve 32 bits alignment

$61792431057747* x coord

$62236058044269* [padding]

$64851396075477* 2 * instruction size = 8

$67744627518982* coin

$69893421560125* robot left

$72366220861688* ghost up

$73803385159414* so the first value is 0

$75937352730902* 0.5 second = 500_000_000 nano second = 0x0000_0000_1DCD_6500



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

$18975134592059* Output should have been enabled.

$26871980917450* Persistent Memory address {i} is supposed to have value {address}, not {value}

$29202969341865* Wrong time output (did you remember to cache the time on the time_0 instruction?)

$29909286517152* The 'zr' register should always be zero (address 0 in the 'Register File').

$30816527015736* Output should have been {expected_output}, not {output_value}.

$31400969059429* {register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}

$41024505081324* You should have read address {counter_value} from the Main Memory, not {actual_counter}. You must have not updated the counter correctly last cycle.

$42960087865089* Screen setting {i} is supposed to be {expected_value}, not {value}

$46474751521062* Link the screen to the "Main Memory" component (use the little red button in the corner of the screen).

$78917660933958* Main Memory address {i} is supposed to have value {address}, not {value}



=== campaign/symphony_8_io_devices/ui.txt ===

$63394282539727* Add IO instructions to Symphony



=== campaign/symphony_9_aliases/label.txt ===

$18099138932731* Persistent Memory

$35059654572638* time

$79162322081640* keyboard

$80985404567327* screen



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

$20456965663323* Instruction Aliases

$41535895646297*
Like previous levels, this level introduces new instructions. However, in this level you are not supposed to add additional hardware, but instead change the assembly specification to reuse already existing instruction hardware for new instructions.

Click on the "spec.isa" tab in the Assembler window and study how instructions are implemented. Then add the following three new instructions:

[b]mov[/b]
"[b]mov[/b]" is short for "move" and takes two operands. Move the value of the second operand to the first.

[b]neg[/b]
"[b]neg[/b] is short for "negate" and takes two operands. Negate the value of the second operand and store the result in the first.

[b]not[/b]
"[b]not[/b]" takes two operands. Not the value of the second operand and store the result in the first.


Once these instructions are added, the assembly code will be valid and running it will complete the level.



=== campaign/symphony_9_aliases/new_program.asm ===

$71972143734450* Hex value



=== campaign/symphony_9_aliases/test.si ===

$44683006232656* The first instruction should have moved hex value 0x1235 to r1.

$67087756287234* r3 should have had hex value 0x1234

$83123414679662* r2 should have had hex value 0xffffedcb.



=== campaign/symphony_9_aliases/ui.txt ===

$13320201556243* Create the ISA spec for the new instructions



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

$20911185106374*
In this level the first input contains flags and the second argument contains a condition. We need to test if the flags match the condition. Compare the three flag input bits pairwise with the first three bits of the condition input. If any of the three pairs the inputs are both [T], the condition is matched.

Finally, the 4th bit of the condition inverts the result. So if the condition matched, but the 4th bit is [T], output [F].

$90224867995967* Condition Match



=== campaign/symphony_condition_test/test.si ===

$33181499064044* Result should never be Z state

$73051402798264* The correct output is {U1 result}



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

$23374750315066* In the game "Towers of Hanoi", you must move a stack of disks from one peg to another. The challenge is that only one disk can be moved at a time, only the top disk on a stack can be moved, and a larger disk can never be placed on top of a smaller one.

$29450953142176* Tower of Hanoi

$62636370223849*
Amazing, you finished all our tests! Look how far you have come from the NAND gate. 

Humans are truly worthy of joining the Galactic Federation.

$72724057674158*
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 magnet with the following outputs:
[left]
                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
[/left]

Play with the magnet manually by using the arrow keys to move and enter to toggle.

$81427576809439*
This level is difficult, but it is a good opportunity for you to use functions. In fact the following solution to the level contains a "recursive function", which means a function that calls itself.

[b]Tower of Hanoi algorithm:[/b]
[box][left]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)
    }
}[/left][/box]

[tip]Remember to push register values to the stack to store them in function that changes them.[/tip]



=== campaign/tower/ui.txt ===

$39419617008574* Oops, you put a larger disk on a smaller one!



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


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


# com_delay_line_word's output pin
$40182352594863* Result


# com_level_output_8_pin's description
$41781588125341* Four bit output


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



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

$12097260550100* Value {num} outside of range for {field}

$15585581119466* Instruction '{instruction_name}' is missing the bit field definition

$15728875852508* Fail to parse {file}

$18981788561705* Expected whitespace here

$19131785861372* Recursive inclusion of: 

$19581803133960* Expected '{syntax}' after '{partial_instruction}'

$21828993759952* Unknown instruction

$23413102374088* Invalid instruction

$30066682696902* Assert {source} did not match

$33085034295813* Expected either a number or a symbol

$35071857261934* Expected some whitespace after 'as'

$35210741057769* Can't understand this line

$37770431994640* Invalid instruction

$39195841380612* Label {name} is already declared

$42442531119863* {constant_name} is already declared

$45433710484419* Expected a size before the number, like: U64 {number}

$47300717145684* Missing '=' after 'const'

$48895355188042* Expect a number literal after '@'

$51460031660101* Could not assemble instruction on resolving label {name}: {err}

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

$53378617686677* Value {num} outside of range for {field}

$57794055991905* Error evaluating assert {assertion}: {err}

$58979769991732* Expected a new line after 'include'

$59248806788382* Cannot reference private label {name}

$60515742509356* Expected a number after a size declaration

$60631582636278* Undefined label {name}

$62050046600010* The file name {name} cannot be used as referencable alias, declare another alias using the keyword 'as', e.g. 'include .A as A'

$66273157704409* Missing a '{field_type}' operand here

$66575346967082* File does not exist: 

$67922577781529* Only positive multiples of 8 bits are supported for now

$68530592279217* Expected a valid operand name, got '{operand_name}' among {all_operand_names}

$69537550553443* Expected at least one whitespace character after '{partial_instruction}'

$71714150108621* Error evaluating operand %{operand_name}: {err}

$76017808702292* The width of instruction '{instruction_name}' is {width} bits, but only multiples of 8 are supported

$79977943868423* '{field_string}' is not a '{field_type}'

$80097289956044* Expected some whitespace between the size and the number, like U{size} {number}

$82512572175623* Unexpected end of instruction after {partial_instruction}

$83023561541280* Was expecting a label name here

$83649060120708* Signed numbers are not supported

$84557608492963* Unknown code found after instruction: 

$86607635528717* Undefined constant {field_string}

$87525828760679* Failed to resolve pattern ({err}): {resolved_pattern}

$90294506138532* Definition value must be either a number or a field



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

$14037712136328* Operand {op} not found

$15525193700799* Unrecognized prefix operator 

$16677833364088* Unrecognized identifier: %{operand}

$17795651801484* Expected ':'

$18996202754936* Expected ')'

$21791372106633* Expected '('

$36919792698704* Instruction pointer not available

$49919016022369* Unrecognized address: ${identifier}

$50863314907270* Expected ')'

$62520916869207* Expected ','

$76203559781109* Expected ']' or ':', got '{sep}'

$86940018019179* Invalid identifier: %{operand}



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

$11703098452145* Unknown setting name {name}

$11824708197936* Expected a valid field/pattern name, got '{operand_name}'

$15904571494199* Expected slice syntax after field/pattern reference in bit pattern

$16564670893367* Was expecting a pattern name here

$18247681204565* Expected ')' after assertion

$18304638469397* Expected a non-empty string to start line comments

$19678805612580* Repeat field references do not match

$20574862674671* Expected newline after virtual field

$20981379307111* Fixed bits in %{operand} do not match

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

$24713798894610* Expected top bound not to exceed 32767

$25123045290962* Was expecting the [instructions] header here

$25249187420360* Expected the name of an option or start of the next section

$25285447732570* Expected top bound not to be less than bottom bound

$26426549472884* Too many virtual operands

$27111936748508* Expected a closing parenthesis after the pattern type

$28197258085607* Expected slice syntax after field/pattern reference in bit pattern

$29837913233106* Expected newline between instructions

$31223930569837* Expected top bound not to be less than bottom bound

$32763965727763* Sign extension bits do not match

$33105996916812* Patterns can only invoke those defined before them

$33504435568130* Could not interpret virtual operand %{variable_name}: {err}

$33645913580119* Too many field types, at most {max_field_types} are allowed

$33890983338825* Expected a list of strings

$35053289858864* Too many patterns, at most {max_patterns} are allowed

$35468867558322* Expected newline after section header

$39427635035157* Duplicate setting '{name}'

$40392382190976* Expected a bit pattern for {field_name}

$40815956642962* Expected slice syntax after base-16 number reference in bit pattern

$42160516340132* Expected either '(' or '[' after the operand name, like: {variable_name}(immediate), {variable_name}[pattern()]

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

$43708359021513* Pattern must have a body

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

$45267257140327* Expected newline after section header

$45631078896174* Expected top bound not to exceed 32767

$47258389995911* Expected ',' between pattern parameters

$48321097736953* Expected hex number not to exceed 32767 digits

$48639756889210* The width of the instruction cannot be 0

$48942522553057* Expected slice syntax after field/pattern reference in bit pattern

$50971737349470* Pattern operands not supported in disassembly yet

$51752498682665* Field name '{field_name}' not defined

$52261961290701* Flipped slice syntax after base-16 number reference in bit pattern

$52710717731997* Was expecting a newline here after syntax declaration

$55289908013299* Virtual operand {variable_name} shadowed another operand on syntax line

$55444523984237* Expected a closing parenthesis after the field type

$55537815420873* Expected ',' or ')' after pattern argument

$55929094649794* Expected a table of strings

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

$57773886232356* Expected a name for the field type

$58295598661589* Description in patterns must be left empty

$59115040206693* Expected a non-empty string to start block comments

$59388744207582* Was expecting a newline at the end of the bit pattern

$59877879891546* Could not interpret 'when'-condition expression: {err}

$61352853872444* Only immediates of width 0 to {max_field_size} are allowed

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

$62103010038950* Expected newline after section header

$62334191081955* Expected slice syntax after base-16 number reference in bit pattern

$62712568576067* Duplicate field type name: {name}

$63072912015761* Expected newline before pattern body

$63246722572594* Expected slice syntax after field reference in bit pattern

$63957561177031* Pattern '{pattern_name}' with {argument_count} parameters not defined

$64093416909416* Expected an identifier after '%'

$67219559926029* Field names can not contain whitespace characters

$67707174963301* Expected an identifier after '%'

$68066163358870* Expected whitespace after 'when'

$68462760531745* The bit pattern of {field_name} is {actual} bits long, expected {expected}

$68533544457789* Operand {variable_name} on syntax line shadowed another operand

$68587613470552* Expected a field value name

$70205284263092* Expected a non-empty string to end block comments

$70814401439344* Expected top bound not to be less than bottom bound

$72400465574342* Only up to {max_field_width}-bit field lengths supported

$72620639818015* Expected newline after section header

$72958581072457* Expected a name for the pattern

$73627734748417* Expected keyword 'pattern' before the pattern name

$75146029145419* Expected a name for the pattern parameter

$76494975412451* Expected a valid operand name, got '{operand_name}' among {all_operand_names}

$77234329031993* Expected slice syntax after field/pattern reference in bit pattern

$77449878176461* Expected an identifier after '%'

$77851254343918* No operand starts with character '{c}'.

$78591996283483* Was expecting a field name or a sized immediate here

$79195048703101* Expected an '=' here

$79975911393070* Expected slice syntax after field/pattern reference in bit pattern

$81691406697268* Expected top bound in slice syntax after field reference in bit pattern

$82876816015252* Too many operand option paths for automatic disassembly, at most {num_path} are allowed

$83804207975330* Expected top bound not to exceed 32767

$85972591916322* Expected newline after setting assignment

$87843223218582* The width of the instruction is {width} bits, but only multiples of 8 are supported

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



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

$10198498286711* Unfinished escape sequence

$11064758781325* Expected '"', ''', or '`' at the start of UI table cell content

$12492443144951* Expected a ',' or end of table

$13040813748160* Expected a key

$19807940646400* Expected one of {expected}, got {actual}

$22378976352410* Line {num}: 

$22452670489981* Expected a number literal

$25983481845150* Expected '{symbol}', got EOF

$27682737127628* Expected an opening quote (one of ", ' or `)

$29112746104375* Expected a bool here.

$33400766069212* Expected an opening parantheses (one of '(', '[' or '{{'), got '{open}'

$33551107641907* Int literal too big

$36313699368590* Invalid octal escape sequence

$43326454052643* Expected an U for unsigned or S for signed here

$44942745729831* Invalid hex escape sequence

$49180229055343* Expected a value

$51855228989260* Invalid unsigned int literal

$56457570130031* Invalid escape character '{nc}'

$64743950507593* Expected a list value

$64926004981217* Invalid int literal

$66187706284192* Expected ':' after the key

$71666516845083* Expected an unsigned number literal

$72110029133381* Expected {prefix}

$73113688099439* Expected one of {expected}

$73973243772156* Expected a signed number literal

$75565287060042* Unexpected EOF while parsing a string

$77089554485217* Expected a size declaration here

$82386938622647* Expected some character after the escape character '\\'



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

$12246885387560* variable {name}


# Assembly label
$17885987456433* label

$18299156828551* signed {n}-bit immediate

$74639900282369* unsigned {n}-bit immediate



=== model/translations.nim ===


# Quadrillion
$49300594926837* Q


# Trillion
$87907122406742* T



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

$81974422302188* Manual



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


# com_static_eval's expression
$32721727081818* Expression

$39851490511821* Location mode

$60193172250813* The setting you have chosen for this component will take up {size} of memory on your computer. Are you OK with this?

$86658255589213* Mutable data



=== presenter/board_ui/file_explorer.nim ===


# Load a schematic
$70369485875359* Load



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

$76805548224716* Total RAM size is too high! This solution won't get scored on server.



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


# IDE tab name
$11106925604855* Files



=== presenter/board_ui/popup/schematic_browser/file_browser.nim ===

$68586106474430* Note: all architecture levels share saves, so this will be deleted for all levels!

$89354977462546* No



=== presenter/board_ui/popup/schematic_browser/item_description.nim ===

$38755675398147* Use WOR

$74184088067843* Select

$84344684205464* Path



=== presenter/level_tree_ui.nim ===

$55841332003989* DECREASE DELAY TO PASS



=== presenter/main_menu_ui/hub/description.nim ===

$84668607423763* Downloading needs path length limit to be disabled in Windows. Clicking continue will show a windows pop up that asks you to confirm disabling it. Path limits are a legacy setting on windows and there is no reason to have it enabled.



=== presenter/update_state_stream.nim ===

$12823129240050* Click the upper-left button to link the screen



=== presenter/utilities.nim ===

$18997072674417* <Component> is not unlocked in this level.

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

$44947135063289* Circular dependency - The output of a component leads back to its own input.

$45545544521085* A <component> is in an invalid position.

$45678915971282* Short circuit inside <this> custom component.

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

$51730362111148* <This custom component> uses a {name} component not unlocked in this level.


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


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

$76434165550872*
[large]Tryby pracy ekranu[/large]
Ekran ma cztery tryby pracy, które zmieniają sposób wyświetlania wartości:
0: ASCII 8
1: ASCII 32
2: Pikselowy 8
3: Pikselowy 32

Poza tym, każdy z trybów ma inne ustawienia, które można zmieniać podczas pracy, używając złączy wejściowych ekranu.

[large]Tryb ASCII 8[/large]
Każdy bajt jest interpretowany jako znak na ekranie 96 na 40 znaków.

[b]Komendy:[/b]
0 Zmień tryb
1 Ustaw offset danych
2 Zmień kolor pierwszoplanowy
3 Zmień kolor tła
4 Ustaw czcionkę

[large]Tryb ASCII 32[/large]
Każde 4 bajty to w kolejności znak, kolor pierwszoplanowy, kolor tła i bajt dopełniający do 4.

8-bitowe kolory używają 3 bitów dla czerwonego, 3 bitów dla zielonego i 2 bitów dla niebieskiego, tak:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

[b]Komendy:[/b]
0 Zmień tryb
1 Ustaw offset danych

[large]Pikselowy 8[/large]
Każdy bajt jest interpretowany jako kolor piksela, z 3 bitami dla czerwonego,
3 bitami dla zielonego i 2 bitami dla niebieskiego, tak:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

Rozdzielczości trybu pikselowego mają współczynnik proporcji 4:3, zaczynając od 4×3, a kończąc aż na 1024×768.
Rozdzielczość jest obliczana na podstawie ustawienia, jak niżej:
4 × (ustawienie + 1) : 3 × (ustawienie + 1)

[b]Komendy:[/b]
0 Zmień tryb
1 Ustaw offset danych
2 Zmień rozdzielczość

[large]Pikselowy 32[/large]
4 bajty są interpretowane jako kolor piksela, po jednym na czerwony, zielony, niebieski i bajt dopełniający do 4:
[b][color=#ff5555]RRRRRRRR[/color][color=#55ff55]GGGGGGGG[/color][color=#5555ff]BBBBBBBB[/color][/b]

Rozdzielczości trybu pikselowego mają współczynnik proporcji 4:3, zaczynając od 4×3, a kończąc aż na 1024×768.
Rozdzielczość jest obliczana na podstawie ustawienia, jak niżej:
4 × (ustawienie + 1) : 3 × (ustawienie + 1)

[b]Komendy:[/b]
0 Zmień tryb
1 Ustaw offset danych
2 Zmień rozdzielczość
 
[large]Czcionki ASCII[/large]
To są czcionki ASCII:

[large][b]Rysunek (cp437)[/b][large]
[image="TC_cp437.png"]

[large][b]Tekst (cp850)[/b][large]
[image="TC_cp850.png"]

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

[large][b]Cyrylica (cp866)[/b][large]
[image="TC_cp866.png"]


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


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

$29435797471674*
[large]Wprowadzenie[/large]
Celem języka asemblera jest nadanie instrukcjom wykonywanym przez komputery nazw, które są czytelne dla człowieka.

Składnia asemblera tutaj opiera się na ogólnych konwencjach, więc po jej opanowaniu prawdopodobnie będziesz w stanie czytać kod asemblera większości rzeczywistych procesorów.

Składnia instrukcji zaczyna się od skróconego angielskiego słowa, zwanego „[color=#9966ff]mnemonikiem[/color]”, które opisuje instrukcję. Po nim następuje lista [color=#66ccff]operandów[/color], jak tutaj:[box][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]4[/color][/box]

Programy w asemblerze to w większości po prostu listy instrukcji.

[large]Operandy[/large]

Jest kilka rodzajów [color=#66ccff]operandów[/color].

[b]Rejestry[/b]
W powyższym przykładzie [color=#66ccff]r1[/color] jest zastępowane przez 1 w wygenerowanym kodzie maszynowym.

[b]Liczby[/b]
W powyższym przykładzie [color=#66ccff]4[/color] jest wstawione bezpośrednio w kod maszynowy.

[b]Etykiety[/b]
W instrukcjach skoku, generalnie chcesz odnosić się do adresów w wygenerowanym kodzie maszynowym. Te adresy mogą być obliczane automatycznie, poprzez użycie etykiet: [box][color=#9966ff]jmp[/color] [color=#66ccff]moja_etykieta[/color]
...
[color=#66ccff]moja_etykieta:[/color][/box]
Etykiety są zawsze deklarowane poprzez dodanie nazwy w linii, z dwukropkiem za nią.


[large]Inne funkcjonalności[/large]

[b]Komentarze[/b]
Wszystko w tej samej linijce za znakiem [highlight];[/highlight] jest uważane za komentarz i ignorowane przez asembler, jak tu:
[box][color=#eeeeee]mov r1, 123 [/color][color=#999999]; Wpisanie 123 do rejestru 1[/color]
[/box]

[b]Surowe dane[/b]
Możesz wstawić dane bezpośrednio pomiędzy instrukcje asemblera, w ten sposób:
[highlight]U8 123[/highlight]
Tutaj wstawiliśmy bajt 123. `U8` znaczy „8-bitowa wartość bez znaku” (ang. „unsigned”), ale asembler wspiera też [highlight]U16[/highlight], [highlight]U32[/highlight] i [highlight]U64[/highlight].
Możesz też wstawiać wartości znaków ASCII, w ten sposób:
[highlight]"Hello"[/highlight]

[b]const[/b]
Nadaj nowe nazwy swoim rejestrom lub innym rodzajom operandów, w ten sposób:
[highlight]const ROTACJA = r0[/highlight]
W tym przykładzie [highlight]ROTACJA[/highlight] staje się alternatywną nazwą dla r0. Nadawanie lokalnych nazw swoim rejestrom może uczynić twój kod łatwiejszym do czytania.

[b]Sekcje[/b]
Wstaw [highlight]@[/highlight] wraz z adresem, aby asembler emitował zera, aż osiągnie ten adres. Na przykład:
[highlight]@0x800[/highlight]

[b]Dołączanie[/b]
Możesz dołączyć inne pliki asemblera, na przykład plik „std_lib.asm” z folderu nadrzędnego:
[highlight]include ../std_lib[/highlight]

Inkludowanie innego pliku asemblera wstawia rezultat jego asemblacji w miejsce dyrektywy include. Możesz też używać etykiet i stałych zdefiniowanych w inkludowanym pliku, o ile zostały one wyeksponowane w tamtym pliku, poprzez poprzedzenie ich słowem kluczowym „pub”, jak tutaj:
[highlight]pub wypisz:[/highlight]

Aby użyć wyeksponowanej nazwy lub etykiety, umieść przed nią nazwę pliku i kropkę, w ten sposób:
[highlight]jmp std_lib.wypisz[/highlight]
Przy użyciu tego masz możliwość stworzenia biblioteki funkcji, która może być wywołana z każdego poziomu. Po prostu umieść tę bibliotekę w folderze nadrzędnym do poziomów i wyeksponuj etykiety odpowiadające każdej z funkcji.



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

$81923869207578* Programowanie w asemblerze



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

$57024194971618*
Sekcja [highlight]\[fields][/highlight] (ang. „pola”) definiuje różne typy pól, które mogą być zawarte w definicjach instrukcji, a także jakie wartości mogę one mieć.

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

warunek
eq 00
ne 01
cs 10
hs 10
[/box]

Pola są od siebie oddzielone pustymi linijkami, a każde pole zaczyna się od jego nazwy w pierwszej linijce, po której następuje jedna lub więcej akceptowanych wartości pola. Wartości te są wzorami bitowymi, a każda z wartości w obrębie pola musi mieć tę samą długość.

Pola są używane w instrukcjach w ten sposób:
[box]mov r1, r3[/box]

[b]Wartości domyślne[/b]
Niektóre architektury, jak aarch64, pozwalają na opcjonalny „#” przed wartościami bezpośrednimi. To może być rozwiązane przy użyciu pól. Zauważ, że nazwy pól mogą być pisane w cudzysłowach, właśnie z tego powodu.

[box]kratka
"#" 0
"" 0[/box]

[b]Zarezerwowane nazwy pól[/b]
Są dwie zarezerwowane nazwy:
* [highlight]label[/highlight] odnosi się do etykiet w asemblerze (np.: [highlight]mojaetykieta:[/highlight]).
* [highlight]immediate[/highlight] odnosi się do wartości bezpośrednich.



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

$32103815380062* Pola



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

$20029422748716*
[b]Operatory w wyrażeniach[/b]
Gra dostarcza ograniczony zbiór operatorów do konstrukcji wirtualnych operandów:
[box]Operator     Opis                                     Przykład      Rezultat dla %a = -30000
!            logiczne nie                             !%a           0
&&           logiczne i                               %a && 7       1
||           logiczne lub                             %a || 7       1
\==           równe                                    %a == 7       0
!=           nierówne                                 %a != 7       1
<u           mniejsze bez znaku                       %a <u 7       0
<            mniejsze ze znakiem                      %a < 7        1
>=u          większe lub równe bez znaku              %a >=u 7      1
>=           większe lub równe ze znakiem             %a >= 7       0
<=u          mniejsze lub równe bez znaku             %a <=u 7      0
<=           mniejsze lub równe ze znakiem            %a <= 7       1
>u           większe bez znaku                        %a >u 7       1
>            większe ze znakiem                       %a > 7        0
~            bitowe NOT                               ~%a           29999
&            bitowe AND                               %a & 7        0
|            bitowe OR                                %a | 7        -29993
^            bitowe XOR                               %a ^ 7        -29993
+            dodawanie                                %a + 7        -29993
-            odejmowanie                              %a - 7        -30007
*            mnożenie                                 %a * 7        -210000
/u           dzielenie bez znaku                      %a /u 7       2635249153387074516
/            dzielenie ze znakiem                     %a / 7        -4285
%            modulo (reszta z dzielenia)              %a % 7        -5
<<           przesunięcie logiczne w lewo (LSL)       %a << 7       -3840000
>>           przesunięcie logiczne w prawo (LSR)      %a >> 7       144115188075855637
[/box]
Zauważalny jest brak operacji negacji. Jednakże, domyślnym zachowaniem kiedy operatorowi „+” lub „-” brakuje pierwszego operandu, jest użycie w tym miejscu wartości 0, co oznacza, że istniejący operator odejmowania obsługuje tę sytuację.



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

$21043147057012* Operatory



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

$64897298154598*
[large]Wprowadzenie[/large]

Strona [link="Assembly/Language creation"]Tworzenie języka[/link] opisuje tylko podstawy definiowania instrukcji, ta strona skupia się na bardziej zaawansowanych funkcjonalnościach.

Definicja instrukcji składa się z następujących linijek:

[color=#66ff99]Składnia[/color]
[color=#ffe666]Wirtualne operandy[/color] (opcjonalne)
[color=#ff6680]Asercje[/color] (opcjonalne)
[color=#66ccff]Kod maszynowy[/color]
[color=#9966ff]Opis[/color]

Przykład:
[box][color=#66ff99]jmp %offset(label)[/color]
[color=#ffe666]%wysokie_bity = %offset / 4[/color]
[color=#ff6680]assert(%offset % 4 == 0, "Można skoczyć tylko do adresu wyrównanego do 4 bajtów")[/color]
[color=#66ccff]01 wwwwww[/color]
[color=#9966ff]# Skocz do %offset[/color][/box]

[large][color=#66ff99]Składnia[/color][/large]
Składnie to listy [b]literałów[/b] i [b]operandów[/b] oddzielone [b]białymi znakami[/b].

[b]Literały[/b]
W powyższym przykładzie, mnemonik [highlight]jmp[/highlight] jest literałem. Instrukcje z wieloma operandami zazwyczaj oddzielają je też literałami [highlight],[/highlight].
Użyj [highlight]%%[/highlight] jako znak ucieczki dla symbolu [highlight]%[/highlight] w literałach.

[b]Operandy[/b]
Operandy instrukcji zaczynają się od prefiksu [highlight]%[/highlight] i są zapisywane w formie [highlight]%nazwa(pola)[/highlight].
* [highlight]nazwa[/highlight] jest dowolnym identyfikatorem.
* [highlight]pola[/highlight] jest listą jednego lub więcej pól utworzonych we wcześniejszej sekcji „Fields” (lub zarezerwowanych pól). Elementy tej listy są oddzielone znakiem potoku ([highlight]|[/highlight]).

[b]Białe znaki[/b]
Białe znaki mogą być albo tabulatorami albo spacjami. Jeśli jest użyty pojedynczy biały znak, przerwa będzie opcjonalna w języku asemblera. Jeśli natomiast po białym znaku jest jeszcze jedna spacja, asembler będzie wymagać białego znaku między tokenami.


[large][color=#ffe666]Wirtualne operandy[/color][/large]
W powyższym przykładzie architektury skoku, wszystkie instrukcje mają szerokość 4 bajtów, a więc dwa dolne bity adresu docelowego instrukcji skoku mają być zawsze 0. Możemy utworzyć wirtualny operand, który nie ma tych dwóch bitów, w ten sposób:
[box]%wysokie_bity = %offset / 4[/box]
W definicji kodu maszynowego użyjemy [highlight]%wysokie_bity[/highlight] zamiast [highlight]%offset[/highlight].
Listę wspieranych operatorów można znaleźć [link="Assembly/Language creation/Instructions/Operators"]tutaj[/link].

Dwa specjalne operandy są zdefiniowane automatycznie, [highlight]$start[/highlight] i [highlight]$end[/highlight]. $start jest offsetem kodu maszynowego zaraz przed instrukcją, a $end zaraz po niej. Mogą być one użyte na przykład do obliczenia offsetów względem obecnej instrukcji, jak tu:
[box]%wzgl_offset = %offset - $end[/box]

[large][color=#ff6680]Asercje[/color][/large]
Asercje pozwalają ci sprawdzić, czy użytkownik nie popełnił błędu. W powyższym przykładzie użyliśmy ich, żeby upewnić się, że skaczemy do adresu wyrównanego do 4 bajtów.


[large][color=#66ccff]Kod maszynowy[/color][/large]
Powyższy przykład używa następującej składni kodu maszynowego.
[box]01 wwwwww[/box]
Zauważ, że [highlight]w[/highlight] odnosi się do wirtualnego operandu [highlight]%wysokie_bity[/highlight]. W tej składni bity operandów są zawsze reprezentowane pierwszymi literami ich nazw.

Alternatywną lecz równoznaczną metodą napisania tego samego jest [b]wycinanie bitów[/b]:
[box]01 %offset\[8:2][/box]
Wycinanie bitów używa standardowej sprzętowej składni wyboru fragmentu pola bitowego. Składnia to: [highlight]\[ostatni:pierwszy][/highlight], gdzie zarówno pierwszy, jak i ostatni są włączne.

Wycinanie bitów może być użyte na wielu operandach i używane naprzemiennie ze składnią jednego bitu na znak.


[large][color=#9966ff]Opis[/color][/large]
Opis nie ma zastosowania dla asemblera, istnieje tylko dla celów dokumentacyjnych.



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

$27583144414493* Instrukcje



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

$29662258275697*
Sekcja [highlight][patterns][/highlight] (ang. „wzorce”) jest miejscem, gdzie definiujemy makra podmiany tekstu, w celu zmniejszenia duplikacji w definicjach instrukcji. Struktura wzorca jest zbliżona do instrukcji:

[color=#66ff99]Sygnatura wzorca[/color]
[color=#66ccff]Podstawienie składni[/color]
[color=#9966ff]Podstawienie kodu maszynowego[/color]

Przykład:
[box][patterns]

[color=#66ff99]pattern rozmiar(szerokosc, kod_maszynowy)[/color]
[color=#66ccff]U{szerokosc}[/color]
[color=#9966ff]00{kod_maszynowy}[/color]

[instructions]

mov_%s\[[color=#66ff99]rozmiar([/color][color=#66ccff]"8"[/color], [color=#9966ff]"00"[/color][color=#66ff99])[/color] | [color=#66ff99]rozmiar([/color][color=#66ccff]"16"[/color], [color=#9966ff]"01"[/color][color=#66ff99])[/color]] %a(reg) %b(reg)
0000 [color=#9966ff]%s[/color] %a %b
\# Przenieś z %b do %a

[/box]
Po podmianie tekstu zamienia się to w:
[box][instructions]

mov_[color=#66ccff]U8[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0000[/color] %a %b
\# Przenieś z %b do %a

mov_[color=#66ccff]U16[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0001[/color] %a %b
\# Przenieś z %b do %a

[/box]
W powyższym przykładzie najpierw widzimy deklaracje wzorca. Deklaracja ta zaczyna się słowem kluczowym „pattern”, po którym następuje jego nazwa, a po niej nazwy argumentów. Te dwie linijki poniżej to fragmenty tekstu, które będą wklejone odpowiednio w linijki składni i kodu maszynowego.

W instrukcji, nazwy zmiennych [highlight]%s[/highlight] są umieszczane w linijce składni. W tym przykładzie, parser wylicza każdą z dwóch wersji, które są wychwycone przez [highlight]%s[/highlight] i tworzy nową instrukcję dla każdej z nich. Wkleja on fragmenty linijki składni oraz kodu maszynowego, a także podmienia argumenty wzorca na podane wartości.



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

$50803475056346* Wzorce



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

$13660841232898*
Sekcja [highlight]\[settings][/highlight] definiuje kilka parametrów konfiguracyjnych dla twojej architektury:

[b]name[/b]
[box]name = "Nazwa architektury"
[/box]Nazwa architektury.

[b]variant[/b]
[box]variant = "Wariant architektury"
[/box]Dodatkowy opis architektury.

[b]endianness[/b]
Definiuje kolejność bajtów w instrukcjach.
[box]endianness = big
endianness = little[/box]
Forma big endian jest domyślna.

Więcej o kolejności bajtów możesz przeczytać [link="Computer concepts/Endianness"]tutaj[/link].

[box=info]Komponenty RAMu mają swoje własne opcje kolejności bajtów, które mogą ponownie odwrócić kolejność. Nie jest to skomplikowane, jeśli szerokość twoich instrukcji zgadza się z szerokością bitową komponentu pamięci, ale może stać się zagmatwane jeśli szerokości się różnią.[/box]

[b]line_comments[/b]
Ustala token używany do rozpoczynania komentarzy liniowych. Takie komentarze rozpoczynają się od podanego tokena i zajmują resztę linijki.
[box]line_comments = "#"
line_comments = \[";", "//"][/box]
Domyślną wartością line_comments jest [highlight]\[";", "//"][/highlight].

[b]block_comments[/b]
Ustala tokeny używane do oznaczania początku i końca komentarzy blokowych. Takie komentarze zaczynają się na pierwszym tokenie i zajmują wszystko aż do ostatniego tokena. Obejmuje to znaki nowej linii, a także dodatkowe tokeny rozpoczęcia komentarza blokowego (uniemożliwiając zagnieżdżanie komentarzy).
[box]block_comments = {"/*":"*/"}[/box]
Domyślną wartością block_comments jest [highlight]{"/*":"*/"}[/highlight].



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

$78090021698706* Ustawienia



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

$41184546203403*
[large]Wprowadzenie[/large]

To jest przykład definicji prostego języka asemblera:
[box][fields]
rejestr
r0 000
r1 001
r2 010
r3 011

[instructions]
mov %a(rejestr), %b(rejestr)
00aaabbb
\# Przenieś wartość do %a z %b

mov %a(rejestr), %b:U8(immediate)
01000aaa bbbbbbbb
\# Przenieś bajt do %a z %b

jmp %a(label)
10000000 aaaaaaaa
\# Skocz do %a[/box]

Zauważ, że definicja jest podzielona na dwie sekcje [highlight][fields][/highlight] i [highlight][instructions][/highlight].

[large]Sekcja [fields][/large]
Sekcja „fields” (ang. „pola”) pozwala nadać nazwy twoim wzorom bitowym. Jest to zazwyczaj wykorzystywane przy rejestrach. Więcej informacji znajdziesz [link="Assembly/Language creation/Fields"]tutaj[/link].

[large]Sekcja [instructions][/large]
Definicje instrukcji składają się z linijki [color=#66ff99]składni[/color], linijki [color=#66ccff]kodu maszynowego[/color] i linijki [color=#9966ff]opisu[/color]:

[box][color=#66ff99]mov %a(rejestr), %b(rejestr)[/color]
[color=#66ccff]00aaabbb[/color]
[color=#9966ff]# Przenieś wartość do %a z %b[/color][/box]
Kiedy piszesz instrukcje asemblera w twoim języku, asembler skanuje tę listę definicji, znajduje pierwszą pasującą [color=#66ff99]składnię[/color] i generuje odpowiadający jej [color=#66ccff]kod maszynowy[/color].

[b][color=#66ff99]Linijka składni[/color][/b]
Linijka składni jest mieszanką sztywno ustalonych napisów oraz operandów. Operand zawsze zaczyna się od znaku [highlight]%[/highlight], po którym jest nazwa, która identyfikuje go w innych linijkach. Po tym znajduje się pole operandu, które może być [highlight]etykietą[/highlight] („label”), [highlight]wartością bezpośrednią[/highlight] („immediate”) lub niestandardowym [highlight]polem[/highlight], zdefiniowanym w sekcji [b][fields][/b].

[b][color=#66ccff]Linijka kodu maszynowego[/color][/b]
Linijka z polem bitowym, które akceptuje [highlight]0[/highlight] lub [highlight]1[/highlight], a także pierwszą literę dowolnej z nazw operandów zdefiniowanych w linijce składni. [highlight]0[/highlight] i [highlight]1[/highlight] są interpretowane dosłownie, podczas gdy litery używają po jednej binarnej cyfrze z wartości ich operandu.

[b][color=#9966ff]Linijka opisu[/color][/b]
Opis nie ma żadnego dla asemblera, istnieje on wyłącznie w celach dokumentacyjnych.

Asembler ma znaczniej więcej funkcjonalności związanych z instrukcjami, o których możesz przeczytać [link="Assembly/Language creation/Instructions"]tutaj[/link].

[large]Inne sekcje[/large]
Poza [b][fields][/b] i [b][instructions][/b] są jeszcze dwie opcjonalne sekcje, [b][link="Assembly/Language creation/Settings"][settings][/link][/b] i [b][link="Assembly/Language creation/Patterns"][patterns][/link][/b].



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

$67371980949119* Tworzenie języka



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

$85571962806085* Asembler



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

$65852115931553*
Auto-szerokość to funkcja dająca większą elastyczność przy tworzeniu komponentów własnych. Na przykład ten schemat przedstawia licznik, który obsługuje dowolną szerokość danych i pozwala na konfigurację wielkości kroku.
[image="example_pl.png"]
Zauważ, że część etykiet z rozmiarem ma inny kolor tła. To dlatego, że zostały one ustawione na automatyczne wnioskowanie. Możesz zmienić szerokość na automatycznie wnioskowaną, przy pomocy tego przycisku.
[image="setting_pl.png"]

W ogólności większość komponentów ma możliwość włączenia auto-szerokości i kiedy jest ona włączona, przyjmą one szerokość taką, jak  przewody prowadzące do ich złączy wejściowych. To, z którego złącza komponent pobiera swoją szerokość, zależy od komponentu. Na przykład ten sumator powyżej użyje szerszego ze swoich dwóch wejść liczbowych, ignorując wszelkie potencjalne przewody podłączone do wejścia przeniesienia.

Z powodów technicznych nie działa to dla komponentów pamięci. Aby uzyskać rejestr lub linię opóźniającą z auto-szerokością, możesz użyć ich specjalnych wersji z niebieskimi złączami, tak jak jest pokazane powyżej. Niebieskie złącza są generalnie używane do funkcji związanych z auto-szerokością.



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

$18060272082456* Auto-szerokość



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

$57134685411828*
Zależność cykliczna występuje, kiedy wejście komponentu zmienia się w zależności od jego własnego wyjścia.

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

Ten symulator nie pozwala na zależności cykliczne i zamiast tego zgłasza błąd.

Wyjątkiem są pomarańczowe złącza, które nie wpływają na wyjście w tym samym cyklu. Dlatego nie mogą one spowodować zależności cyklicznych.

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



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

$79928695804890* Zależność cykliczna



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

$25269304368822*
W prawdziwym sprzęcie wszystkie komponenty mają opóźnienie. Jest to istotne, ponieważ opóźnienie obwodu określa maksymalną prędkość, z jaką może on pracować.

Podążając od wejścia do wyjścia i dodając opóźnienia komponentów na ścieżce, uzyskasz opóźnienie tej ścieżki. Opóźnienie obwodu to opóźnienie jego najwolniejszej ścieżki (nazywanej ścieżką krytyczną).



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

$82367602514282* Opóźnienie



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

$20065838867866*
W elektronice dwa komponenty wysyłające inne wartości tym samym przewodem powodują zwarcie.

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

Jednakże poprzez odłączanie złączy wyjściowych od przewodu możliwe jest jego współdzielenie przez wiele złączy (co nazywamy magistralą). Co ważne, wyjście tylko 1 komponentu może pozostać podłączone w każdym cyklu, albo ryzykujesz zwarcie.

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

W tym symulatorze złącza, które mogą być odłączane, są szare.



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

$80662783536910* Zwarcie



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

$43200267887776*
Otwórz odlewnię klikając w ten przycisk  na lewym górnym pasku.

Odlewnia pozwala ci tworzyć swoje własne komponenty. Umieszczona logika określa zachowanie komponentu własnego, a położenie komponentów określa jego kształt.

Umieszczone komponenty wejściowe i wyjściowe stają się złączami komponentu.

Sondy umieszczone w komponencie własnym będą na nim widoczne i mogą wyświetlać jego wewnętrzne wartości. Sondy mogą być podłączane do innych komponentów własnych, a więc można wyświetlać zagnieżdżone wartości. Sondowane w ten sposób wartości mogą być też podłączane do komponentu programu.

Menadżer plików odlewni zarządza także komponentami własnymi. Nazwy schematów są nazwami komponentów, a struktura folderów decyduje o ich umiejscowieniu w menu.



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

$83185064398279* Odlewnia



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

$18477347795935*
Klawiatura jest komponentem rejestrującym naciśnięcia klawiszy na twojej klawiaturze.

Każde wciśnięcie klawisza skutkuje dwoma zdarzeniami: zdarzeniem naciśnięcia i zdarzeniem zwolnienia klawisza. Te zdarzenia mogą być odczytywane z komponentu po jednym na raz.

[large]Tryby pracy klawiatury[/large]
Różne kraje używają różnych klawiatur, na przykład pierwszy rząd klawiszy na polskich klawiaturach zaczyna się od QWERTY, a na francuskich od AZERTY.

Jeśli tworzysz edytor tekstowy, nie zależy ci na fizycznym położeniu klawiszy, a chcesz po prostu wiedzieć, co jest na nich napisane. W takim przypadku użyj [b]Trybu zlokalizowanego[/b].

Z drugiej strony, jeśli chcesz użyć górnych lewych klawiszy do sterowania grą, nie chcesz, żeby to było WASD na polskich klawiaturach, ale ZQSD na francuskich. Chcesz po prostu odwołać się do fizycznego położenia klawisza na klawiaturze, a nie do tego, co jest na nim napisane. W tym przypadku użyj [b]Trybu fizycznego położenia[/b].

[large]Tryb zlokalizowany[/large]
W tym trybie klawisze są mapowane do kodów ASCII, jeśli jest to możliwe. [highlight]w[/highlight] na klawiaturze QWERTY, AZERTY lub jakiejkolwiek innej zawsze będzie [highlight]0x77[/highlight].

[large]Tryb fizycznego położenia[/large]
W tym trybie klawisze są mapowane na ich fizyczne położenie w rzędzie i kolumnie. Zarówno rząd jak i kolumna używają 4 bitów, a więc położenie może być łatwo zapisane szesnastkowo. Na przykład spacja jest w 5. rzędzie i w 3. kolumnie, co daje 0x53 szesnastkowo.

[image="coordinate_mode.png"]

Zauważ, że klawisze po prawej stronie czarnej linii mają większe numery rzędów, żeby zmieścić wszystkie klawisze w limicie 4 bitów na rząd i kolumnę.

Jeśli twoja klawiatura nie wygląda jak ten diagram, możesz poeksperymentować, żeby przekonać się, jakie wartości mają poszczególne klawisze.



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

$11486015900582* Klawiatura



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

$53269020658041* Ekran



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

$42610024611500* Obwody



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

$69772243733094*
ASCII jest mapowaniem pomiędzy 7-bitowymi liczbami a znakami (w tej grze ekran korzysta z rozszerzonego ASCII, które ma 8 bitów).

[b]Kod   Znak   Opis[/b]
  0    NUL    
  1    SOH    Początek nagłówka (ang. „Start of header”)
  2    STX    Początek tekstu (ang. „Start of text”)
  3    ETX    Koniec tekstu (ang. „End of text”)
  4    EOT    Koniec transmisji (ang. „End of transmission”)
  5    ENQ    Zapytanie (ang. „Enquiry”)
  6    ACK    Potwierdzenie (ang. „Acknowledgment”)
  7    BEL    Dzwonek (ang. „Bell”)
  8    BS     Cofnięcie o znak (ang. „Backspace”)
  9    HT     Tabulator poziomy (ang. „Horizontal tab”)
 10    LF     Przesunięcie wiersza (ang. „Line feed”)
 11    VT     Tabulator pionowy (ang. „Vertical tab”)
 12    FF     Przesunięcie formularza (ang. „Form feed”)
 13    CR     Powrót karetki (ang. „Carriage return”)
 14    SO     Wyłączenie rejestru (ang. „Shift out”)
 15    SI     Włączenie rejestru (ang. „Shift in”)
 16    DLE    Znak ucieczki łącza danych (ang. „Data link escape”)
 17    DC1    Sterowanie urządzeniem 1 (ang. „Device control 1”) (XON)
 18    DC2    Sterowanie urządzeniem 2 (ang. „Device control 2”)
 19    DC3    Sterowanie urządzeniem 3 (ang. „Device control 3”) (XOFF)
 20    DC4    Sterowanie urządzeniem 4 (ang. „Device control 4”)
 21    NAK    Potwierdzenie negatywne (ang. „Negative acknowledgement”)
 22    SYN    Bezczynność synchroniczna (ang. „Synchronous idle”)
 23    ETB    Koniec bloku transmisji (ang. „End of transmission block”)
 24    CAN    Anuluj (ang. „Cancel”)
 25    EM     Koniec nośnika (ang. „End of medium”)
 26    SUB    Zastąpienie (ang. „Substitute”)
 27    ESC    Ucieczka (ang. „Escape”)
 28    FS     Separator plików (ang. „File separator”)
 29    GS     Separator grup (ang. „Group separator”)
 30    RS     Żądanie nadawania/separator wpisów (ang. „Request to send/record separator”)
 31    US     Separator jednostek (ang. „Unit separator”)
 32    SP     Spacja (ang. „Space”)
 33    !      Wykrzyknik
 34    "      Podwójny cudzysłów
 35    #      Kratka
 36    $      Znak dolara
 37    %      Procent
 38    &      Ampersand
 39    '      Pojedynczy cudzysłów
 40    (      Lewy/otwierający nawias
 41    )      Prawy/zamykający nawias
 42    *      Asterisk
 43    +      Plus
 44    ,      Przecinek
 45    -      Minus lub półpauza
 46    .      Kropka
 47    /      Prawy ukośnik
 48    0       
 49    1       
 50    2       
 51    3       
 52    4       
 53    5       
 54    6       
 55    7       
 56    8       
 57    9       
 58    :      Dwukropek
 59    ;      Średnik
 60    <      Mniejsze niż
 61    =      Znak równości
 62    >      Większe niż
 63    ?      Znak zapytania
 64    @      
 65    A       
 66    B       
 67    C       
 68    D       
 69    E       
 70    F       
 71    G       
 72    H       
 73    I       
 74    J       
 75    K       
 76    L       
 77    M       
 78    N       
 79    O       
 80    P       
 81    Q       
 82    R       
 83    S       
 84    T       
 85    U       
 86    V       
 87    W       
 88    X       
 89    Y       
 90    Z       
 91    \[      Lewy/otwierający nawias kwadratowy
 92    \\      Lewy ukośnik (wsteczny)
 93    ]      Prawy/zamykający nawias kwadratowy
 94    ^      Kareta
 95    _      Podkreślnik
 96    `       
 97    a       
 98    b       
 99    c       
100    d       
101    e       
102    f       
103    g       
104    h       
105    i       
106    j       
107    k       
108    l       
109    m       
110    n       
111    o       
112    p       
113    q       
114    r       
115    s       
116    t       
117    u       
118    v       
119    w       
120    x       
121    y       
122    z       
123    {      Lewy/otwierający nawias klamrowy
124    |      Kreska pionowa
125    }      Prawy/zamykający nawias klamrowy
126    ~      Tylda
127    DEL    Usuń (ang. „Delete”)



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

$75719044675256* Kodowanie ASCII



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

$39479426746559*
Liczby, których używasz na co dzień, mają bazę 10, a więc kiedy dopiszemy 0 po prawej stronie liczby, jej wartość wzrasta 10-krotnie.

System binarny (dwójkowy) ma bazę 2, a więc zrobienie tego samego tylko podwaja liczbę. Mówiąc inaczej, każda cyfra reprezentuje potęgę 2. Na przykład, oznaczając kolorami [color=#c54d5e]bazę 2[/color] i [color=#e49f44]bazę 10[/color]:

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

Aby przedstawić liczbę 6, wystarczy że dodamy 4 i 2:

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

Dodawanie, mnożenie i wszystko inne działa tak samo jak przy bazie 10, poza tym, że przenosisz, kiedy dojdziesz do 2, a nie do 10.



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

$73447955210779* Liczby binarne



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

$64065714320299*
Ta gra zleca ci zbudowanie 8-bitowego komputera. W praktyce wymagałoby to od gracza poprowadzenia w wielu miejscach 8 równoległych przewodów.
W celu oszczędzenia żmudnej pracy, wprowadzone zostało pojęcie bajtu, który jest po prostu wirtualną wiązką 8 bitów.

Stan bajtowego przewodu lub złącza wejściowego / wyjściowego jest reprezentowany liczbą, zamiast czerwonego lub zielonego koloru.



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

$68430971305988* Bajty



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

$13079267765950*
Tablice prawdy czterech podstawowych bramek logicznych są symetryczne. Możesz przekształcać jedną w drugą poprzez [color=#6e9759][b]odwracanie wejść[/b][/color] (pionowe strzałki) lub [color=#595f99][b]odwracanie wyjść[/b][/color] (poziome strzałki), tak jak zaznaczono na poniższym grafie.

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

Uwagi
1. Możesz przejść z każdej bazowej bramki do każdej innej, w najgorszym przypadku negując (NOT) oba wejścia i wyjście.
2. Możesz przejść pomiędzy OR/NOR, negując wyjście, tak samo z AND/NAND. Tak naprawdę NOR znaczy NOT OR, a NAND znaczy NOT AND. Zauważ, że kształty komponentów OR/NOR są identyczne oprócz tej małej kropki, która oznacza NOT. Tak samo jest w przypadku AND/NAND.
3. Negując wyjście odwracasz wszystkie bity w ostatnim wierszu tablicy prawdy. Negując wejścia tworzysz lustrzane odbicie ostatniego wiersza tablicy prawdy.



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

$66359790889628* Prawa De Morgana



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

$78199387512682*
Zwyczajowo dane o coraz większych adresach pamięci wyświetlamy od lewej do prawej. Sprawia to, że tekst ASCII wyświetla się od lewej do prawej, kiedy zapisujemy znaki w kolejnych komórkach pamięci.


[box]          Pamięć (hex) |   ASCII
Adres:   0  1  2  3  4 | 0 1 2 3 4
Dane:   [color=#ff6680]57[/color] [color=#ffe666]69[/color] [color=#66ff99]74[/color] [color=#66ccff]61[/color] [color=#9966ff]6A[/color] | [color=#ff6680]W[/color] [color=#ffe666]i[/color] [color=#66ff99]t[/color] [color=#66ccff]a[/color] [color=#9966ff]j[/color]
[/color][/box]

Natomiast konwencją zapisywania liczb jest umieszczanie najbardziej znaczącej cyfry po lewej, tak że trzynaście jest zapisywane jako [color=#ff6680]13[/color] a nie [color=#ff6680]31[/color].

Kierując się tym, oczywistym sposobem przedstawiania w pamięci wielobajtowej liczby takiej jak 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] jest:

[box]          Pamięć (hex)
Adres:     0  1  2  3
Dane:     [color=#66ccff]12[/color] [color=#66ff99]34[/color] [color=#ffe666]56[/color] [color=#ff6680]78[/color][/box]

Jest to nazywane [b]big endian[/b], ponieważ większe (ang. „big”), bardziej znaczące cyfry są przechowywane na wcześniejszych adresach.

Jednakże liczby rosnące w kierunku przeciwnym niż tekst są niewygodne przy pisaniu algorytmów. Do niektórych zastosowań, takich jak kryptografia, potrzebne są liczby o nieograniczonej wielkości (BigInt), a żeby takie uzyskać, musisz być w stanie zwiększyć liczbę cyfr lub usunąć końcowe zera. Naturalnym byłoby uporządkować cyfry w taki sposób, żeby być w stanie powiększyć liczbę bez konieczności aktualizacji wskaźnika do niej. Można by oczywiście zadecydować, że powiększanie oznacza przesuwanie się w przeciwnym kierunku, co sprawiłoby, że ten sam problem dotknąłby też tekstu (lub zaimplementować dwa rodzaje rosnących tablic).

Są też inne aspekty przechowywania liczb zaczynając od najmniej znaczących bitów, które okazują się korzystne. Na przykład, znacznie częściej będziesz potrzebować tylko najniższych bitów (rzutowanie w dół) liczby, niż tylko najwyższych bitów. Przechowywanie najniższej cyfry na początku znowu sprawia, że można to zrobić bez zmieniania wskaźnika.

Przyjazna obliczeniom konwencja przechowywania najmniej znaczącej cyfry na początku jest nazywana [b]little endian[/b]. Niestety czytanie tej konwencji jest zazwyczaj podwójnie mylące, ponieważ wartości są grupowane bajtami, które są wyświetlane w tradycyjny sposób. Przez to 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] staje się:

[box]          Pamięć (hex)
Adres:     0  1  2  3
Dane:     [color=#ff6680]78[/color] [color=#ffe666]56[/color] [color=#66ff99]34[/color] [color=#66ccff]12[/color][/box]

Gdyby konwencjonalny zapis był taki, że liczby i tekst rosną w tym samym kierunku, ta strona podręcznika byłaby zbędna.

Wszystkie współczesne CPU stosują little endian i stało się to de fakto standardem, z jednym istotnym wyjątkiem, jakim jest protokół TCP/IP, używający big endian.



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

$25715726162519* Kolejność bajtów



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

$22037524510182*
Sposób w jaki ta gra reprezentuje liczby ujemne jest nazywany „kodem uzupełnień do dwóch”. Jest to standardowa metoda reprezentacji liczb we współczesnych komputerach. Niektóre kluczowe informacje o tym kodzie:
 1: Aby zmienić znak liczby, możesz odwrócić wszystkie bity i dodać 1.
 2: Jeśli najwyższy bit jest [T], wartość jest zawsze ujemna.
 3: Sumatory działają zarówno w trybie ze znakiem jak i bez znaku.
 4: Jest tylko jeden sposób zapisania każdej liczby.

We erze wczesnych komputerów, głównym współzawodnikiem „kodu uzupełnień do dwóch” był „kod uzupełnień do jedności”. Jego główną zaletą było to, że zmiana znaku polegała na zwyczajnym zanegowaniu wszystkich bitów. Jednakże miał on dwa zapisy liczby 0, dodatnią i ujemną, co komplikowało porównania.

Inną interesującą reprezentacją, być może wartą sprawdzenia, jest baza -2, w której wartość cyfr jest naprzemiennie dodatnia i ujemna.



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

$64907157003500* Liczby ujemne



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

$16579770195459*
Tabele przedstawiające wejścia i wyjścia, które są używane wszędzie w tej grze, są znane jako tablice prawdy.

[center]
Wejście 0 [F][T][F][T]
Wejście 1 [F][F][T][T]
Wyjście   [T][T][T][F]
[/center]

„Wejście” i „wyjście” będą często reprezentowane nazwami zmiennych, jak w algebrze. A zamiast kolorów, często spotkasz się z zapisem 0/1 lub Prawda/Fałsz.



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

$39788153942181* Tablice prawdy



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

$38118080841071*
Niektóre komputery, takie jak proste kalkulatory, mają ograniczenia co do algorytmów, jakie mogą wykonywać.

Nie mogą one wykonać żadnych obliczeń, które wymagałyby arbitralnej liczby iteracji pętli lub wywołań rekurencji. Technicznie rzecz biorąc, maszyny bez pętli lub rekurencji są wyłącznie układami kombinacyjnymi.

Z drugiej strony, maszyny kompletne w sensie Turinga są tak potężne jak to tylko możliwe. Taka maszyna może mieć powolny procesor, ale jest potężna w tym sensie, że nie ma żadnego (możliwego do obliczenia) algorytmu, którego nie mogłaby wykonać.



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

$88124920557040* Kompletność Turinga



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

$11499640163947*
Tak się składa, że wszystkie układy logiczne w komputerze możesz zbudować tylko z bramek NAND lub tylko z bramek NOR. Komputery nawigacyjne Apollo były zbudowane wyłącznie z bramek NOR. Zaprojektowane w latach sześćdziesiątych, miały tylko 4 KB RAMu i 32 KB miejsca na dysku, a mimo tego doprowadziły astronautów na Księżyc.

Współczesne komputery nie są zbudowane wyłącznie z jednego rodzaju bramek, ale kiedy to możliwe, bramka NAND jest preferowana względem bramki NOR, ponieważ ma mniejsze opóźnienie i zajmuje mniejszą powierzchnię.



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

$24291443495513* Funkcjonalnie pełne bramki



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

$42755701050268* Pojęcia komputerowe



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

$62210202128540* Widzisz, że wejście nie ma znaczenia?



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

$33906573915218* Wybierz jakąkolwiek bramkę, która wysyła [T], kiedy jej wejścia nie są do niczego podłączone.



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

$18258110894478* Ten poziom odblokowuje pierwszą stronę w twoim podręczniku. Jest ona istotna, więc przeczytaj ją uważnie.

$61066799501731* Zawsze włączone

$85978749941194* Stwórz obwód, który jest zawsze [T].



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

$68158507707802* Bramka AND może być interpretowana jako bramka NOT-NOT-AND lub bramka NOT-NAND.



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

$18221128000007*
Stwórz obwód, który odpowiada tej tabeli.
[tip]Większość poziomów ma przycisk podpowiedzi (żarówka), który możesz kliknąć jeśli utkniesz.[/tip]

$28388869498626* Obecnie słoń dominuje wszystkie inne testowane osobniki z Ziemi. Biorąc poprawkę na wielkość mózgu, tobie też idzie nieźle.

$70892117360845* Branka AND



=== campaign/and_gate_3/hint_0.txt ===

$34539182309616* Większa bramka AND to po prostu kilka bramek AND jedna po drugiej.



=== campaign/and_gate_3/meta.txt ===

$28751026881977* Stwórz bramkę AND z 3 wejściami.

$32912994842868* Większa bramka AND



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

$10183449965120* Żeby dowiedzieć się, czy przynajmniej 2 wejścia są [T], możemy sprawdzać je parami.



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

$83867604619162* Żeby sprawdzić, czy oba z wejść są [T], użyj na nich AND.



=== campaign/any_doubles/hint_solution.txt ===

$34521278233301* To jest już jednak ćwiczeniem dla gracza!

$43216513907358* Przedstawione rozwiązanie nie jest z żadnym razie eleganckie lub optymalne.



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

$43068867747292*
Ten poziom ma 4 wejścia.
Wyślij [T], kiedy co najmniej 2 z nich są [T].

[tip]Nie przekombinuj tego.[/tip]

$81647833476822* Wykrywanie dwójek



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

$11603603520594* Przenosi wartość z %b do %a.



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

$17226968214352* Programowanie przy pomocy kart perforowanych to żmudna praca. Spróbujmy ponownie dodać 5 do wejścia, jak w poprzednim poziomie, ale tym razem przy pomocy programowania w asemblerze.

$72990407719621* Programowanie w assemblerze

$73801373825270*
Celem języka asemblera jest nadanie instrukcjom, które wykonuje nasza maszyna, nazw czytelnych dla ludzi.

Konwencjonalnie składnia instrukcji zaczyna się skróconym angielskim słowem (zwanym „[color=#9966ff]mnemonikiem[/color]”), które opisuje instrukcję, po którym następuje lista [color=#66ccff]operandów[/color], jak tu:
[highlight][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]r2[/color][/highlight]

Konwencja wymaga również, żeby adres docelowy był po lewej. Tak więc w powyższym przykładzie przenosimy wartość z r2 do r1. Jeśli opanujesz te konwencje, będziesz w stanie czytać prawdziwe języki asemblera.

Kliknij „edit” na komponencie RAMu, żeby otworzyć edytor asemblera. Gdy w nim jesteś, kliknij zakładkę „spec.isa” w lewym górnym rogu, żeby zobaczyć pełną listę instrukcji Uwertury.



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

$36228934755685* Przenosi 15 do rej 0.

$41299869859669* To jest komentarz.

$73562005049347* Przenosi wejście do rej 2.

$80524429403045* Kliknij zakładkę „spec.isa” w lewym górnym rogu, żeby zobaczyć wszystkie instrukcje.



=== campaign/assembly_programming/test.si ===

$38629344681843* {input_value} + 5 to {expected_value}, a nie {actual_value}.

$47165251832545* {input_value} + 5 to {expected_value}, a nie Z.



=== campaign/assembly_programming/ui.txt ===

$27941792707668* Dodaj 5 do wejścia, przy pomocy programowania w asemblerze.



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

$31456617450268* Przenosi wartość z %b do %a.



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

$12002017150690* Kliknij przycisk „edit” na komponencie „program”, aby zacząć programować swój komputer za pomocą kart perforowanych. Twój komputer powinien odczytać wejście, dodać do niego 5 i wysłać wynik na wyjście.

$23659479615536* Teraz, kiedy masz już swój pierwszy komputer, musisz nauczyć się go programować.

$35877580485177*
Jako że i ty i delfin zbudowaliście komputery, zawody o to, kto będzie reprezentował Ziemię w Federacji Galaktycznej, będą kontynuowane, dopóki któryś z was nie odpadnie.

Następnym kamieniem milowym jest napisanie programu, który przejdzie labirynt.

$47348572622406* Programowanie kartami perforowanymi



=== campaign/binary_programming/test.si ===

$61846111928326* {input_value} + 5 to {expected_value}, a nie {actual_value}.

$81797824381193* {input_value} + 5 to {expected_value}, a nie Z.



=== campaign/binary_programming/ui.txt ===

$65391114076509* Dodaj 5 do wejścia, przy pomocy programowania binarnego.



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

$17561499905402* Ten poziom to moja ulubiona rozrywka. Konwersja liczb dziesiętnych na dwójkowe pod presją czasu.

$37988524800638* Wyścig dwójkowy

$78267067157141*
Przełączaj bity w panelu poziomu, tak aby suma była równa liczbie dziesiętnej z pytania.

Musisz ukończyć 3 poziom, żeby przejść dalej.



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

$16764912826624* Łamacz kodów

$20948899837760*
W tym poziomie wygrywasz, kiedy wyślesz mój sekretny kod, o którym myślę. Żadne wyjście nie przegra tego poziomu, więc możesz po prostu próbować z każdą liczbą.

Dodatkowo, ustawię wejście na 1 po tym, jak strzelisz zbyt wysoko, a na 0 w przeciwnym wypadku. Być może będziesz w stanie wykorzystać to, by znaleźć kod szybciej.



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

$32998192994042* SUMA wymaga takiego samego rozumowania, jak w poziomie „Nieparzysta liczba sygnałów”.

$90884846016283* PRZENIESIENIE jest [T] wtedy i tylko wtedy, kiedy oba wejścia są [T].



=== campaign/bit_adder/meta.txt ===

$10776402819741* Do mierzenia wszechświata używamy liczb, tak więc nasze maszyny muszą umieć liczyć.

$19285770105090*
Traktuj wejścia jako [b]0[/b] lub [b]1[/b] w zależności od tego, czy są [F] czy [T]. Dodaj je do siebie w systemie dwójkowym tak, że wynik to albo [b]0[/b] albo [b]1[/b].

Tak jak przy normalnym dodawaniu, jeśli wynik nie mieści się w jednej cyfrze, ustaw przeniesienie na [b]1[/b].

$64470174232265* Sumator półpełny



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

$40415302067949* gdy albo wejście 0 jest [T] ORAZ wejście 1 jest [F], ALBO wejście 0 jest [F] ORAZ wejście 1 jest [T].

$61125857472821* Tablica prawdy mówi nam, że wyjście jest [T] wtedy i tylko wtedy,



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

$64992550674018* Tak na prawdę to po prostu bramka XOR.



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

$38198768813364* Odwracacz bitów

$53559965601096* Stwórz warunkowy odwracacz wartości. Kiedy [color=#e49f44][b]odwróć[/b][/color] jest [T], wyślij odwrotność [color=#e49f44][b]wartości[/b][/color]. W przeciwnym razie, po prostu wyślij [color=#e49f44][b]wartość[/b][/color] bez zmian.

$66258723258123* Eksperymentujemy z tym, jak tła wpływają na funkcje poznawcze Ziemian.

$76209391067704* Ten poziom jest dokładnie taki sam, jak bramka XOR, rozwiązana przez ciebie wcześniej. Pamiętaj, że niezależnie od tego, co mówię ci o celu tego poziomu, rzeczywista prawda zawsze znajduje się w tablicy prawd.



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

$29875779381032* Wartość

$41975883966377* Obecne wyjście

$42809920196772* Odwróć

$62797002040657* Oczekiwane wyjście



=== campaign/bit_switch/hint_0.txt ===

$22413958203952* Tablica prawdy mówi nam po prostu, żeby zbudować bramkę XOR.

$46480779443140* Na początku udawajmy, że nie mamy ograniczeń komponentów.



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

$45466715038362* Teraz musimy już tylko wyeliminować bramkę OR, żeby zmieścić się w budżecie.

$76027454955517* Przełącznik działa bardzo podobnie do bramki AND, więc podmieńmy ją.



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

$16488212881433* Dolny obwód

$42664577834105* Co oznacza, że dolny obwód jest nieco błędny, bo oba przełączniki wysyłają [Z], kiedy oba wejścia są [F].

$47029050705615* Niepoprawne wyjście

$52307576546100* Górny obwód/XOR

$62622482229413* W przeciwieństwie do bramki AND, kiedy złącze „Włącz” jest [F], przełącznik nie wysyła [F].

$80836475394613* W ogóle niczego nie wysyła, pozwalając współdzielić przewód pomiędzy wyjściami bez zwarć.



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

$12922292218235* Przełącznik bitowy

$25663924496537*
Zamiast wizualizować to sobie, jako niepodłączone wyjście, możesz o tym myśleć jak o wysyłaniu nie [F] ani [T], tylko trzeciego stanu, który nazywamy „stanem Z” [Z].

Podłączenie dwóch wyjść do przewodu, utworzy następujące stany:

Wyjście 0 [F][F][F][T][T][T][Z][Z][Z]
Wyjście 1 [F][T][Z][T][F][Z][F][T][Z]
Stan      [F][E][F][T][E][T][F][T][Z]

Zauważ, że zwarcie [E] nie może być sensownie uznane za czwarty stan, ponieważ uszkadza ono obwód. Jest ono i tak umieszczone w tabelce, ale tylko dla kompletności.

$77268807700313* Przy użyciu 2 bramek NOT i dwóch przełączników, zbuduj bramkę XOR.

$88100823584262*
Jeśli dwa komponenty wysyłają dwie różne wartości na ten sam przewód, pojawia się błąd zwarcia.

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

Jednakże, niektóre komponenty mają szare złącza, które nie wysyłają niczego, jeśli komponent nie jest włączony. Dzieje się tak w przypadku przełącznika bitowego.

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

Kiedy dolne złącze jest [F], wyjście jest wyłączone. W takiej sytuacji, więcej niż 1 wyjście może być podłączone do tego samego przewodu bez powodowanie błędów.

[center][image="bus_wire.png"][/center]
W praktyce, podłączanie wielu komponentów do jednego przewodu ma sens tylko wtedy, kiedy są one przełącznikami. Każdy komponent musi „mieć swoją kolej” wysyłania, żeby to było przydatne.



=== campaign/byte_adder/hint_0.txt ===

$37690209655811* Potrzebujesz 8 sumatorów pełnych.



=== campaign/byte_adder/hint_1.txt ===

$49335074955899* Do dodawania na poziomie bitów możemy po prostu użyć komponentu pełnego sumatora.

$56143546486508* Podobnie jak w przypadku innych komponentów bajtowych, najpierw rozdzielamy wejścia na bity.



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

$57534334907443* Dodaj kolejne 7 sumatorów pełnych, po jednym dla każdego bitu.



=== campaign/byte_adder/hint_solution.txt ===

$36646953278480* Przeniesienie wejściowe poprzedniego bitu jest przeniesieniem wejściowych następnego.

$69804974830322* Podłącz przeniesienia wejściowe i wyjściowe poziomu, aby dokończyć obwód.



=== campaign/byte_adder/label.txt ===

$45190053242926* Wejście przeniesienia

$76244671092409* Wyjście przeniesienia



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

$31490345812891* Dodaj do siebie dwa wejścia bajtowe. Każdy z bitów wyjściowych powinien być wynikiem dodania do siebie odpowiadających sobie bitów wejściowych i potencjalnie przeniesienia.

$45061087867940*
Jeśli wynik nie mieści się w 8 bitach, zmień przeniesienie wyjściowe na [T]. (Możesz o nim myśleć jak o 9. bicie.)

Poza tym, jest też przeniesienie wejściowe. Jest ono przydatne do łączenia ze sobą sumatorów bajtowych, aby sumować większe liczby. Możesz i nim myśleć jak o dodawaniu 0 [F] lub 1 [T].

$53076615315445* Tak w ogóle, to ten poziom ma mnóstwo testów. Kliknij prawym przyciskiem myszy na „Wykonuj”, żeby zwiększyć prędkość testowania.

$62793095496458* Dodawanie bajtów



=== campaign/byte_adder/ui.txt ===

$51758065631068* [color=#E49F44][left]Wyjście przen.  Suma[/left][/color]



=== campaign/byte_asr/hint_0.txt ===

$86214455922761* Najpierw, przypomnijmy sobie czym są te przesunięcia: obwodami rozdzielacza i scalacza.



=== campaign/byte_asr/hint_1.txt ===

$11228896363898* tzn. przesunięcie o 3 jest równoznaczne z przesunięciem o 1 + przesunięciem o 2.

$11260842500047* Możemy zaimplementować wersję tego obwodu zwaną przesuwnikiem baryłkowym.

$55175982917102* W związku z tym zauważmy, że przesunięcie ma właściwość addytywności,



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

$87506885530483* A więc przesuwamy wejście 0 o 1, 2 i 4 w zależności od [T] w bitach wejścia 1.



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

$53539145017840* ASR

$79125097012724*
Przesunięcie, które zbudowaliśmy w ostatnim poziomie jest znane jako przesunięcie [b]logiczne[/b]. Przesunięcie logiczne w prawo o 1 jest dla liczb bez znaku tym samym, co dzielenie przez 2. Dla liczb ze znakiem, jeśli najwyższy bit jest [T], wypełniamy puste bity [T] zamiast [F]. Jest to znane jako [b]przesunięcie arytmetyczne w prawo[/b] (ang. „arithmetic shift right”), często zapisywane jako [b]asr[/b] w asemblerze.

[color=#e49f44]-106 asr 3[/color]
  [T] [F] [F] [T] [F] [T] [T] [F]
Skutkuje w:
 |[T] [T] [T]|[T] [F] [F] [T] [F]
^             
Wstawiamy tutaj [T] zamiast [F].



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

$67841603404086* Dwójkowa reprezentacja liczby 164 to [T][F][T][F] [F][T][F][F].



=== campaign/byte_constant/meta.txt ===

$55176290924321* Stwórz obwód, który zawsze zwraca liczbę 164.

$55259569122850* Stała bajtowa



=== campaign/byte_constant/ui.txt ===

$90758832592628* Stwórz obwód, który zawsze zwraca liczbę 164.



=== campaign/byte_divide/meta.txt ===

$15513439442399* Podziel pierwsze wejście przez drugie i wyślij wynik. Zauważ, że ten poziom jest opcjonalny, ponieważ jest bardzo trudny. Jeśli drugie wejście (dzielnik) wynosi 0, wynik powinien być 0.

$55155519654685* Dzielenie



=== campaign/byte_divide/test.si ===

$10903561275291* {a} / {b} to {result}.



=== campaign/byte_divide/ui.txt ===

$86943286745277* Podziel przez siebie dwie liczby.



=== campaign/byte_equal/hint_0.txt ===

$13186595896308* XOR z 2 takich samych liczb jest niezwykle piękny.



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

$85034261531833* XOR z 2 liczb jest 0 wtedy i tylko wtedy, gdy są one równe.

$88637818475024* Wystarczy że potem sprawdzimy, czy bajt jest 0, poprzez sprawdzenie, czy wszystkie jego bity są [F].



=== campaign/byte_equal/meta.txt ===

$16679981460998* Wyślij [T] kiedy oba wejścia są takie same.

$44220989927736* Równość



=== campaign/byte_equal/test.si ===

$18508994046371* {a} == {b} to {value}

$32432328437519* Wartość {a} nie jest równa {b}

$51276780017906* Wartość {a} jest równa {b}



=== campaign/byte_equal/ui.txt ===

$41065065514143* Stwórz układ, który wysyła [T], kiedy oba wejścia są takie same.



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

$14667194911431* Z tym że ostatni bit jest w przypadku liczb ze znakiem rozważany osobno, ponieważ ma tu przeciwny efekt.

$19896249626650* Jeśli tylko jedna z liczb ma [T] w miejscu bitu znaku, to ta liczba na pewno musi być mniejsza.

$41958293329044* Porównywanie 2 liczb ze znakiem jest podobne do porównywania dwóch liczb bez znaku.



=== campaign/byte_less_s/hint_1.txt ===

$82755888644217* Jeśli bity znaku dwóch wejść różnią się, możemy je po prostu porównać.



=== campaign/byte_less_s/hint_solution.txt ===

$52492743864774* W przeciwnym wypadku możemy porównać 2 7-bitowe liczby bez znaku.



=== campaign/byte_less_s/meta.txt ===

$12621415211383* Stwórz obwód, który wysyła [T], kiedy pierwsze wejście jest mniejsze od drugiego. Interpretuj bajty jako liczby [color=#dd6576]ze znakiem[/color].

$57911276445846* Mniejszość ze znakiem



=== campaign/byte_less_s/test.si ===

$18672872329218* Wartość {a} nie jest mniejsza niż {b}

$60636366241019* Wartość {a} jest mniejsza niż {b}

$67770115019509* {a} < {b} to {result}



=== campaign/byte_less_s/ui.txt ===

$33907970782848* Stwórz obwód, który wysyła [T], kiedy pierwsze wejście jest mniejsze od drugiego.



=== campaign/byte_less_u/hint_0.txt ===

$18968293717104* Jedną z metod jest porównywanie po jednej cyfrze na raz, tak jak robimy to z liczbami dziesiętnymi.

$45223418140453* Tak więc 09 < 21, ponieważ 0 < 2, a więc 1100 > 1001, ponieważ 11XX > 10XX.



=== campaign/byte_less_u/hint_1.txt ===

$23270172293605* a więc użyjmy łańcucha bramek OR dla każdego z bitów, żeby sprawdzić, czy jakiś wyższy nie jest [T].

$34091176621640* Można to zrobić przy pomocy bajtowego XORa (pamiętaj, że XOR wysyła [T], gdy jego wejścia nie są takie same).

$38704349429368* Najpierw sprawdź, które z bitów różnią się między tymi dwoma bajtami.

$45560562333305* Ale musimy brać pod uwagę jedynie najwyższy z różniących się bitów,

$72421677239233* Wiemy, że liczba, której najwyższy różniący się bit jest [T], jest większą liczbą.



=== campaign/byte_less_u/hint_2.txt ===

$37315430614523* 09 < 11, a więc 09 - 11 < 0; 1100 > 1001, a więc 1100 - 1001 > 0.

$73589178770254* Kolejnym sposobem jest porównywanie różnicy z zerem.



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

$15205448412655* tj. wejście 0 plus (zanegowane wejście 1).

$19139933016995* Nie mamy komponentu odejmowania, jedynie dodawanie i negację.

$56709208304109* A więc zamieniamy na przykład 1100 - 1001 na 1100 + (-1001),



=== campaign/byte_less_u/hint_4.txt ===

$21199347421587* Aby przedstawić je w formie ze znakiem, musimy działać na 9-bitowych bajtach.

$46518640933018* Ale mamy tu 8-bitowe wejścia bez znaku.



=== campaign/byte_less_u/hint_5.txt ===

$11293872851403* Możemy stworzyć 9-bitowy komponent własny.

$17291563256662* Albo możemy rozbić negację na NOT i bitowy sumator, aby manipulować



=== campaign/byte_less_u/hint_solution.txt ===

$90593296729801* Uprość ten obwód.



=== campaign/byte_less_u/meta.txt ===

$39605373706887* Mniejszość bez znaku

$68842379350661* Stwórz obwód, który wysyła [T], kiedy pierwsze wejście jest mniejsze od drugiego. Interpretuj bajty jako liczby [color=#dd6576]bez znaku[/color].



=== campaign/byte_less_u/test.si ===

$50702714470018* Wartość {a} nie jest mniejsza niż {b}

$54835419299907* Wartość {a} jest mniejsza {b}

$75551771019196* {a} < {b}  to  {value}



=== campaign/byte_less_u/ui.txt ===

$88632565567686* Stwórz obwód, który wysyła [T], kiedy pierwsze wejście jest mniejsze od drugiego.



=== campaign/byte_lsr/hint_0.txt ===

$75806240403820* Najpierw, przypomnijmy sobie czym są te przesunięcia: obwodami rozdzielacza i scalacza.



=== campaign/byte_lsr/hint_1.txt ===

$12195819154781* tzn. przesunięcie o 3 jest równoznaczne z przesunięciem o 1 + przesunięciem o 2.

$28136552692253* Możemy zaimplementować wersję tego obwodu zwaną przesuwnikiem baryłkowym.

$88850298427736* W związku z tym zauważmy, że przesunięcie ma właściwość addytywności,



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

$22456794338741* A więc przesuwamy wejście 0 o 1, 2 i 4 w zależności od [T] w bitach wejścia 1.



=== campaign/byte_lsr/label.txt ===

$17566441654249* Przesunięcie



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

$26791208073532* Zadaniem w tym poziomie jest przesunięcie pierwszego wejścia w prawa o wartość podaną na drugim wejściu.

$36654581830314* LSR

$57629598331916*
Przesunięcie wartości o jeden w prawo oznacza po prostu przesunięcie wszystkich bitów w prawo o jedną pozycję.

Taka operacja jest znana jako [b]przesunięcie logiczne w prawo[/b] (ang. „logical shift right”) i w asemblerze jest często skracana do [b]lsr[/b].

Na przykład [b]180 lsr 1[/b]
[left]
           [T][F][T][T][F][T][F][F] Przesuń to o 1:
           [F][T][F][T][T][F][T][F]
[/left]
I [b]180 lsr 3[/b]
[left]
           [T][F][T][T][F][T][F][F] Przesuń to o 3:
           [F][F][F][T][F][T][T][F]
[/left]

$83781539475221* Poza komponentem przesunięcia w prawo, otrzymujesz też komponent przesunięcia w lewo.



=== campaign/byte_mod/meta.txt ===

$84095392269624* Modulo

$87605997307596* Wyślij resztę z dzielenia pierwszego wejścia przez drugie. Jeśli drugie wejście (dzielnik) wynosi 0, wynik powinien być taki sam jak pierwsze wejście (dzielna).



=== campaign/byte_mod/test.si ===

$38641362389638* {a} mod {b} to {result}.



=== campaign/byte_mod/ui.txt ===

$76653207214085* Wyślij resztę z dzielenia dwóch liczb.



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

$37740515704094* Ten poziom jest podobny do „Przełącznika bitowego”.

$71057700033977* Ale z A w miejscu wejścia 0, a B w miejscu zanegowanego wejścia 0.



=== campaign/byte_mux/label.txt ===

$63172000393911* Wybierz



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

$44523532982427* Kiedy bit wejściowy wyboru jest [F], wyślij bajt A, a jeśli nie wyślij bajt B.

$66984132947598*
Mimo tego, że nie przeszedł naszych testów, zdecydowaliśmy się zatrzymać psa. W przeciwieństwie do większości Ziemian jest puszysty i potrafi słuchać się prostych poleceń.

Może zechcemy żebyście połączyli siły, ponieważ dobrze uzupełniacie swoje słabe strony.

$75861961518456* Multiplekser



=== campaign/byte_mux/test.si ===

$15140861344476* Wybierz {select}



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

$28574225028041* Wybierz A lub B



=== campaign/byte_nand/hint_0.txt ===

$88766421259023* Bajtowy NAND 2 liczb dwójkowych to po prostu bramka NAND na każdej parze bitów wejściowych.



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

$11980470862173* Bajtowy NAND

$52274910421610*
Wykonaj NAND na każdym z bitów bajtów wejściowych i wyślij wynik.

Na przykład:
Wejście 0 [T][T][F][F][F][T][F][F]
Wejście 1 [F][F][F][F][T][T][F][F]
Wyjście   [T][T][T][T][T][F][T][T]

$66454601163361* Nie martw się. Jeśli nie potrafisz zbudować komputera, wypuścimy cię z powrotem w dzicz, albo wsadzimy do zoo z mnóstwem przestrzeni.



=== campaign/byte_not/hint_0.txt ===

$55051011788323* Bajtowy NOT liczby dwójkowej to po prostu bramka NOT na każdym z bitów tej liczby.



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

$54090032127372* Wykonaj NOT na każdym bicie wejścia bajtowego.

$60317070264440* Z tego powodu liczba ramion danego stworzenia jest bezspornie głównym czynnikiem prognozującym inteligencję. Czy wiesz, że są morskie stworzenia, które mają czterokrotnie więcej ramion od ciebie i idzie im lepiej w testach?

$65498108564418* Bajtowy NOT

$70777086019982* Wytwarzanie i użycie narzędzi jest kluczowe w początkowych stadiach ewolucyjnego rozwoju inteligencji.

$79214241606407* Nasz wcześniejszy model zakładający, że wielkość mózgu jest głównym wyznacznikiem inteligencji, był naiwny.



=== campaign/byte_xor/hint_0.txt ===

$66692685876410* Bajtowy XOR 2 liczb dwójkowych to po prostu bramka XOR na każdej parze bitów wejściowych.



=== campaign/byte_xor/meta.txt ===

$41472172986798* Bajtowy XOR

$70973830134418* Stwórz obwód, który wykonuje XOR na każdym w bitów wejść.



=== campaign/byte_xor/test.si ===

$54747903652562* {a} XOR {b} to {result}



=== campaign/byte_xor/ui.txt ===

$62779271315005* Stwórz obwód, który wykonuje XOR na każdym w bitów wejść.



=== campaign/circumference/meta.txt ===

$21808795465233* Obwód okręgu

$46884494321384*
W tym poziomie dostajesz promień okręgu i obliczasz jego obwód.

Tutaj jest równanie: 2×π×r

r jest wejściem.
I możesz przybliżyć π jako 3.

Wyślij odpowiedź na wyjście, kiedy skończysz obliczenia.



=== campaign/circumference/test.si ===

$18136442036625* Ile wynosi 2π × {radius}?



=== campaign/circumference/ui.txt ===

$24129473753872* Odczytaj wejście.

$47357954866257* *Przyjmując, że π ≈ 3.



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

$38150072401115*
Aby ukończyć ten poziom, odczytuj wejście dopóki nie zobaczysz liczby 37.

Wtedy wyślij liczbę, ile razy wejście było odczytane.

$38613585637577*
Mam dla ciebie dobre wieści. Delfin już odpadł.

Miał trudności z programowanie za pomocą płetw.

Będziemy jednak kontynuować testy, żeby zobaczyć, jak daleko może zajść człowiek.

$40525671378957*
Celem tego poziomu jest nauczenie cię o skokach i etykietach.

Skok jest instrukcją, która nadpisuje licznik.

Nadpisywanie licznika oznacza, że „skaczemy” do instrukcji w innym miejscu w programie, zamiast po prostu kontynuować do następnej.

$47703565240245* Skoki warunkowe

$65712025748767*
Jeśli użyjesz stałej liczby jako adresu twojego skoku, będziesz musieć aktualizować ją za każdym razem, kiedy dodasz lub usuniesz kod.

Zamiast tego możesz użyć mechanizmu zwanego [color=#66ccff]etykietą[/color], aby oznaczyć miejsce w programie, które aktualizuje się automatycznie, kiedy coś zmieniasz, jak tutaj:

[box][left]
[color=#66ccff]moje_etykieta[/color]:     [color=#aaaaaa]; To jest etykieta.[/color]
[color=#9966ff]imm[/color] [color=#66ccff]moje_etykieta[/color]  [color=#aaaaaa]; Załaduj offset etykiety.[/color]
[/left][/box]
  



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

$35642914965530* Skacze do 5 bajtu programu.

$50319416070023* Przenosi 5 do r0.

$66946505646203* Możesz odczytać jego offset w ten sposób.

$67381454058237* To jest etykieta.



=== campaign/conditional_jumps/test.si ===

$39953782121467* Ostatnim wejściem nie było 37!

$75138288162938* Wejście było odczytane {read_count} razy, a nie {output}.



=== campaign/conditional_jumps/ui.txt ===

$65261628219716* Edytuj asembler w RAMie.



=== campaign/count_leading_zeroes/hint_0.txt ===

$15352671410916* gdzie 8 jest liczbą bitów, a log2 jest pozycją pierwszego bitu [T].

$75683304945175* Oprócz przypadku gdzie wejście jest 0, jest to to samo co obliczanie 8 - 1 - log2(wejście),

$83745112465243* Znajdowanie log2 liczb binarnych jest w informatyce dobrze wydeptaną ścieżką.



=== campaign/count_leading_zeroes/hint_1.txt ===

$40521556880682* Jedną z metod jest podział problemu:

$46035077948196* Czym jest log2 2-bitowej niezerowej liczby (tzn. 1, 2 lub 3)?



=== campaign/count_leading_zeroes/hint_2.txt ===

$32041142528569* Odejmując od (2 - 1) = 1, jest odpowiednio 1 lub 0 wiodących zer.

$88044062357651* A co a 4-bitową liczbą?

$88309764896321* Jeśli liczba jest mniejsza niż 2, log2 wynosi 0; w przeciwnym wypadku jest to 1.



=== campaign/count_leading_zeroes/hint_3.txt ===

$24472621996685* Jeśli liczba jest mniejsza niż 4, możemy zredukować ten problem do 2-bitów.

$42632561737634* Tak czy siak, problem zmienia się z 4-bitowego w 2-bitowy.

$87709120049440* Jeśli nie, to pierwsze [T] jest gdzieś pośród najwyższych dwóch bitów.



=== campaign/count_leading_zeroes/hint_4.txt ===

$12591714876491* Brakuje już tylko przypadku, gdzie wejście jest 0.

$82513296271559* Zastosuj te same kroki, żeby zredukować problem z 8-bitowego do 4-bitowego.



=== campaign/count_leading_zeroes/hint_solution.txt ===

$27675083487752* Przedstawione rozwiązanie nie jest z żadnym razie eleganckie lub optymalne.

$62535209440079* To jest już jednak ćwiczeniem dla gracza!

$81301599100070* Najprostszym sposobem jest zrobienie przypadku zera osobno.



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

$18890527031365* Zliczanie wiodących zer

$30557055303267*
Stwórz obwód, który liczy jak wiele jest [F] z rzędu, zaczynając od najbardziej znaczącego bitu.

Na przykład tutaj odpowiedzią jest 3, ponieważ są 3 wiodące bity [F]:
[F][F][F] [T][F][T][F][T]



=== campaign/count_leading_zeroes/test.si ===

$10248302990519* Liczba wiodących zer w {input_value} ({binary_value}) to {count}.

$46565705342966* Liczba wiodących zer w {input_value} ({binary_value}) to 1.



=== campaign/count_leading_zeroes/ui.txt ===

$85604588212035* Policz wiodące zera



=== campaign/counter/hint_0.txt ===

$74290091312759* Ten poziom jest zaledwie drobną modyfikacją zapisywania z możliwością nadpisywania.



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

$22938387275450* Po prostu dodaj 1 do zapętlonego przewodu linii opóźniającej.

$81327009436542* Ale użycie komponentu dodawania jest tu zdecydowanie przesadą!



=== campaign/counter/label.txt ===

$24866509692444* Ustaw



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

$42949183679479*
Zbuduj licznik, który będzie zwiększany o 1 w każdym cyklu.

Dodatkowo powinna być też możliwość nadpisywania go podaną wartością.

Dostajesz dwa wejścia: bit i bajt.

Wejście bitowe przełącza pomiędzy liczeniem a nadpisywaniem licznika wartością wejścia bajtowego.

$51274378991709* Liczenie jest tak fundamentalne, że nawet owady to robią. Od liczenia gatunek może wyewoluować do porównywania i wykonywania arytmetyki. I zanim się obejrzysz, będziesz mieć małpy budujące komputery.

$68850421394935* Licznik



=== campaign/counter/test.si ===

$27837193789838* Wyjście powinno wynosić {memory}.

$30050502504940* Dodaj 1

$69821998974515* Nadpisz liczbą {num}



=== campaign/counter/ui.txt ===

$16305942415014* Akcja

$57018164959250* Następne oczekiwane wyjście



=== campaign/counting_signals/hint_0.txt ===

$20653200546136* Bit jedności używa tego samego obwodu co poziom „Nieparzysta liczba sygnałów”.

$39788606928520* Bit dwójek używa tego samego obwodu co poziom „Wykrywanie dwójek”, poza sytuacją gdy wszystkie 4 są [T].



=== campaign/counting_signals/hint_1.txt ===

$79041418443903* Wyjście 0 jest takie samo jak w poziomie „Nieparzysta liczba sygnałów”.



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

$90442785399123* Wyjście 2 jest [T] tylko wtedy, gdy wszystkie sygnały są [T].



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

$12139411441713* Wyjście 1 jest [T] wtedy i tylko wtedy, gdy co najmniej 2, ale nie wszystkie 4 sygnały są [T].

$83417330967064* Fragment „co najmniej 2” zrobiliśmy już w poziomie „Wykrywanie dwójek”.



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

$14499217305520* Liczenie sygnałów

$83123268362253*
Komponent wyjściowy tego poziomu jest binarnym licznikiem, którego 3 złącza reprezentują 1, 2 i 4.
Użyj tego binarnego licznika, żeby pokazać liczbę sygnałów.

[tip]Rozwiązanie tego poziomu nie jest zbyt eleganckie i wymaga ono wielu komponentów.[/tip]



=== campaign/decoder_1/meta.txt ===

$55345008240214* Dekoder 1-bitowy

$64947954189801* Stwórz komponent, który może przełączać sygnał pomiędzy dwoma złączami.



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

$40303102766749* Wyjście 0

$56552908891774* Wyjście 1



=== campaign/decoder_2/meta.txt ===

$44276233109848* Dekoder 2-bitowy

$46223188985873* Z 2 bitami wejściowymi, istnieją 4 kombinacje. Stwórz obwód, który wybiera 1 wyjście dla każdej z tych 4 kombinacji. W każdym momencie dokładnie 1 bit powinien być [T].



=== campaign/decoder_3/label.txt ===

$44918705544255* Wyłącz



=== campaign/decoder_3/meta.txt ===

$28695849165746* Z 3 bitami wejściowymi, istnieje 8 kombinacji. Stwórz obwód, który wybiera 1 wyjście dla każdej z tych kombinacji. Dodatkowo jest też bit wyłącznika. Kiedy jest on [T], wszystkie wyjścia powinny być [F].

$43603044118584* Dekoder 3-bitowy



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

$10870388349665* Oczekiwano, że wyjście {cycle} będzie [T], a pozostałe wyjścia będą [F]

$18073111523064* Oczekiwano, że wszystkie wyjścia będą [F], ponieważ bit wyłącznika jest [T]



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

$20191487800946* Oczekiwany bit

$23128720321555* Wyłącz

$23707304171214* Upewnij się, że wyjście zawsze jest [F], kiedy bit wyłączenia jest [T].



=== campaign/dependency/hint_0.txt ===

$21613887420121* Prostym obwodem, w którym wejście zależy od wyjścia, jest zapętlona bramka NOT.

$57091568089512* Zauważ czerwony przewód z błędem.

$64834808154176* Jest to niedozwolone w innych poziomach, ale w tym jest to celem.



=== campaign/dependency/hint_1.txt ===

$13967626449720* Czasami zwodniczo, jak na tym przykładzie, który mógłby mieć sens w formie czysto logicznej.

$71118235828147* Zależność cykliczna może być złożona i obejmować wiele różnych przewodów oraz komponentów.



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

$24156270270079*
Stwórz „zależność cykliczną”. Jest ona obwodem, w którym wejście zależy od jego własnego wyjścia. W przypadku zależności cyklicznej nie jest możliwe określenie wyjścia komponentu, ponieważ trzeba by było najpierw znać jego wejście, które zależy od wyjścia, i tak dalej (stąd „cykliczna”).

Taki stan nie jest normalnie dozwolony w innych poziomach, ale celem w tym poziomie jest stworzenie go, żeby pokazać ci co to jest, zanim przejdziemy dalej.

$25862237357880* Zależność cykliczna

$57043666310618* Nie mam pewności, czy przynosi to korzyści studentom, ale nauczyciele to uwielbiają.

$60783049086609* W naszym systemie edukacji jest tradycja wkręcania studentów w zrobienie czegoś niepoprawnie, a następnie wyśmiewania ich za to.



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

$28070798445412* Skonstruuj obwód, który wysyła to samo, co dostał na wejściu, ale z opóźnieniem dwóch cykli

$66914768639545* Ten poziom wprowadza komponent Linii Opóźniającej. Zapamiętuje ona swoje wejście i wysyła je 1 cykl później.

$81657957055974* Linie opóźniające



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

$13944257184132* W tym poziomie otrzymujesz bajt, czyli grupę 8 bitów, którą musisz rozdzielić i z powrotem scalić.

$16215081868720* Do tej pory pracowaliśmy tylko na bitach, czyli sygnałach [T] lub [F].



=== campaign/double_number/hint_1.txt ===

$29000872588470* Aby podwoić liczbę zapisaną dwójkowo, przesuń bity o 1.



=== campaign/double_number/meta.txt ===

$46697878992908* Podwój liczbę

$78449227663032*
W tym poziomie wprowadzone są wartości bajtowe, które są przedstawiane jako liczby pomiędzy 0 a 255. Bajt jest złożony z 8 bitów, każdy z których jest cyfrą liczby dwójkowej. Otrzymujesz nowe komponenty, jeden przyjmujący bajt i rozdzielający go na bity, a drugi przeciwnie.

Używając tych komponentów, wymyśl, jak można podwoić liczbę wejściową (nie większą niż 127).



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

$24718289227251*
Witaj w odlewni. Obwody, które tu tworzysz, będą mogły być użyte w innych poziomach jako komponenty.
Połączenia w stworzonym obwodzie definiują zachowanie komponentu, a rozmieszczenie elementów określa jego kształt.

$62612312608874* Ponieważ ten poziom jest narzędziem, a nie wyzwaniem, możesz przejść do mapy i kontynuować, kiedy chcesz.

$72171231322685* Odlewnia

$88436914545275* Dodanie, zmiana nazwy lub usunięcie komponentu może być dokonane w menu schematów.



=== campaign/full_adder/hint_0.txt ===

$50970897346580* SUMA wymaga takiego samego rozumowania, jak w poziomie „Nieparzysta liczba sygnałów”.



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

$54848313056941* PRZENIESIENIE jest [T] wtedy i tylko wtedy, gdy co najmniej 2 wejścia są [T].



=== campaign/full_adder/hint_solution.txt ===

$13880107359455* To jest już jednak ćwiczeniem dla gracza!

$18497022543669* Przedstawione rozwiązanie nie jest z żadnym razie eleganckie lub optymalne.



=== campaign/full_adder/label.txt ===

$12555311310864* Wejście 0

$13755587162128* Wejście 2

$34717193596171* Przenie.

$41149959264274* Wejście 1

$50183740481245* Suma



=== campaign/full_adder/meta.txt ===

$34381936755276*
W poprzednim poziomie dodaliśmy do siebie 2 wejścia. Tym razem dodamy 3. Raz jeszcze, dodaj do siebie wejścia w systemie dwójkowym tak, że wynik to albo [b]0[/b] albo [b]1[/b].

Tak jak przy normalnym dodawaniu, jeśli wynik nie mieści się w jednej cyfrze, ustaw przeniesienie na [b]1[/b].

$42735906141201* Sumator pełny



=== campaign/full_adder/ui.txt ===

$40317306745068* Oczekiwana suma

$49855734765642* Oczekiwane przeniesienie

$51965136043073* Obecne przeniesienie

$84617036256734* Obecna suma



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

$11327399415058* Ten poziom to moja druga ulubiona rozrywka. Konwersja liczb szesnastkowych na dwójkowe pod presją czasu.

$45399195121692* Wyścig szesnastkowy

$65517909958697*
Kiedy pracujemy z wieloma bitami, liczby dwójkowe mogą być trudne do odczytania. System szesnastkowy (heksadecymalny) reprezentuje każdą kombinację 4 bitów za pomocą jednej swojej cyfry:

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

Jako przykład, w którym liczby szesnastkowe są czytelniejsze, porównajmy największą liczbę 16-bitową w różnych reprezentacjach:
[left]
              Dwójkowo:     1111111111111111
              Dziesiętnie:  65535
              Szesnastkowo: FFFF
[/left]
Dostrzeżenie, że w zapisie dwójkowym brakuje cyfry, lub że dziesiętny jest błędny, jest trudne, ale zapis szesnastkowy jest od razu jasny (przynajmniej, kiedy już się do niego przyzwyczaisz).

$87098190175913*
Przełączaj bity w panelu poziomu, tak aby suma była równa liczbie szesnastkowej z pytania.

Musisz ukończyć 3 poziom, żeby przejść dalej.



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

$26182817405385*
Gratulacje, uprowadziliśmy cie.

Testujemy cię na naszym statku kosmicznym.

Zbuduj działający komputer, a twój gatunek będzie mógł przyłączyć się do Federacji Galaktycznej.

$44716420394020* Skromne początki

$76679675871478* Ten pierwszy test sprawdza twoje zrozumienie obwodów. Jest tu wejście oraz wyjście, z przewodem pomiędzy nimi. Włącz wejście w menu po lewej, aby ukończyć ten poziom.



=== campaign/logic_gate_racer/meta.txt ===

$35186537961257* Ten poziom jest tutaj, żeby upewnić się, że w pełni rozumiesz logikę boolowską, zanim przejdziesz dalej. Biegłość w tym zakresie bardzo ci pomoże w przyszłości.

$39180730338379* Będziesz musieć tu zbudować kilka obwodów. Kiedy wciśniesz przycisk „Wykonuj”, twój obwód zostanie przetestowany i dostaniesz zielony znacznik, jeśli był poprawny, a czerwony, jeśli nie. Ten poziom jest zaliczony, kiedy 4 z 5 znaczników w historii poniżej będą zielone.

$39721874026332* Świetna robota. Teraz, kiedy już sprawnie posługujesz się logiką boolowską, nadszedł czas zacząć pracować nad twoim pierwszym komputerem. Lecz najpierw musisz dowiedzieć się więcej o pamięci i arytmetyce dwójkowej. Droga do mistrzostwa jest długa i satysfakcjonująca.

$57679157572023* Egzamin z logiki



=== campaign/logic_gate_racer/ui.txt ===

$32183772878666* Historia



=== campaign/maze/hint_0.txt ===

$60076150664554* Podążanie zawsze wzdłuż lewej (lub prawej) ściany labiryntu sprawi, że na pewno w końcu dotrzesz do wyjścia.

$66501964970865* Pseudo-kod takiego algorytmu wygląda tak:



=== campaign/maze/meta.txt ===

$19088384441761*
Odczytuj wejście, żeby dowiedzieć się, co robot widzi przed sobą. Jest to zawsze któreś z tych:
0 Nic
1 Ściana

$56722492138232* Świetna robota. Udało ci się ukończyć labirynt i mistrzowsko opanować asembler Uwertury. Ale Uwertura jest zbyt prosta. Jest dobra do nauki, lecz brakuje jej wiele funkcji. Twoim następnym projektem będzie dążenie do zbudowania Symfonii, czyli potężniejszego komputera, który ma pamięć RAM, ekran, klawiaturę i pozwala ci używać kodu wielokrotnie poprzez funkcje. W trakcie tego, będziesz musieć zbudować kilka nowych komponentów, nauczyć się o stosie i więcej.

$84960209408475*
W tym poziomie kontrolujesz robota. Napisz algorytm, który przeprowadzi go od początku aż do drzwi na końcu labiryntu.

Są trzy polecenia, które możesz wysyłać:
0 Obróć się w lewo
1 Porusz się do przodu
2 Obróć się w prawo

Możesz też użyć klawiszy strzałek, żeby pobawić się robotem ręcznie.

$90660848232877* Labirynt



=== campaign/mod_4/hint_0.txt ===

$23027113131109* resztę z dzielenia przez 2 (parzysta lub nieparzysta), najniższe 3 bity to reszta z dzielenia przez 8 i tak dalej.

$35037773638556* Tak samo w systemie dziesiętnym, obliczenie modulo 4321 przez 100 też jest proste.

$40190253854900* W systemie dwójkowym, obliczenie modulo 4 liczby jest tym samym co użycie tylko jej dwóch najniższych bitów.

$44666331884152* Jest tak, ponieważ wyższe bity reprezentują 4, 8, 16, itd., a wszystkie te liczby dzielą się przez 4 bez reszty.

$47075416850998* To jest ogólnie prawdziwe dla reszt z dzielenia przez wszystkie potęgi 2. Najniższy bit liczby reprezentuje

$79521133202800* (Odpowiedź to 21, a wyższe cyfry są ignorowane, ponieważ 100 jest potęgą 10.)

$81555476661504* Teraz wystarczy, że wymyślisz, jak pobrać najniższe 2 cyfry z liczby dwójkowej.



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

$46388374967041*
W tym poziomie jako wejście otrzymasz liczbę i twoim zadaniem jest wysłać tą liczbę modulo 4, jako wynik.

Wyzwanie polega na tym, że masz tylko 8 cykli na wysłanie oczekiwanego wyniku.

Notka: Nie musisz modyfikować swojego sprzętu, musisz po prostu znaleźć sposób na szybkie obliczenie reszty z dzielenia przez 4.

$71000564779980*
Długość naszego tygodnia to 4 dni. Nasze dni tygodnia nazywają się dzień zer, dzień jedynek, dzień dwójek i dzień trójek. Słyszałem, że niektórzy Ziemianie błędnie numerują swój dzień piątek?

Niezbyt mnie to zaskakuje.

$76392666043520* Tak czy inaczej, nadchodzi nowy rok i chcielibyśmy obliczyć dni tygodnia wszystkich urodzin. Podamy ci datę, a twoim całym zadaniem jest zwrócenie dnia tygodnia w ciągu 8 cykli.

$78836302049950* Mod 4



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

$13853243145042* Musisz wysłać wynik przed cyklem 8!

$59240995307159* Najpierw odczytaj wejście.

$60992625993288* {inp} mod 4 to {result}.



=== campaign/multiply/meta.txt ===

$44500958231665* Pomnóż dwie liczby. Jeśli wynik nie mieści się w 8 bitach, odrzuć te bity, które się nie mieszczą.

$54529139494347* Mnożenie



=== campaign/multiply/test.si ===

$13790051293386* {a} * {b} to {result}.

$46804407616321* Niższy bit z {a} * {b} to {result}.

$83214947196979* Pomnóż dwie liczby.



=== campaign/multiply/ui.txt ===

$77112891598455* Pomnóż dwie liczby.



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

$36846418389807* Wszystkie gatunki zwierząt na Ziemi przechodzą przez ten sam test, żeby zobaczyć, czy macie inteligencje wystarczającą do nauczenia się jak zbudować komputer.

$39082333495604* Bramka NAND

$50880631203389* Poprawnie! Udało ci się odblokować bramkę NAND. Z tego fundamentalnego elementu konstrukcyjnego zbudujesz wszytko inne w swoim komputerze.

$65167079914703* Pierwsza sekcja jest o „logice boolowkiej”. Logika ta opisuje najprostszą formę kalkulacji, jaką mogą wykonywać komputery. Tak na prawdę wszystkie kalkulacje wykonywane przez komputer są złożone z tych prostych kalkulacji.

$68865507501612* Ten obwód zawiera „bramkę NAND”, której chciałbym, żebyśmy się przyjrzeli. Twoim zadaniem jest udokumentowanie jej zachowania poprzez wypełnienie „tablicy prawdy” w panelu, który widzisz poniżej. Tylko dwa wiersze tabeli odpowiadające wejściom są wypełnione. Poeksperymentuj z wejściami układu, zaobserwuj co robi bramka NAND i wypełnij ostatni wiersz tablicy prawdy.



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

$16731935541997*
Ten poziom wprowadza „kod uzupełnień do dwóch”, czyli najpopularniejszy sposób reprezentacji liczb negatywnych.

Najwyższa cyfra jest w nim zanegowana. W przypadku bajtów oznacza to, że 8. cyfra zmienia swoją wartość z 128 na -128.

Musisz ukończyć 2 poziom, żeby przejść dalej.

$20753698232132* Liczby ujemne

$87951492143019* Żeby znać różnicę między rzeczami, potrzebujesz odejmowania. Żeby mieć odejmowania, najpierw potrzebujesz liczb ujemnych.



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

$18962231551900* jeśli i tylko jeśli zarówno wejście 0 ORAZ wejście 1 jest [F].

$68908249643417* Tablica prawdy mówi nam, że bramka NOR jest [T],



=== campaign/nor_gate/hint_1.txt ===

$14349743750598* Bramka AND może być interpretowana jako bramka NOT-NOT-AND lub bramka NOT-NAND.



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

$37240300421781*
Większość ziemskich istot jest agresywna i nie potrafi się skupić.

Aby odnieść sukces, musisz nauczyć się myśleć logicznie, nie niszcząc rzeczy.

$56653221050913* Stwórz obwód, który odpowiada tej tabeli.

$72918877035793* Bramka NOR



=== campaign/not_gate/hint_0.txt ===

$26513163439009* Jedynym komponentem, jaki mamy, jest bramka NAND.



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

$20946507323050* Kiedy oba wejścia są [T], wyjście jest [F].

$88952480145102* Kiedy oba wejścia są [F], wyjście jest [T].



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

$16394937100308* Bramka NOT

$56423993638708* W poprzednim poziomie wypełniliśmy tablicę prawdy, która opisuje obwód. W tym poziomie stworzymy obwód, który pasuje do tablicy prawdy.

$64052600264884*
Używając bramek NAND, zbuduj bramkę NOT

Używając: [b]bramki NAND[/b]
Wejście 0: [F][T][F][T]
Wejście 1: [F][F][T][T]
Wyjście:   [T][T][T][F]

Zbuduj: [b]bramkę NOT[/b]
Wejście:   [T][F]
Wyjście:   [F][T]

$80163590000700* Teraz, kiedy już mamy bramkę NAND, nadeszła pora na samodzielne stworzenie obwodu.



=== campaign/odd_number_of_signals/hint_0.txt ===

$17243045715726* Możesz dowiedzieć się czy 2 wejścia mają nieparzystą liczbę [T] przy użyciu zaledwie jednego komponentu.



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

$39747324204871* Ale co jeśli, zamiast wyłączone/włączone, wyobrazimy sobie, że to parzyste/nieparzyste?

$80670337048058* Do tej pory [F] było traktowane jako wyłączone, a [T] jako włączone.



=== campaign/odd_number_of_signals/hint_2.txt ===

$28104365880572* parzysta liczba + parzysta liczba = parzysta liczba

$49444546097133* nieparzysta liczba + nieparzysta liczba = parzysta liczba

$57603105454008* Czy mamy jakiś komponent, który naśladuje to zachowanie?

$59534613718377* nieparzysta liczba + parzysta liczba = nieparzysta liczba



=== campaign/odd_number_of_signals/hint_3.txt ===

$47175212977659* To czego szukasz to bramka XOR.



=== campaign/odd_number_of_signals/meta.txt ===

$44190469254011* Nieparzysta liczba sygnałów

$63242509760527* Używając co najwyżej 3 komponentów, wyślij [T] tylko wtedy, kiedy nieparzysta liczba wejść jest [T]



=== campaign/odd_number_of_signals/test.si ===

$40553112323959* W tym poziomie nie możesz użyć więcej niż 3 komponentów



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

$69947751578736* Wejście tego poziomu jest tu tylko dla odwrócenia uwagi.

$75667038547709* Informacja pochodzi z liczby cykli, przy czym wykazać może się Linia opóźniająca.



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

$14188568517859* Linia opóźniająca może zostać zapętlona z sobą samą,

$88356074900046* aby stworzyć sygnał bazujący na liczbie cykli.



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

$17699211754487* W poprzednim poziomie nauczyliśmy się, że zależności cykliczne są niedozwolone. Teraz musisz poznać jeden wyjątek.

$54648226811178* Nieparzyste cykle

$60625429879527*
Pomarańczowe złącza nigdy nie wpływają na wyjście w tym samym cyklu. Z tego powodu nigdy nie powodują one zależności cyklicznych.

  [image="delay_line.png"]

$75292456030647*
Linia opóźniająca ma przyzwolenie, żeby zależeć od własnego wyjścia. Jest tak, ponieważ jej wejście nie wpływa na resztę obwodu aż do następnego cyklu.

[image="delay_line.png"]

$85913836277587* Wyślij [F] w parzystych cyklach i [T] w nieparzystych.



=== campaign/one_hot_encoding/hint_0.txt ===

$28460985244857* Jednym z komponentów, których potrzebujesz jest przesunięcie.



=== campaign/one_hot_encoding/hint_1.txt ===

$49063245216494* Ten poziom robi użytek ze zaimplementowanego wcześniej komponentu LSL (przesunięcia w lewo).



=== campaign/one_hot_encoding/meta.txt ===

$12296593054599* Kod 1 z n

$17817215316423*
Wejście decyduje o tym, które wyjście powinno być ustawione na [T]. A więc jeśli na wejściu jest 7, wyślij [T] na wyjście numer 7, a [F] na wszystkie pozostałe.

Nie używaj więcej niż 3 komponentów. Nie możesz też użyć żadnego z dekoderów, które budowaliśmy wcześniej.



=== campaign/one_hot_encoding/test.si ===

$60812617177494* Nie używaj więcej niż 3 komponentów.

$74562193652628* Wyjście na złączu {pin} jest niepoprawne.



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

$29061908449874* jeśli i tylko jeśli oba wejścia NIE są [F].

$49190016957852* Tablica prawdy mówi nam, że bramka OR jest [T],



=== campaign/or_gate/meta.txt ===

$46797361496226*
Stwórz obwód, który odpowiada tej tabeli.
[tip]Kliknij dwukrotnie na komponent, aby przesunąć go razem z podłączonymi przewodami.[/tip]
  

$81822607191994* Bramka OR



=== campaign/or_gate_3/hint_0.txt ===

$67313804184537* Większa bramka OR to po prostu kilka bramek OR jedna po drugiej.



=== campaign/or_gate_3/meta.txt ===

$29275887429601* Stwórz bramkę OR z 3 wejściami.

$68089739910654* Większa bramka OR



=== campaign/or_gate_3/ui.txt ===

$15378963142694* Wejście 2



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

$58396790216558* Przenieś wartość z %b do %a.



=== campaign/overture_1_registers/hint_0.txt ===

$25938996008186* ze źródłami zamiast wejść i z celami zamiast wyjść.

$87908319845833* Ten poziom przypomina poziom „Magistrala”



=== campaign/overture_1_registers/hint_1.txt ===

$66937784075495* Teraz używamy dekoderów do ustalenia włączonego źródła i celu.



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

$13757092116124*
[color=#ff6680]Źródło[/color] i [color=#e49f44]cel[/color] mogą być 1 z 6 rejestrów, które nazwiemy odpowiednio REJ 0 do REJ 5.

Dodatkowo ten poziom ma dedykowany komponent wejściowy, który może być [color=#ff6680]źródłem[/color], oraz komponent wyjściowy, który może być [color=#e49f44]celem[/color].

$36376879506769* Wreszcie nadszedł czas na zbudowanie twojego pierwszego komputera. Nauczę cię, jak zbudować architekturę [color=#e49f44]Uwertura[/color], rzeczywistą kompletną w sensie Turinga maszynę, prawdziwy komputer pod każdym względem.

$61875924861326*
Twoim zadaniem w tym poziomie jest stworzenie obwodu, który może przenosić wartości ze [color=#ff6680]źrodła[/color] do [color=#e49f44]celu[/color].

Bajt instrukcji w tym poziomie określa [color=#e49f44]cel[/color] i [color=#ff6680]źródło[/color].

Bity 0, 1 i 2 to [color=#ff6680]źródło[/color]. Bity 3, 4 i 5 to [color=#e49f44]cel[/color].

$79626649565563* Rejestry

$87179643828952*
To są wzory bitowe dla każdego ze [color=#ff6680]źródeł[/color] i [color=#e49f44]celów[/color].

[color=#ff6680]Źródła[/color]:
[left]
                      [F] [F] [F]  REJ 0
                      [F] [F] [T]  REJ 1
                      [F] [T] [F]  REJ 2
                      [F] [T] [T]  REJ 3
                      [T] [F] [F]  REJ 4
                      [T] [F] [T]  REJ 5
                      [T] [T] [F]  WEJŚCIE
                      [T] [T] [T]  NIEUŻYWANY
[/left]

[color=#e49f44]Cele[/color]:
[left]
                      [F] [F] [F]  REJ 0
                      [F] [F] [T]  REJ 1
                      [F] [T] [F]  REJ 2
                      [F] [T] [T]  REJ 3
                      [T] [F] [F]  REJ 4
                      [T] [F] [T]  REJ 5
                      [T] [T] [F]  WYJŚCIE
                      [T] [T] [T]  NIEUŻYWANY
[/left]



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

$18540192543555* Rejestr {reg_i} powinien mieć wartość {value}.

$51132330915663* Wyjście nie jest włączone.

$75546240775660* Oczekiwane wyjście: {value}.

$85392755740261* Wyjście nie powinno być włączone.



=== campaign/overture_1_registers/ui.txt ===

$77115196290575* Skonstruuj obwód rejestrów.



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

$57911760722636* Przenosi wartość z %b do %a.



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

$17602708328746*
Czas połączyć obwód „Jednostka arytmetyczno-logiczna”, stworzony wcześniej, z obwodem rejestrów. Obwód ALU został zapisany w odlewni i może być teraz dodany jako komponent. Jeśli nie pamiętasz funkcji poszczególnych złączy, sprawdź obwód w odlewni.

Użyj dekodera, który zbudowaliśmy wcześniej, do sprawdzenia czy powinniśmy przenosić wartość między rejestrami, czy raczej wykonywać kalkulacje w ALU. Tu są ponownie te 4 tryby:
[left]
                      [F][F] Bezwzględna (wartość)
                      [F][T] ALU
                      [T][F] Przenieś
                      [T][T] Warunek
[/left]

W tym poziomie musisz się przejmować tylko trybami przenoszenia i ALU. W trybie ALU, użyj [color=#e49f44]REJ 1[/color] i [color=#e49f44]REJ 2[/color] jako wejść, a wynik zapisz w [color=#e49f44]REJ 3[/color].

[tip]Nie zapomnij, że dekoder 3-bitowy ma bit wyłącznika.[/tip]

$76398546711745* ALU



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

$27417572090527* Wyjście nie jest włączone.

$45837083894306* Oczekiwane wyjście: {value}.

$67011612338355* Rejestr {reg_i} powinien mieć wartość {value}.

$84026509534190* Wyjście nie powinno byś włączone.



=== campaign/overture_2_alu/ui.txt ===

$49706182840588* Przyłącz ALU to obwodu.



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

$50864238070873* Przenosi wartość z %b do %a.



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

$23614311904581* Wartości bezpośrednie

$63109056149876*
Potrzebujemy sposobu na bezpośrednie przenoszenie liczb z naszego programu do rejestrów. Używamy do tego trybu wartości bezpośredniej (gdy dwa najwyższe bity są [F][F]).

Kiedy jesteśmy w trybie wartości bezpośredniej, cały bajt jest interpretowany jako liczba, którą zapisujemy do REJ 0. Oznacza to, że możemy zapisać dowolną wartość pomiędzy 0 a 63.



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

$17793323757435* Oczekiwane wyjście: {value}.

$63497936956369* Wyjście nie powinno być włączone.

$73489311755739* Rejestr {reg_i} powinien mieć wartość {value}.

$82564442776805* Wyjście nie jest włączone.



=== campaign/overture_3_immediates/ui.txt ===

$57764930098721* Dodaj wartości bezpośrednie do obwodu.



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

$26930827349244* Przenosi wartość z %b do %a.



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

$10102035559374* Program

$58149108600515* Komponent wejściowy instrukcji został usunięty. Jest on zastąpiony komponentem RAM, zawierającym program. Do RAMu jest przyczepiony "port odczytu". Kiedy złącze „włącz” tego portu jest włączone, wysyła on wartość z RAMu, zgodnie z podanym adresem. W każdym cyklu użyj licznika do załadowania następnej instrukcji z pamięci programu.



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

$19443898128380* Wyjście nie powinno być włączone.

$49097812105667* Rejestr {reg_i} powinien mieć wartość {value}.

$50052313044113* Wyjście nie jest włączone.

$73023200204536* Licznik powinien mieć wartość {expected_value}.

$88140381331491* Oczekiwane wyjście: {value}.



=== campaign/overture_4_program/ui.txt ===

$62678678871254* Dodaj program do obwodu.



=== campaign/overture_5_conditionals/label.txt ===

$37075142107851* Rej 2

$38743609381557* Rej 1

$40362507068221* Rej 4

$57061942907076* Rej 5

$79357977314471* Rej 3

$82470056393191* Rej 0



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

$27747401844990* Udało ci się! Myśleliśmy, że jesteś tylko takim dziwnie wyglądającym bezwłosym małpim stworem, ale naprawdę udało ci się zbudować prawdziwy komputer! Niesamowite.

$59169726539090* Kompletność Turinga

$77166984247940* Do tej pory wszystkie możliwe programy było ograniczone do wykonywania się w kolejności bajt po bajcie.

$85320707451673* Wcześniej tylko kod mógł wpływać na pamięć, teraz pamięć musi wpływać na kod. Dodanie warunkowej logiki sprawia, że nasz komputer może wykonać dowolny program i obliczyć wszystko, co da się obliczyć. Tak jak wszystkie nieteoretyczne komputery, ta maszyna jest ograniczona wyłącznie posiadaniem skończonej ilości pamięci.

$89085328104477*
Ostatnią rzeczą, którą musimy dodać jest mechanizm zmieniania licznika programu poprzez instrukcje, gdy spełnione są określone warunki.

Kiedy dwa największe bity są [T][T], jesteśmy w trybie warunków. W tym trybie, wartość w REJ 3 jest sprawdzana przez warunek zdefiniowany w 3 najniższych bitach instrukcji. Jeśli warunek jest spełniony, nadpisujemy wartość licznika wartością REJ 0.
Warunkowe zmienianie licznika oznacza, że możemy pominąć instrukcje w zależności od warunków, lub uruchamiać instrukcje w pętli.

Warunki:[left]
                    [F][F][F] Nigdy
                    [F][F][T] Zawsze
                    [F][T][F] Jeśli [color=#e49f44]REJ 3[/color] = 0
                    [F][T][T] Jeśli [color=#e49f44]REJ 3[/color] ≠ 0
                    [T][F][F] Jeśli [color=#e49f44]REJ 3[/color] < 0
                    [T][F][T] Jeśli [color=#e49f44]REJ 3[/color] ≥ 0
                    [T][T][F] Jeśli [color=#e49f44]REJ 3[/color] ≤ 0
                    [T][T][T] Jeśli [color=#e49f44]REJ 3[/color] > 0
[/left]
Warunki te odpowiadają komponentowi warunków, który był zapisany w odlewni.



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

$17521915837347* Wyjście nie powinno być włączone.

$33411257451562* Oczekiwane wyjście: {value}.

$36308361121667* Wyjście nie jest włączone.



=== campaign/overture_5_conditionals/ui.txt ===

$65145204616501* Dodaj warunki do obwodu.



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

$18505654344513* Skocz r0.

$21095867785396* Wykonaj AND na r1 oraz r2 i zapisz wynik do r3.

$24147817394058* Skocz do r0 jeśli r3 jest mniejszy niż 0.

$26704206992933* Wykonaj NAND na r1 oraz r2 i zapisz wynik do r3.

$33850592701591* Odejmij r2 od r1 i zapisz wynik do r3.

$42577908074742* Przenieś %a do r0.

$43876958520450* Skocz do r0 jeśli r3 nie jest 0.

$45432635426071* Przenieś wartość z %b do %a.

$46599288949396* Skocz do r0 jeśli r3 jest 0.

$48758564562305* Skocz do r0 jeśli r3 jest mniejszy lub równy 0.

$58823897430160* Wykonaj OR na r1 oraz r2 i zapisz wynik do r3.

$64808551937719* Skocz do r0 jeśli r3 jest większy lub równy 0.

$71072332861445* Nic nie rób.

$75067212691206* Wykonaj NOR na r1 oraz r2 i zapisz wynik do r3.

$75524550463342* Dodaj r1 do r2 i zapisz wynik do r3.

$88048573834702* Skocz do r0 jeśli r3 jest większy od 0.



=== campaign/overture_alu_1/hint_0.txt ===

$17808301775724* Ten poziom jest podobny do poziomu "Multiplekser"

$69085851994491* z NAND, OR, AND i NOR zastępującymi wejścia A/B.



=== campaign/overture_alu_1/hint_solution.txt ===

$76898193108851* To, który przełącznik włączyć, można ustalić przy pomocy dekodera.



=== campaign/overture_alu_1/meta.txt ===

$16562043259074* Jednostka arytmetyczno-logiczna (ALU) 1

$31234606133949*
Stwórz urządzenie, które może wykonać OR, NAND, NOR lub AND na wejściach bajtowych. Trzecie wejście będzie instrukcją. (Instrukcją nazywamy liczbę określającą co należy obliczyć.)

Instrukcje:

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



=== campaign/overture_alu_2/hint_solution.txt ===

$30599543511275* Rozszerzenie używające 3-bitowego dekodera zamiast 2-bitowego.

$61118397217284* Odjęcie B od A to samo co dodanie zanegowanego B do A.



=== campaign/overture_alu_2/meta.txt ===

$20519420764551* Jednostka arytmetyczno-logiczna (ALU) 2

$39134024311972*
Dodaj dodawanie (ADD) i odejmowanie (SUB) do swojego obwodu.

Instrukcje:

[color=#87a8c8]0 NAND
1 OR
2 AND
3 NOR
4 ADD
5 SUB[/color]



=== campaign/overture_alu_2/ui.txt ===

$53936374688885* Kod operacji



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

$30858693828450* Więc podłączmy je oba do magistrali.

$41615813866999* Nigdy i zawsze są najłatwiejszymi częściami.

$73479968135998* Teraz, żeby sprawdzić, czy wartość = 0, musimy sprawdzić, czy każdy bit jest [F].



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

$71744044447857* Żeby sprawdzić czy wszystkie bity są [F], rozdzielamy wartość na bity i stosujemy wielką bramkę NOR.

$78036114842982* Następnie dla warunku wartość < 0 sprawdzamy, czy liczba dwójkowa jest ujemna.



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

$16809493892244* Żeby sprawdzić, czy liczba dwójkowa jest ujemna, po prostu sprawdzamy, czy bit znaku jest [T].

$70638453446538* Pozostałe warunki to po prostu kombinacje warunków wartość = 0 i wartość < 0.



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

$19520914707885* [left]wartość ≥ 0 oznacza NIE (wartość < 0)[/left]

$44207156733924* [left]wartość ≤ 0 oznacza (wartość < 0) LUB (wartość = 0)[/left]

$75072852663289* [left]wartość > 0 oznacza NIE (wartość ≤ 0)[/left]



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

$71466914240996*
Ten poziom ma wejście wartości i 3-bitowe wejście warunku.

Te trzy bity wybierają warunek tak, jak pokazano poniżej. Sprawdź, czy wartość spełnia warunek i wyślij [T] jeśli tak, a [F] jeśli nie.

[left]
            Układ bitów:   Kiedy wysłać [T]:
              [F][F][F]       Nigdy
              [F][F][T]       Zawsze
              [F][T][F]       Jeśli wartość = 0
              [F][T][T]       Jeśli wartość ≠ 0
              [T][F][F]       Jeśli wartość < 0
              [T][F][T]       Jeśli wartość ≥ 0
              [T][T][F]       Jeśli wartość ≤ 0
              [T][T][T]       Jeśli wartość > 0
[/left]

$83283206082997* Warunki



=== campaign/overture_conditions/test.si ===

$74974087807935* ZAWSZE

$80507287196650* NIGDY



=== campaign/overture_conditions/ui.txt ===

$11886599003881* wartość

$38979555213581* Opis

$43384041502940* Wartość

$81487261104241* Warunek



=== campaign/overture_decoder/label.txt ===

$15645900189277* Przenieś

$60698949860454* ALU

$90597971391617* Bezpośrednia



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

$44644153822563* Obwód zbudowany w poziomie „Rejestry” może kopiować wartości pomiędzy rejestrami, podczas gdy „Jednostka arytmetyczno-logiczna" może wykonywać różne operacje na 2 wejściach. Ty jednak musisz być w stanie robić obie te rzeczy w tym samym obwodzie. Aby tego dokonać, zbuduj „dekoder”, który będzie decydować, w którym trybie jest nasz komputer, bazując na 2 bitach wejściowych, których jeszcze nie użyliśmy.

$62355105651643*
Aby rozróżnić pomiędzy instrukcjami 4 różnych rodzajów, dwa najwyższe bity będą używane do określania, w którym TRYBIE jesteśmy, jak następuje:

[left]
                [F][F][Z][Z][Z][Z][Z][Z] (Wartość) bezpośrednia
                [F][T][Z][Z][Z][Z][Z][Z] ALU
                [T][F][Z][Z][Z][Z][Z][Z] Przenieś
                [T][T][Z][Z][Z][Z][Z][Z] Warunek
[/left]
[Z] oznacza tu dowolną wartość.

Ustal w którym TRYBIE jesteśmy i wyślij [T] na odpowiednie wyjście.

$81732613304305* Dekoder instrukcji



=== campaign/overture_decoder/test.si ===

$23393810721136* ALU

$41856942338650* Warunek

$67613074322431* Przenieś

$71705253055197* Bezpośrednia



=== campaign/overture_decoder/ui.txt ===

$35299017249605* Oczekiwany tryb

$55162862394836* Instrukcja



=== campaign/ram_component/hint_0.txt ===

$32597308066943* Na początku umieśćmy wszystkie nasze 4 bajty pamięci na planszy.



=== campaign/ram_component/hint_1.txt ===

$73686127519870* Następnie musimy zadecydować, na której komórce pamięci wykonujemy odczyt/zapis.

$86131527203527* Tutaj przydaje się dekoder.



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

$51243843817679* Używając wyjścia [T] dekodera, możemy włączyć odpowiadającą mu komórkę pamięci, z której chcemy załadować bajt.

$78963222298606* I nie zapomnij dodatkowego przełącznika, żeby wysyłać wyjście tylko kiedy ZAŁADUJ jest [T].



=== campaign/ram_component/hint_3.txt ===

$51887730294248* Podłącz przewody i jedyna rzecz, która nam pozostanie, to włączenie odpowiedniej komórki pamięci.

$65959445914539* Wartość do zapisu w komórce pochodzi z wejścia.



=== campaign/ram_component/label.txt ===

$10655955073336* Załaduj

$46688176903674* Adres



=== campaign/ram_component/meta.txt ===

$14374127314134* Malutkie pudełko

$68663841862704*
W tym poziomie masz za zadanie zbudować obwód który może zapisać i załadować 4 różne bajty pamięci.

Dostajesz 1 bit, który decyduje, czy powinieneś załadować bajt. Kolejny bit decyduje, czy powinieneś zapisać bajt i towarzyszy mu wartość do zapisu.
Dodatkowo, masz 2 bity adresu.

Te 2 bity dają 4 kombinacje, po jednej na każdy z bajtów pamięci w tym poziomie.

[tip]Spacja obraca komponenty.[/tip]

$76851096880864* Czy dasz radę zmieścić 4 bajty pamięci w tak ograniczonej przestrzeni?



=== campaign/ram_component/test.si ===

$29258463778822* Wyjście było Z, a powinno wynosić {expected_value}.

$45179662026844* Wyjście powinno być Z.

$48251194975794* Wyjście wynosiło {actual_value}, a powinno wynosić {expected_value}.

$52597500133853* Zapisz {text_value} do {text_add}

$55086379351729* Załaduj {text_state} z {text_add}



=== campaign/ram_component/ui.txt ===

$22107475451139* [left]Zapisz ??? do ??[/left]

$27304327624610* [color=#E49F44][b]Stan[/b][/color]

$27457656265551* [color=#E49F44][b]Zapisz [/b][/color]

$57378010777762* [left]Załaduj ??? z ??[/left]

$62207646058430* [color=#E49F44][b]Załaduj [/b][/color]

$62589960113273* [color=#E49F44][b]Adres[/b][/color]

$71008031461945* [color=#E49F44][b]   Wartość   [/b][/color]

$85306375920893* [color=#E49F44][b]  Adres  [/b][/color]



=== campaign/sandbox/meta.txt ===

$58382627590046* Piaskownica



=== campaign/saving_bytes/hint_solution.txt ===

$73980120059844* Po prostu zrobiliśmy bajtową wersję z rozwiązań poziomu „Zapisywanie z gracją”.



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

$41663630841312* Zapisywanie bajtów

$87293777622656*
Stwórz obwód, który może przechowywać bajt.

Kiedy wejście „Zapisz” jest [T], zapisz bajt wejściowy.

Zawsze wysyłaj do wyjścia bajt, który jest obecnie przechowywany.



=== campaign/saving_gracefully/hint_0.txt ===

$14624167685294* Ten poziom wymaga użycia jednej linii opóźniającej.

$52905927349424* Jej wejścia to 2 wejścia poziomu ORAZ wyjście linii opóźniającej, które też gra tu rolę wejścia.

$61760299843073* Traktuj wejście linii opóźniającej jako wyjście twojej tablicy.

$83682732712729* Rozrysuj tablicę prawdy, opisującą, co powinno znaleźć się w linii opóźniającej.

$90057665917240* Mając cele poziomu w formie tablicy, powinno być ci znacznie łatwiej to rozwiązać.

$90652401745526* W sumie potrzebujesz w tej tablicy 3 „wejścia”, co daje ci 8 kombinacji.



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

$16548183735739* Ale przechowuje ona wartość tylko przez 1 cykl, co znaczy, że trzeba ją zapętlić, żeby ją odświeżać.

$64973475823722* Jedynym komponentów jaki mamy, który ma „pamięć” jest linia opóźniająca.



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

$11101940160071* Kiedy złącze akcji jest [T], lub zapisz, chcemy nadpisać ją wartością.

$19959785727663* Ale zrobienie tego prowadzi do zwarcia.



=== campaign/saving_gracefully/hint_solution.txt ===

$10919459809145* Więc używamy multipleksera, żeby zdecydować, którą wartość zapiszemy w linii opóźniającej.



=== campaign/saving_gracefully/label.txt ===

$88860903896097* Zapisz



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

$13114757255411*
W tym poziomie masz dwa wejścia.
Kiedy pierwsze z nich jest [T], zaktualizuj przechowywaną wartość.
Drugie wejście jest nową wartością.
Zawsze wysyłaj to, co jest w danej chwili przechowywane.

$39874917169400* Zapisywanie z gracją

$61501859914469*
Linia opóźniająca pozwala nam przechować wartość na 1 cykl. Jednak czasami użyteczny byłby komponent, który może przechowywać wartość przez dłuższy okres czasu.

Twoim zadanie jest zbudowanie takiego komponentu.



=== campaign/saving_gracefully/ui.txt ===

$10654649810679* Zapisz

$63465863198591* Wartość



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

$81345258398584* Tablica prawdy mówi nam, że wyjście jest [T]

$87387306821265* wtedy i tylko wtedy, gdy wejście 0 jest [T], a wejście 1 jest [F].



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

$11961528105462* Wyślij [T] tylko w drugim cyklu.

$69913560783046* Drugi cykl



=== campaign/signed_negator/hint_0.txt ===

$59964726775903* odwrócenie jej bitów (bajtowy NOT) i dodanie jednego.

$77523753173621* Negację dwójkowej liczby możemy otrzymać poprzez



=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* To jest już jednak ćwiczeniem dla gracza!

$55687805352825* Przedstawione rozwiązanie nie jest z żadnym razie eleganckie lub optymalne.



=== campaign/signed_negator/meta.txt ===

$15862778001173*
Traktując wejście jako liczbę ze znakiem (gdzie 8. bit jest -128), stwórz komponent, który neguję liczbę wejściową.
Na przykład zanegowane 4 zmieniłoby się w -4, a zanegowane -9 zmieniłoby się w 9.

$54237470041206* Negator ze znakiem



=== campaign/signed_negator/ui.txt ===

$10529708471093* Wejście



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

$36086882016175*
Większość instrukcji pobiera 2 argumenty i tworzy 1 wynik (np. ADD, OR, itd.).

[color=#e49f44]Symfonia[/color] używa 4 bajtów na instrukcję i może zakodować wszystkie trzy w każdej instrukcji, które są przechowywane w komponencie RAMu zwanym „pamięć główna”. Oznacza to, że możemy na przykład dodać dowolne dwa rejestry i zapisać wynik do dowolnego rejestru.

$62556352127349* Przewodowe spaghetti

$70083014183793* Nareszcie nadszedł czas na rozpoczęcie przez ciebie budowy architektury [color=#e49f44]Symfonia[/color]!

$83483553172261*
Mając to wszystko objaśnione, zaimplementuj instrukcję NAND.

Instrukcje są zakodowane w ten sposób:

[left]
                      [color=#ff9800]T[/color] = Tryb
                      [color=#ff6680]K[/color] = Kod rozkazu
                      [color=#ffe666]C[/color] = Cel (rejestr docelowy)
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Nieużywane / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]TT[/color][color=#bbbbbb]0[/color][color=#ff6680]KKKK[/color] [color=#ffe666]CCCC[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

Użyj dekodera do oddzielenia rejestrów docelowego i argumentów. Uważaj: porty odczytu i zapisu przyjmują adresy a bajtach, ale każdy z rejestrów zabiera 4 bajty. To oznacza, że musisz dostarczyć adres rejestru, a nie jego numer.
Tak w ogóle to w tym poziomie [color=#ff9800]tryb[/color] zawsze wynosi 1, a [color=#ff6680]kod operacji[/color] zawsze wynosi 0. Oznacza to, że wykonujemy NAND na pierwszym i drugim argumencie, a wynik zapisujemy do rejestru docelowego. Na razie możesz po prostu użyć 32-bitowej bramki NAND zamiast ALU.

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

$88649654188267*
To są nazwy wszystkich 16 rejestrów [color=#e49f44]Symfonii[/color]:

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

„zr” zawsze zwróci 0 przy odczycie, więc wszelkie zapisy do „zr” są odrzucane. Możemy to wykorzystać do uproszczenia naszego sprzętu. „ws” i „flagi” są normalnymi rejestrami, które po prostu mają inne nazwy. Będą one później zarezerwowane do specjalnych celów.

Zamiast używać pojedynczych rejestrów, użyj dostarczonego komponentu RAMu, który jest nazwany „plik rejestrów”.



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

$34545926188340* Adres odczytany a pamięci głównej powinien wynosić {expected_value}, a nie {actual_counter}. Licznik musiał zostać błędnie zaktualizowane w ostatnim cyklu.

$35453700742253* Komponent czasu nie powinien być włączony od ostatniego wykonania instrukcji czas_0.

$40674051088628* Ustawienie ekranu 3 powinno wynosić {expected_value}, a nie {value}.

$55420494010123* Adres {i} pamięci głównej powinien zawierać wartość {expected_value}, a nie {value}.

$56149980430079* Wyjście powinno być włączone.

$68153781027719* Adres {i} pamięci trwałej powinien zawierać wartość {expected_value}, a nie {value}.

$74043498193765* Wyjście powinno mieć wartość {expected_output}, a nie {output_value}.

$81124009043205* Rejestr „zr” powinien zawsze zawierać zero (adres 0 w „pliku rejestrów”).

$84654787309709* {register} (adres {address} w „pliku rejestrów”) powinien zawierać wartość szesnastkową {expected_value}, a nie {actual_value}.



=== campaign/symphony_1_nand/ui.txt ===

$21345632528660* Zbuduj podwaliny architektury Symfonia.



=== campaign/symphony_2_io/hint_solution.txt ===

$34652721020070* Szare przewody implementują tryb wejścia-wyjścia.



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

$66929200224494*
W tym poziomie, dodajemy metodę wprowadzania danych do i odczytu ich z [color=#e49f44]Symfonii[/color].

Jeszcze raz, instrukcje są zakodowane w ten sposób:

[left]
                      [color=#ff9800]T[/color] = Tryb
                      [color=#ff6680]K[/color] = Kod rozkazu
                      [color=#ffe666]C[/color] = Cel (rejestr docelowy)
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Nieużywane / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]TT[/color][color=#bbbbbb]0[/color][color=#ff6680]KKKK[/color] [color=#ffe666]CCCC[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

Tak jak w przypadku [color=#e49f44]Uwertury[/color] są 4 tryby:

0 Wejście-wyjście
1 ALU
2 Skok
3 RAM

Jednakże w tym poziomie musisz się martwić jedynie o tryby wejścia-wyjścia i ALU. W trybie ALU wykonaj instrukcję NAND, tak jak w poprzednim poziomie. W trybie wejścia-wyjścia wykonaj jedną z następujących instrukcji w zależności od kodu operacji:

0 nop (nie rób nic)
1 wejście (Zapisz wejście do [color=#ffe666]rejestru docelowego[/color].)
2 wyjście (Wyślij [color=#66ccff]argument B[/color] na wyjście.)

$85119202720349* Wejście-wyjście



=== campaign/symphony_2_io/ui.txt ===

$76620689360899* Dodaj tryb wejścia-wyjścia do Symfonii.



=== campaign/symphony_3_alu/hint_solution.txt ===

$23277299590423* Zamień bramkę NAND na komponent ALU.

$90347458725803* Ten nowy pomarańczowy przewód dostarcza kod operacji do ALU.



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

$13069282666558*
Dodaj ALU zbudowane w poprzednim poziomie do obwodu. Operacja dla każdej z instrukcji jest zakodowana w [color=#ff6680]kodzie operacji[/color].

[left]
                      [color=#ff9800]T[/color] = Tryb
                      [color=#ff6680]K[/color] = Kod operacji
                      [color=#ffe666]C[/color] = Cel (rejestr docelowy)
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Nieużywany / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]TT[/color][color=#bbbbbb]0[/color][color=#ff6680]KKKK[/color] [color=#ffe666]CCCC[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

$78613176066303* Dołączenie ALU



=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* Dodaj ALU do Symfonii.



=== campaign/symphony_9_aliases/default.isa ===

$11626177279992* Skocz do %a jeśli pierwsza wartość była wyższa (bez znaku) od drugiej (czytając wyniki z rejestru „flagi”).

$12835125621741* Zapisuje wartość %b do ustawienia %a ekranu.

$13110303123442* Zapisz %value pod adresem %adr pamięci trwałej.

$13576771671264* Przesuń logiczne %b w lewo o %c zapisz wynik do %a.

$15915531259935* Wysyła %a na wyjście.

$16685334571248* Przesuń logiczne %b w prawo o %c zapisz wynik do %a.

$18254089726214* Wysyła %a na wyjście.

$19953421010778* Zapisz %value pod adresem %adr pamięci głównej.

$23349431010010* Wykonaj ADD na %b oraz %c i zapisz wynik do %a.

$23396316982953* Ładuje adres %adr z pamięci głównej i zapisuje go do %dest.

$26183125927881* Skocz do %a jeśli pierwsza wartość była niższa (bez znaku) lub równa drugiej (czytając wyniki z rejestru „flagi”).

$27219499692147* Ładuje adres %adr z pamięci głównej i zapisuje go do %dest.

$27868418224252* Ładuje wejście z klawiatury i zapisuje je do %dest.

$28652904157569* Wykonaj SUB na %b oraz %c i zapisz wynik do %a.

$29562677483890* Zapisz %value pod adresem %adr pamięci głównej.

$30574433901064* Wykonaj OR na %b oraz %c i zapisz wynik do %a.

$31763492459833* Skocz do %a jeśli pierwsza wartość była niższa (bez znaku) od drugiej (czytając wyniki z rejestru „flagi”).

$37102964808364* Porównuje %a z %b i zapisuje wynik do rejestru „flagi”.

$37333076617857* Wykonaj NOR na %b oraz %c i zapisz wynik do %a.

$39857449355186* Zapisuje wartość %b do ustawienia %a ekranu.

$40732211165530* Wykonaj OR na %b oraz %c i zapisz wynik do %a.

$42626144645228* Przesuń arytmetycznie %b w prawo o %c zapisz wynik do %a.

$44524771082050* Ładuje wejście i zapisuje je do %a.

$46087142860391* Wykonaj NOR na %b oraz %c i zapisz wynik do %a.

$46967848572964* Wykonaj XOR na %b oraz %c i zapisz wynik do %a.

$47442552951774* Zapisz %value pod adresem %adr pamięci głównej.

$51030225266712* Wykonaj ADD na %b oraz %c i zapisz wynik do %a.

$53499765587663* Skocz do %a jeśli pierwsza wartość była większa (ze znakiem) lub równa drugiej (czytając wyniki z rejestru „flagi”).

$54565380946620* Porównuje %a z %b i zapisuje wynik do rejestru „flagi”.

$54577249258785* Przesuń logiczne %b w lewo o %c zapisz wynik do %a.

$55551510150818* Przesuń arytmetycznie %b w prawo o %c zapisz wynik do %a.

$57200935026773* Ładuje adres %adr z pamięci głównej i zapisuje go do %dest.

$59344052643304* Zapisz %value pod adresem %adr pamięci trwałej.

$61040780958703* Zapisz %value pod adresem %adr pamięci głównej.

$66785854415645* Wykonaj XOR na %b oraz %c i zapisz wynik do %a.

$67019902294705* Przesuń logiczne %b w prawo o %c zapisz wynik do %a.

$67178948469318* Skocz do %a jeśli wartości nie były równe (czytając wyniki z rejestru „flagi”).

$67376584796076* Ładuje wartość licznika i zapisuje ją do %dest.

$67495552371225* Wykonaj SUB na %b oraz %c i zapisz wynik do %a.

$68219187873304* Ładuje cztery wyższe bajty wartości czasu i zapisuje je do %a.

$69550893885320* Zapisz %value pod adresem %adr pamięci głównej.

$69632418904622* Ładuje adres %adr z pamięci głównej i zapisuje go do %dest.

$71317192057126* Skocz do %a jeśli pierwsza wartość była większa (ze znakiem) lub równa drugiej (czytając wyniki z rejestru „flagi”).

$71637103729391* Skocz do %a jeśli pierwsza wartość była mniejsza (ze znakiem) od drugiej (czytając wyniki z rejestru „flagi”).

$72280171778920* Ładuje adres %adr z pamięci trwałej i zapisuje go do %dest.

$72551400437977* Ładuje cztery niższe bajty wartości czasu i zapisuje je do %a.

$73559051740347* Zapisz %value pod adresem %adr pamięci głównej.

$74148826866592* Skocz do %a.

$75302656449127* Wykonaj NAND na %b oraz %c i zapisz wynik do %a.

$77040234358389* Skocz do %a jeśli pierwsza wartość była mniejsza (ze znakiem) lub równa drugiej (czytając wyniki z rejestru „flagi”).

$77232719678109* Ładuje adres %adr z pamięci głównej i zapisuje go do %dest.

$82087388048746* Skocz do %a jeśli pierwsza wartość była wyższa (bez znaku) lub równa drugiej (czytając wyniki z rejestru „flagi”).

$85679146831122* Wykonaj AND na %b oraz %c i zapisz wynik do %a.

$85822609095465* Ładuje adres %adr z pamięci głównej i zapisuje go do %dest.

$86705346481666* Wykonaj NAND na %b oraz %c i zapisz wynik do %a.

$86713121915282* Wykonaj AND na %b oraz %c i zapisz wynik do %a.

$88180305667389* Skocz do %a jeśli wartości były równe (czytając wyniki z rejestru „flagi”).

$88272577071256* Nic nie robi.

$89257021109854* Ładuje adres %adr z pamięci trwałej i zapisuje go do %dest.

$90876214388280* Skocz do %a.



=== campaign/symphony_9_aliases/label.txt ===

$28246040923235* Plik rejestrów

$41903613959902* Pamięć główna



=== campaign/symphony_alu/meta.txt ===

$52048822283735*
To jest kopia ALU Uwertury. Czas ulepszyć je do obsługi 32-bitowych wartości i dodać kilka nowych instrukcji.

Instrukcje:

[color=#87a8c8]0 NAND
1 OR
2 AND
3 NOR
4 ADD
5 SUB
6 XOR
7 LSL
8 LSR
9 ASR
10 CMP[/color]

Operacja cmp to ta, którą już stworzyliśmy w poprzednim poziomie jako komponent własny.

$71902120982324* ALU Symfonii



=== campaign/symphony_alu/ui.txt ===

$69427874681706* Zaimplementuj ALU Symfonii.



=== campaign/symphony_cmp/meta.txt ===

$37729390402296* Flagi porównania

$64818361855764*
W tym poziomie porównujesz dwa 32-bitowe wejścia na trzy różne sposoby. Każdy wynik jest 1 bitem zwanym „flagą”.

Flagi:
Ustaw bit 0 na 1 jeżeli wejścia są równe.
Ustaw bit 1 na 1 jeżeli pierwsze wejście jest niższe (bez znaku) od drugiego.
Ustaw bit 2 na 1 jeżeli pierwsze wejście jest mniejsze (ze znakiem) od drugiego.

Aby nauczyć się o komponentach 32-bitowych, otwórz wpierw poziom „Licznik Symfonii”, jeśli jeszcze cię tam nie było.



=== campaign/symphony_cmp/test.si ===

$55730459238598* Oczekiwane wyjście: {a}{b}{c}.



=== campaign/symphony_cmp/ui.txt ===

$73310930628112* Zaimplementuj flagi Symfonii.



=== campaign/symphony_condition_test/label.txt ===

$13327132168076* Wynik

$17010689474441* Warunek

$25959617344671* Flagi



=== campaign/symphony_counter_1/label.txt ===

$41164574218692* Licznik

$42019997838216* Nadpisz

$48990052180226* Wartość



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

$56387381898532* Licznik Symfonii

$76860406179468*
Żeby zmienić szerokość komponentu słownego, będziesz musieć użyć narzędzie szerokości bitowej znajdujące się przy lewym panelu (wygląda jak dwukierunkowa strzałka i liczba).

Kliknij narzędzie szerokości bitowej prawym przyciskiem, aby wybrać docelową szerokość.
Klikanie lewym przyciskiem na komponenty, kiedy narzędzie jest aktywne, ustawi ich szerokości bitowe.
Świeżo postawione elementy będą mieć tę szerokość bitową domyślnie.

$77897142643435*
Zbuduj 32-bitowy licznik, który zwiększa się o 4, ale alternatywnie może być też nadpisany konkretną wartością.

Poza tym podłącz dostarczoną sondę pamięci do 32-bitowego komponentu, który przechowuje wartość pamięci licznika.



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

$54301125260332* Pamięć powinna mieć wartość {expected_memory}, a nie {memory_value}.

$70376380014778* Wyjście nigdy nie powinno być z stanie Z.

$84451713761977* Wyjście powinno mieć wartość {expected_memory}.



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

$81792554779622* Zbuduj 32-bitowy licznik, który w każdym cyklu zwiększa się o 4.



=== campaign/symphony_decoder/label.txt ===

$16402377924132* Jest bezpośrednia

$24747841106265* Argument B

$26207217884026* Kod operacji

$26325060783055* Argument A

$40584554497383* Wartość bezpośrednia

$48212238534381* Instrukcja

$48506758479060* Tryb

$67128656777473* Cel



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

$13883461694525* Dekoder instrukcji

$41138026161536*
Użyj komponentu indeksera statycznego, aby rozwiązać ten poziom.

Indekser statyczny jest specjalnym komponentem, który pozwala ci wziąć z przewodu i przesunąć wybrane bity bez żadnego opóźnienia ani kosztu w bramkach. Zmiana liczby na tym komponencie przesunie bity (pozytywna przesuwa w prawo). Potem kliknij na komponencie, aby ustawić szerokość jego wyjścia.

$71911284169222*
Zbuduj obwód, który rozdziela instrukcję Symfonii na jej poszczególne części. Później będzie to bardzo pomocne.

Instrukcje symfonii mają dwa różne kodowania w zależności, czy korzystamy z wartości bezpośrednich, czy nie:

[left]
              [color=#ff9800]T[/color] = Tryb
              [color=#ff6680]K[/color] = Kod operacji
            [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Tryb wartości bezpośredniej
              [color=#ffe666]C[/color] = Cel (rejestr docelowy)
              [color=#66ff99]A[/color] = Argument A
              [color=#66ccff]B[/color] = Argument B (może być bezpośrednią)
              [color=#bbbbbb]0[/color] = Nieużywany / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]TT[/color][color=#9966ff]0[/color][color=#ff6680]KKKK[/color] [color=#ffe666]CCCC[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

[color=#bbbbbb]0[/color][color=#ff9800]TT[/color][color=#9966ff]1[/color][color=#ff6680]KKKK[/color] [color=#ffe666]CCCC[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]
  



=== campaign/symphony_decoder/test.si ===

$15174125339458* Kod operacji powinien wynosić {opcode}, a nie {actual_opcode}.

$31544476297744* Cel powinien wynosić {dest}.

$31942264008156* Argument B powinien wynosić {b}.

$45701446129480* Wartość bezpośrednia powinna wynosić {immediate_value}.

$63089562267538* „Jest bezpośrednia” powinno wynosić {immediate}.

$64926808682290* Tryb powinien wynosić {mode}.

$82638458430252* Argument A powinien wynosić {a}.



=== campaign/symphony_decoder/ui.txt ===

$51036929729507* Zaimplementuj dekoder Symfonii.



=== campaign/the_bus/hint_0.txt ===

$42863588667057* Użyj przełączników, żeby przekazywać wejścia na ten sam przewód.



=== campaign/the_bus/hint_1.txt ===

$88955803760495* Wybierane wejście to po prostu multiplekser.



=== campaign/the_bus/hint_solution.txt ===

$55189990966587* Zmodyfikuj multiplekser tak, żeby współdzielił wejście zamiast wyjścia, aby mieć wybierane wyjście.

$86286155471986* Purpurowy przewód po środku jest magistralą.



=== campaign/the_bus/label.txt ===

$25477689162292* Wybór wyjścia

$25535487507842* A

$43340511034957* Wybór wejścia

$43474590938240* Y

$47236089523392* X

$65041743851294* B



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

$10949534274977* Magistrala

$25369396405852*
Ten poziom ma 2 bajtowe wejścia i 2 bajtowe wyjścia. Twoim celem jest przekazanie liczby z jednego z wejść do jednego z wyjść.

Pierwsze wejście bitowe określa, z którego wejścia pobrać wartość. Drugie wejście bitowe określa, do którego wyjścia wysłać wartość.

W każdym cyklu tylko 1 wyjście otrzymuje wartość. Drugie powinno otrzymać Z (brak wartości). Jest to oznaczone jako „-” na wyjściu.



=== campaign/the_bus/test.si ===

$28173496384607* Wyjście Y powinno mieć wartość {val}.

$46672500255781* Wyjście X powinno mieć wartość Z.

$65293894030728* Wyjście X powinno mieć wartość {val}.

$69214136994673* Przekaż wartość z {source} do {destination}

$75577618213381* Wyjście Y powinno mieć wartość Z.



=== campaign/the_bus/ui.txt ===

$31341803878224* Stwórz obwód, który przekazuje wartość z określonego wejścia do określonego wyjścia.



=== campaign/xnor/hint_0.txt ===

$89305883777750* Widzisz, że wyjście bramki XNOR jest dokładnym przeciwieństwem bramki XOR?



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

$29396170535219* Stwórz odwróconą bramkę XOR, znaną jako XNOR.

$50956872142719* Bramka XNOR

$85674599929809* Większość Ziemian była ogromnymi gadami, kiedy ostatnio tu byliśmy. Żaden z nich nie był na tyle inteligentny ani uprzejmy, żeby dołączyć do Federacji Galaktycznej.



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

$15534865654723* Wejście 0

$17025412277453* Wejście 1

$59092390409834* Oczekiwane wyjście

$62308032073140* gdy albo wejście 0 jest [T] ORAZ wejście 1 jest [F], ALBO wejście 0 jest [F] ORAZ wejście 1 jest [T].

$84782011304318* Tablica prawdy mówi nam, że wyjście jest [T] wtedy i tylko wtedy,



=== campaign/xor_gate/hint_solution.txt ===

$16623524168613* To jest już jednak ćwiczeniem dla gracza!

$30671593085518* Przedstawione rozwiązanie nie jest z żadnym razie eleganckie lub optymalne.



=== campaign/xor_gate/label.txt ===

$22122562689406* Wyjście

$45326245069696* Wejście



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

$21287008524643* Bramka XOR

$30005674935190*
Nazywane jest to bramką XOR. Jest to trudny poziom, więc nie zniechęcaj się, jeśli nie uda ci się znaleźć rozwiązania od razu.

[tip]Możesz połączyć wyjście z więcej niż jedną bramką.[/tip]

$50002893048555* W poprzednim poziomie zbudowaliśmy obwód, który wysyłał [T] tylko podczas drugiego cyklu. W tym poziomie budujemy obwód, który wysyła [T] podczas drugiego lub trzeciego cyklu.



=== campaign/xor_gate/ui.txt ===

$38271404408184* Obecne wyjście



=== model/board/custom_prototype.nim ===


# Default new output pin name for custom compoennts
$14864122622568* Wyjście


# Default new input pin name for custom compoennts
$14951951489108* Wejście



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


# com_mux's output pin
$10003014068713* Wyjście


# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* Wej


# com_concatenator_8's input pin
$10080083255838* Słowo 3


# com_clz's output pin
$10092537578053* Wynik


# com_splitter_bit_4's output pin
$10111764008386* Bit 2


# com_level_output_4_pin's name
$10190739202646* Wyjście


# com_ctz's description
$10231593934948* Policz zera od najmniej znaczącej cyfry do pierwszej jedynki


# com_xor_word's output pin
$10269927015049* Wynik


# com_static_indexer_config's name
$10289043699917* Automatyczny Indekser Statyczny


# com_lsr's input pin
$10335381544532* Przesuń o


# com_halt's name
$10351143139905* Wstrzymaj


# com_nand_word's input pin
$10425218359878* Wejście 0


# com_splitter_bit_8's description
$10488114435022* Dzieli bajt na 8 bitów


# com_splitter_bit_8's output pin
$10491931394044* Bit 3


# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* WE/WY


# com_probe_wire_bit's input pin
$10499689720024* Wartość


# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* Dewel


# com_splitter_bit_4's name
$10524104374521* Rozdzielacz


# com_cc_output's name
$10557704838301* Złącze wyjściowe


# com_segment_display's name
$10582128204153* Wyświetlacz 7-Segmentowy


# com_switch_word's name
$10611658692685* Przełącznik


# com_xnor_bit's description
$10614106399129* [T] gdy wejścia są takie same


# com_not_word's description
$10624873506476* Odwróć poszczególne bity


# com_counter's output pin
$10629272823895* Wartość


# com_splitter_bit_2's output pin
$10655485270988* Bit 0


# com_splitter_bit_8's output pin
$10688845521356* Bit 1


# com_level_input_3_pin's name
$10689623552857* Wejście


# com_maker_bit_8's input pin
$10716205698752* Bit 5


# com_decoder_3's input pin
$10755367544042* Wejście


# com_delay_line_word_config's output pin
$10757852071445* Wynik


# com_rol's input pin
$10762061266647* Wartość


# com_decoder_2's output pin
$10762093809413* Bit 1


# com_nor_word's input pin
$10770218762282* Wejście 0


# com_concatenator_2's description
$10776829749898* Konkatenuje 2 wartości, z szerokością wyjścia, która jest sumą szerokości wszystkich wejść


# com_cc_output's description
$10781578424003* Złącze wyjściowe


# com_ror's description
$10802217509530* Przesuwa cyklicznie bity wejścia w prawo


# com_add's output pin
$10815269647822* Przeniesienie wyjściowe


# com_not_bit's description
$10844421681709* Odwraca wejście


# com_nand_word's description
$10859914201083* NAND poszczególne bity dwóch wartości


# com_full_adder's output pin
$10918445419498* Wynik


# com_static_value's output pin
$10920459933396* Wartość


# com_mod's description
$10934212906097* Reszta z dzielenia 2 liczb


# com_level_input_word's name
$10943344093513* Wejście


# com_keyboard's name
$10965596602414* Klawiatura


# com_less_s's output pin
$11019209691112* Wynik


# com_asr's name
$11034107377099* Arytmetyczne Przesunięcie w Prawo


# com_maker_word_2's description
$11048127331082* Scala 2 n/2 bitowe wartości w jedną n bitową wartość


# com_register_word_config's input pin
$11057152094224* Szerokość


# com_concatenator_8's input pin
$11115698874478* Słowo 0


# com_maker_bit_4's name
$11119510732154* Scalacz


# com_nand_bit's name
$11130919681688* NAND


# com_static_indexer_config's output pin
$11132082500971* Wynik


# com_mux's description
$11168613697835* Przełącza między dwiema wartościami


# com_full_adder's input pin
$11264799740288* Wejście 0


# com_level_input_switched's name
$11278573510238* Przełączane wejście


# com_not_word's name
$11286216680410* NOT


# com_maker_word_2's output pin
$11293966912554* Wynik


# com_decoder_2's output pin
$11297026031742* Bit 2


# com_level_output_word's name
$11300749636961* Wyjście


# com_full_adder's input pin
$11312161634667* Wejście 1


# com_delay_line_word_config's late input pin
$11320392055125* Wejście


# com_mod's output pin
$11329013865174* Wynik


# com_or_word's input pin
$11335506036805* Wejście 1


# com_level_input_word's description
$11342065742485* Wejście słowa


# com_splitter_word_4's output pin
$11345730126879* Słowo 0


# com_static_indexer_config's input pin
$11349557191063* Wejście


# com_maker_word_8's output pin
$11351867388170* Wynik


# com_mod's input pin
$11352468367638* Dzielna


# com_concatenator_8's input pin
$11366501215506* Słowo 2


# com_level_gate's name
$11417416554850* Komponent poziomu


# com_splitter_word_8's input pin
$11440186157356* Wejście


# com_level_input_4_pin's name
$11447837612693* Wejście


# com_inc's description
$11449663590476* Inkrementuje wejście o 1


# com_splitter_word_8's output pin
$11465347976002* Słowo 3


# com_level_output_switched's input pin
$11520072088720* Włącz


# com_asr's output pin
$11521973612539* Wynik


# com_splitter_bit_8's output pin
$11548514728473* Bit 0


# com_switch_bit's name
$11574334638147* Przełącznik


# com_nand_word's input pin
$11578787451669* Wejście 1


# com_div's input pin
$11611913368782* Dzielnik


# com_switch_word's output pin
$11625195403324* Wyjście


# com_maker_bit_8's input pin
$11634467729625* Bit 4


# com_neg's input pin
$11637742665554* Wejście


# com_clz's name
$11678932883790* Policz wiodące zera


# com_ram's name
$11710093917097* RAM


# com_decoder_2's name
$11727998752868* Dekoder 2-bitowy


# com_maker_bit_2's input pin
$11752209410617* Bit 1


# com_and_word's description
$11791872137683* AND poszczególne bity dwóch wartości


# com_mul's output pin
$11838813794006* Wynik


# com_off's name
$11860786587357* WYŁ


# com_splitter_bit_8's name
$11904470559153* Rozdzielacz


# com_nor_word's output pin
$11938328576163* Wynik


# com_delay_line_bit's output pin
$11945697622944* Wynik


# com_and_word's input pin
$11977039914327* Wejście 0


# com_neg's description
$12021716182809* Neguje wejście


# com_splitter_bit_2's input pin
$12046095993506* Wejście


# com_screen's name
$12046117430308* Ekran


# com_cc_level_output's description
$12051024347384* Wyjście słowa, które zostanie przekonwertowane na złącze WE/WY po zapisaniu rozwiązania jako komponent


# com_splitter_bit_4's input pin
$12060097589370* Wejście


# com_xnor_word's name
$12087865653212* XNOR


# com_ror's name
$12093087039542* Obrót w prawo


# com_delay_line_bit's name
$12121899638400* Linia opóźniająca


# com_nor_word's name
$12175906806727* NOR


# com_neg's output pin
$12196354295621* Wynik


# com_level_output_1_pin's name
$12242923444593* Wyjście


# com_level_output_counter's name
$12247325526438* Licznik


# com_maker_word_4's output pin
$12262460678043* Wynik


# com_probe_memory_bit's name
$12318534735397* Sonda pamięci (bit)


# com_concatenator_2's input pin
$12329350771997* Przewód 2


# com_concatenator_8's input pin
$12341255296823* Słowo 1


# com_verilog_output's name
$12353364840899* Wyjście Verilog


# com_probe_wire_asm's late input pin
$12365938365321* Wejście


# com_splitter_word_4's description
$12370556827575* Rozdziela 4n bitową wartość na cztery n bitowe wartości


# com_concatenator_4's input pin
$12371272172145* Słowo 1


# com_concatenator_8's input pin
$12384635971036* Słowo 5


# com_decoder_3's output pin
$12390018918095* Bit 7


# com_asr's input pin
$12408847893200* Przesuń o


# com_register_word's late input pin
$12420839132846* Wartość do zapisu


# com_constant's description
$12424468899005* Wartość stała


# com_concatenator_8's description
$12443053648819* Konkatenuje 8 wartości, z szerokością wyjścia, która jest sumą szerokości wszystkich wejść


# com_keyboard's output pin
$12465282633818* Wartość klawisza


# com_level_input_1_pin's output pin
$12465938629713* Wejście


# com_concatenator_8's output pin
$12478474747295* Wynik


# com_probe_memory_word's description
$12492235992906* Wyświetl wartość na własnym komponencie lub w edytorze programu


# com_mux's input pin
$12520768681157* Wartość 1


# com_switch_word's input pin
$12550214308917* Wartość


# com_maker_word_8's input pin
$12592072659210* Słowo 1


# com_maker_bit_2's name
$12602955212919* Scalacz


# com_maker_word_8's input pin
$12616927929524* Słowo 3


# com_static_indexer_config's input pin
$12633414511976* Szerokość


# com_delay_line_word's late input pin
$12644592179746* Wejście


# com_register_bit's name
$12678278048629* Rejestr


# com_mux's input pin
$12687047365426* Wartość 0


# com_and_bit's description
$12719674432950* [T] gdy oba wejścia są [T]


# com_splitter_word_2's name
$12723870092766* Rozdzielacz


# com_counter's description
$12736827510023* Inkrementuje w każdym cyklu, chyba że zostanie nadpisany


# com_level_input_1_pin's name
$12746117288689* Wejście


# com_off's description
$12749460799924* Zawsze [F]


# com_less_s's description
$12765625016236* Sprawdza, czy pierwsze wejście jest mniejsze od drugiego


# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* Bitowe


# com_switch_word's input pin
$12784430582183* Włącz


# com_lsl's input pin
$12849468178655* Wartość


# com_static_indexer_config's input pin
$12869119410565* Przesunięcie


# com_nand_bit's description
$12903183841172* [T] chyba, że oba wejścia są [T]


# com_and_word's name
$12926911335769* AND


# com_lsr's name
$12931148241340* Przesunięcie w prawo


# com_splitter_word_4's input pin
$12938882109013* Wejście


# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* Ekrany


# com_halt's description
$12990744955549* Wstrzymuje wykonanie z podanym komunikatem


# com_or_bit's description
$13013154620359* [T] gdy którekolwiek wejście jest [T]


# com_level_output_8_pin's name
$13087193858087* Wyjście


# com_maker_bit_8's input pin
$13104890311933* Bit 1


# com_rol's input pin
$13135722015590* Obróć o


# com_decoder_3's output pin
$13138546420646* Bit 6


# com_store_port's name
$13159020985209* Port zapisu


# com_level_output_3_pin's description
$13174121812559* Trzybitowe wyjście


# com_maker_word_4's input pin
$13236424504117* Słowo 2


# com_xor_word's description
$13236921580268* XOR poszczególne bity dwóch wartości


# com_level_output_2_pin's name
$13255344581755* Wyjście


# com_level_gate's description
$13259215761047* Używane do tworzenia map poziomów


# com_cc_input's description
$13263310288543* Pin wejściowy


# com_delay_line_word_config's input pin
$13271299225650* Szerokość


# com_level_input_1_pin's description
$13272198916233* Jednobitowe wejście


# com_register_word's late input pin
$13298317818150* Włącz zapis


# com_concatenator_4's input pin
$13331778821779* Słowo 0


# com_verilog_input's output pin
$13351141217116* Wejście


# com_nor_bit's name
$13375115196253* NOR


# com_maker_word_8's input pin
$13378739117488* Słowo 6


# com_less_u's name
$13502755965496* Mniejszy < (bez znaku)


# com_splitter_word_2's output pin
$13510688527850* Słowo 1


# com_ror's input pin
$13521735131997* Obróć o


# com_register_word's description
$13576980017857* Mały komponent pamięci


# com_splitter_word_2's output pin
$13625849577132* Słowo 0


# com_splitter_bit_8's output pin
$13666042416530* Bit 2


# com_keyboard's output pin
$13705122401876* Zdarzenie oczekuje


# com_splitter_bit_2's name
$13766521376720* Rozdzielacz


# com_maker_bit_4's input pin
$13826250945595* Bit 3


# com_ctz's input pin
$13829181406158* Wejście


# com_equal's input pin
$13859686951415* Wejście 0


# com_add's name
$13973952772642* Dodawanie


# com_xnor_bit's name
$14079327237795* XNOR


# com_lsl's output pin
$14132199132916* Wynik


# com_less_u's input pin
$14201184715010* Wejście 0


# com_maker_bit_4's input pin
$14237744302250* Bit 0


# com_keyboard's output pin
$14338437722935* Klawisz wciśnięty


# com_maker_bit_8's description
$14338505460996* Scala 8 bitów w jeden bajt


# com_level_input_2_pin's description
$14340334686746* Dwubitowe wejście


# com_decoder_3's name
$14375716460090* Dekoder 3-bitowy


# com_verilog_input's description
$14408471620057* Wejście Verilog


# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* Multi


# com_probe_wire_word's name
$14427436420428* Sonda przewodu


# com_not_bit's name
$14453052824732* NOT


# com_inc's name
$14456039381703* Inkrementacja


# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* Verilog


# com_nor_word's description
$14517798310461* NOR poszczególne bity dwóch wartości


# com_maker_bit_2's description
$14531866237078* Scala dwa bity w jedną 2 bitową wartość


# com_splitter_word_8's output pin
$14592399073683* Słowo 7


# com_splitter_bit_4's output pin
$14645527447275* Bit 0


# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* Pamięć


# com_decoder_3's output pin
$14688114733776* Bit 5


# com_maker_bit_8's input pin
$14770992007366* Bit 6


# com_maker_word_2's name
$14812135740513* Scalacz słów


# com_xor_bit's name
$14832952840086* XOR


# com_register_bit's output pin
$14834136969633* Wynik


# com_maker_bit_2's input pin
$14834270613682* Bit 0


# com_segment_display's input pin
$14849689592952* Wartość


# com_maker_bit_4's input pin
$14852108377004* Bit 2


# com_level_output_2_pin's description
$14875690243444* Dwubitowe wyjście


# com_maker_bit_8's output pin
$14889574903079* Wynik


# com_mul's input pin
$14896244080868* Wejście 0


# com_mul's input pin
$14913258317738* Wejście 1


# com_probe_wire_word's input pin
$14914933156268* Wartość


# com_level_input_switched's input pin
$14935676453720* Włącz


# com_maker_bit_8's input pin
$14944669923906* Bit 7


# com_div's name
$14959426271423* Dzielenie


# com_verilog_output's description
$14973155280765* Wyjście Verilog


# com_less_u's output pin
$15024221028085* Wynik


# com_mux's input pin
$15091015683874* Wybierz 0 / 1


# com_asr's description
$15194709458499* Przesuwa bity w prawo, zachowując znak liczby


# com_probe_wire_bit's description
$15206117280094* Wyświetl wartość na własnym komponencie lub w edytorze programu


# com_splitter_word_8's description
$15228522216068* Rozdziela 8n bitową wartość na osiem n bitowych wartości


# com_maker_word_4's input pin
$15232070727738* Słowo 1


# com_lsl's name
$15268915597774* Przesunięcie w lewo


# com_inc's output pin
$15310910823919* Wynik


# com_splitter_word_4's output pin
$15360783001914* Słowo 2


# com_less_s's name
$15403981009644* Mniejszy < (ze znakiem)


# com_maker_word_4's description
$15410415450178* Scala 4 n/4 bitowe wartości w jedną n bitową wartość


# com_splitter_word_2's description
$15417695246232* Rozdziela 2n bitową wartość na dwie n bitowe wartości


# com_mux's name
$15422378975821* Multiplekser


# com_less_s's input pin
$15432695156488* Wejście 0


# com_concatenator_4's description
$15492861320167* Konkatenuje 4 wartości, z szerokością wyjścia, która jest sumą szerokości wszystkich wejść


# com_decoder_3's output pin
$15527856774069* Bit 2


# com_rol's description
$15557725551789* Przesuwa cyklicznie bity wejścia w lewo


# com_splitter_word_4's output pin
$15566912320742* Słowo 1


# com_cc_level_output's name
$15625973306519* Wyjście


# com_not_word's output pin
$15635980858172* Wynik


# com_level_output_8_pin's input pin
$15649241608462* Wyjście 6


# com_equal's description
$15668435514829* Sprawdza, czy dwa wejścia są równe


# com_maker_word_4's input pin
$15693531522415* Słowo 0


# com_splitter_bit_4's output pin
$15744234453408* Bit 3


# com_concatenator_8's input pin
$15759275278695* Słowo 4


# com_ror's input pin
$15762072154176* Wartość


# com_xnor_word's description
$15789912406647* XNOR poszczególne bity dwóch wartości


# com_static_value's output pin
$15833633678405* Rozmiar w bitach


# com_maker_word_8's description
$15845204308823* Scala 8 n/8 bitowe wartości w jedną n bitową wartość


# com_constant's name
$15858905835416* Stała


# com_on's name
$15896157427528* WŁ


# com_decoder_2's output pin
$15898724303882* Bit 3


# com_concatenator_4's name
$15908922745328* Konkatenator


# com_or_word's input pin
$15962339721851* Wejście 0


# com_probe_wire_word's description
$15969687819995* Wyświetl wartość na własnym komponencie lub w edytorze programu


# com_clz's input pin
$15988469904002* Wejście


# com_register_word's name
$16007777261800* Rejestr


# com_time's name
$16011300295966* Czas


# com_splitter_word_4's output pin
$16099286786157* Słowo 3


# com_static_indexer's description
$16103423834548* Przesuń bity przewodu o stałą wartość bez kosztu w opóźnieniu ani bramkach. Dodatnie wartości przesuwają w prawo, a ujemne w lewo


# com_lsr's input pin
$16105779236896* Wartość


# com_less_s's input pin
$16118461327893* Wejście 1


# com_splitter_word_8's output pin
$16120663256468* Słowo 4


# com_level_output_word's description
$16148744080822* Wyjście słowa, które zostanie zamienione na pin WE/WY po zapisaniu rozwiązania jako komponent


# com_maker_word_2's input pin
$16178897760565* Słowo 1


# com_splitter_bit_8's input pin
$16196769003341* Wejście


# com_on's description
$16212935718484* Zawsze [T]


# com_mod's name
$16223673009720* Modulo


# com_level_output_4_pin's input pin
$16259545926196* Wyjście 0


# com_ror's output pin
$16261916666444* Wynik


# com_level_output_3_pin's name
$16269858195218* Wyjście


# com_static_eval's name
$16294314784377* Ewaluator statyczny


# com_less_u's input pin
$16307028951926* Wejście 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* Logika


# com_load_port's name
$16380513614754* Port odczytu


# com_counter's late input pin
$16380665909610* Nadpisz


# com_splitter_bit_4's description
$16428357982878* Rozdziela 4 bitową wartość na 4 bity


# com_load_port's description
$16440979564796* Dodaj złącze odczytu do komponentu pamięci


# com_concatenator_4's output pin
$16450922709110* Wynik


# com_lsl's description
$16482114876737* Przesuwa wejściowe bity w lewo


# com_mul's name
$16549841656852* Mnożenie


# com_add's output pin
$16559516323162* Wynik


# com_splitter_word_4's name
$16563671560208* Rozdzielacz


# com_level_input_3_pin's description
$16604606953092* Trzybitowe wejście


# com_maker_word_4's name
$16610055905190* Scalacz słów


# com_decoder_3's output pin
$16637198920534* Bit 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* Wyjścia


# com_xor_word's input pin
$16674052164634* Wejście 0


# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* Własne


# com_decoder_1's description
$16685462633615* Przełącza się pomiędzy dwoma wyjściami


# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* Poziomy


# com_rol's name
$16755142829250* Obrót w lewo


# com_segment_display's description
$16761198694928* Dobry do wyświetlania liczb


# com_keyboard's description
$16766452660421* Rejestruje naciśnięcia klawiszy z fizycznej klawiatury


# com_decoder_3's input pin
$16773243310913* Wyłącz


# com_level_input_switched's description
$16797889673362* Odczytuje wejście z poziomów


# com_and_word's output pin
$16806711173957* Wynik


# com_cc_level_input's name
$16810631435170* Wejście


# com_and_3_bit's description
$16839706221116* 3-wejściowa bramka AND


# com_xor_word's name
$16843812162355* XOR


# com_xor_bit's description
$16856280609387* [T] gdy wejścia są różne


# com_level_input_2_pin's name
$16870364449392* Wejście


# com_static_eval's description
$16874064281189* Oblicza wartość przed symulacją (staje się stałą podczas symulacji)


# com_probe_memory_bit's description
$16875362121056* Wyświetl wartość na własnym komponencie lub w edytorze programu


# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* Słowne


# com_switch_bit's description
$16917313833836* Włącza/wyłącza bit


# com_concatenator_8's name
$16974631589430* Konkatenator


# com_cc_level_output's input pin
$17030391013189* Wyjście


# com_splitter_bit_8's output pin
$17053062486634* Bit 4


# com_or_word's name
$17053670145576* OR


# com_xnor_word's output pin
$17089816656649* Wynik


# com_decoder_3's output pin
$17090003684860* Bit 4


# com_splitter_bit_8's output pin
$17163920171569* Bit 6


# com_static_value's name
$17192199509688* Wartość statyczna


# com_store_port's description
$17240636780043* Dodaj złącze zapisu do komponentu pamięci


# com_mod's input pin
$17244932190980* Dzielnik


# com_or_bit's name
$17247779246257* OR


# com_splitter_bit_2's output pin
$17293853955838* Bit 1


# com_switch_word's description
$17345192339084* Włącza/wyłącza wartość


# com_delay_line_word's name
$17407828844862* Linia opóźniająca


# com_splitter_word_8's output pin
$17425893786880* Słowo 6


# com_concatenator_2's name
$17495243848605* Konkatenator


# com_nor_bit's description
$17510848535619* [T] gdy żadne z wejść nie jest [T]


# com_maker_bit_8's input pin
$17515061804367* Bit 0


# com_full_adder's description
$17559382166174* Dodaje 3 bity i zwraca sumę oraz przeniesienie


# com_or_3_bit's description
$17576327690867* 3-wejściowa bramka OR


# com_maker_word_8's name
$17581447274882* Scalacz słów


# com_register_word_config's name
$17630501850089* Automatyczny rejestr


# com_level_output_3_pin's input pin
$17644027370563* Wyjście 2


# com_splitter_bit_8's output pin
$17664445405251* Bit 5


# com_full_adder's name
$17669928463861* Sumator pełny


# com_register_bit's description
$17670626909848* 1 bit pamięci


# com_maker_word_4's input pin
$17742753106024* Słowo 3


# com_register_bit's late input pin
$17744526831576* Włącz


# com_concatenator_2's output pin
$17758165407719* Wynik


# com_counter's late input pin
$17764401720104* Wartość nadpisania


# com_equal's input pin
$17767800149691* Wejście 1


# com_static_value's description
$17781742628050* Łatwo ustawiaj wartości lub szerokość na poszczególnych komponentach własnych


# com_add's input pin
$17802619460312* Wejście przeniesienia


# com_cc_input's name
$17814826739168* Złącze wejściowe


# com_add's input pin
$17820183531095* Wejście 0


# com_splitter_bit_4's output pin
$17862413256378* Bit 1


# com_equal's output pin
$17864898529357* Wynik


# com_maker_bit_4's input pin
$17897455882076* Bit 1


# com_store_port's input pin
$17908666907710* Wartość do zapisu


# com_concatenator_8's input pin
$17908668221433* Słowo 7


# com_maker_bit_8's input pin
$17957417956069* Bit 3


# com_level_output_switched's input pin
$17979647868788* Wyjście


# com_load_port's output pin
$17988237627670* Wyjście


# com_nand_word's name
$17989404583269* NAND


# com_store_port's input pin
$18001316449428* Adres


# com_counter's name
$18007194288764* Licznik


# com_splitter_word_8's name
$18008204445107* Rozdzielacz


# com_add's input pin
$18009367936916* Wejście 1


# com_div's input pin
$18043895181775* Dzielna


# com_maker_bit_2's output pin
$18060429242565* Wynik


# com_probe_wire_asm's late input pin
$18082830776248* Adres


# com_not_word's input pin
$18100827224098* Wejście


# com_and_word's input pin
$18149321315676* Wejście 1


# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* WE/WY


# com_keyboard's input pin
$18168295822085* Odczytaj następny


# com_store_port's input pin
$18196820862263* Włącz


# com_delay_line_bit's description
$18206009264853* Przechowuje wejście przez 1 cykl


# com_decoder_3's output pin
$18208851966397* Bit 3


# com_decoder_1's name
$18250587600120* Dekoder 1-bitowy


# com_level_output_2_pin's input pin
$18282543476901* Wyjście 0


# com_level_output_4_pin's description
$18308856504509* Czterobitowe wyjście


# com_level_output_switched's description
$18319747827404* Przełączane wyjście


# com_level_output_1_pin's description
$18342586404936* Jednobitowe wyjście


# com_maker_word_2's input pin
$18365137610205* Słowo 0


# com_neg's name
$18379907297327* Negacja


# com_load_port's input pin
$18399493738021* Włącz


# com_register_bit's late input pin
$18405644304073* Wartość


# com_full_adder's output pin
$18410639135888* Wyjście przeniesienia


# com_concatenator_2's input pin
$18414950181373* Przewód 1


# com_splitter_word_8's output pin
$18425501753807* Słowo 0


# com_add's description
$18429814030509* Dodaje dwa wejścia


# com_splitter_bit_8's output pin
$18437214963047* Bit 7


# com_delay_line_word_config's description
$18447417990806* Przechowuje wejście przez 1 cykl


# com_full_adder's input pin
$18480011054605* Wejście przeniesienia


# com_probe_memory_word's name
$18495107507052* Sonda pamięci


# com_time's output pin
$18510923212418* Nanosekundy od 1 sty 1970


# com_maker_bit_4's output pin
$18538545767544* Wynik


# com_splitter_word_8's output pin
$18541722201520* Słowo 2


# com_asr's input pin
$18563543025377* Wartość


# com_splitter_bit_2's description
$18566798809283* Rozdziela 2 bitową wartość na 2 bity


# com_register_word_config's late input pin
$18592599175225* Wartość do zapisu


# com_or_word's output pin
$18599325743999* Wynik


# com_nand_word's output pin
$18604301487974* Wynik


# com_mul's description
$18631919890554* Mnoży dwa wejścia


# com_less_u's description
$18645721548287* Sprawdza, czy pierwsze wejście jest mniejsze od drugiego


# com_maker_word_8's input pin
$18747558269936* Słowo 7


# com_maker_bit_8's name
$18747779812970* Scalacz


# com_time's description
$18774996925434* Nanosekundy od 1 stycznia 1970


# com_maker_bit_4's description
$18837875001662* Scala cztery bity w jedną 4 bitową wartość


# com_clz's description
$18865460617183* Policz zera od najbardziej znaczącej cyfry do pierwszej jedynki


# com_and_bit's name
$18912167455465* AND


# com_concatenator_4's input pin
$18970466583796* Słowo 2


# com_decoder_3's output pin
$19041825668970* Bit 0


# com_level_output_counter's description
$19047791955795* Trzybitowe wyjście


# com_maker_word_8's input pin
$19068496076705* Słowo 2


# com_load_port's input pin
$19069820293504* Adres


# com_concatenator_8's input pin
$19112189486457* Słowo 6


# com_lsl's input pin
$19120200575252* Przesuń o


# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* Sondy


# com_level_input_4_pin's description
$19187328896214* Czterobitowe wejście


# com_register_word_config's description
$19209488297941* Wersja rejestru z automatycznie zmienialnym rozmiarem


# com_maker_bit_8's input pin
$19209724501083* Bit 2


# com_ctz's name
$19218324472471* Policz końcowe zera


# com_splitter_word_8's output pin
$19229992367375* Słowo 5


# com_div's description
$19251828025705* Dzieli 2 liczby


# com_decoder_2's output pin
$19275565166747* Bit 0


# com_verilog_output's input pin
$19276197821142* Wejście


# com_concatenator_4's input pin
$19277763516215* Słowo 3


# com_xnor_word's input pin
$19329533997829* Wejście 0


# com_nor_word's input pin
$19354802063529* Wejście 1


# com_equal's name
$19369982838671* Równy


# com_lsr's description
$19394421220436* Przesuwa wejściowe bity w prawo


# com_div's output pin
$19403575811053* Wynik


# com_or_word's description
$19406015796751* OR poszczególne bity dwóch wartości


# com_delay_line_word_config's name
$19421095581293* Automatyczna linia opóźniająca


# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* Matem


# com_level_output_switched's name
$19513138880387* Przełączane wyjście


# com_probe_wire_bit's name
$19521764791439* Sonda przewodu (bit)


# com_maker_word_8's input pin
$19579002124406* Słowo 4


# com_inc's input pin
$19579388993928* Wejście


# com_xnor_word's input pin
$19579585753615* Wejście 1


# com_or_3_bit's name
$19630419947500* OR 3-wejściowy


# com_splitter_word_2's input pin
$19630801846451* Wejście


# com_and_3_bit's name
$19664974941910* AND 3-wejściowy


# com_register_word_config's late input pin
$19717901345023* Włącz zapis


# com_xor_word's input pin
$19719622211817* Wejście 1


# com_maker_word_8's input pin
$19740232065347* Słowo 0


# com_lsr's output pin
$19748092068880* Wynik


# com_maker_word_8's input pin
$19779691531031* Słowo 5


# com_verilog_input's name
$19796166910463* Wejście Verilog


# com_static_indexer's name
$19804933576629* Indekser statyczny


# com_ram's description
$19814732518166* Duży komponent pamięci


# com_cc_level_input's description
$19864966939331* Wejście, które zostanie zamienione na wejście niestandardowe, jeśli rozwiązanie zostanie zapisane w odlewni


# com_ctz's output pin
$19883191600386* Wynik


# com_splitter_word_8's output pin
$19903808503639* Słowo 1


# com_rol's output pin
$19903955254861* Wynik


# com_screen's description
$19974317694842* Konfigurowalny ekran


# com_push_button's name
$20020953885936* Przycisk


# com_level_output_3_pin's input pin
$21084166025569* Wyjście 1


# com_level_input_word's output pin
$21448308897245* Wejście


# com_level_input_2_pin's output pin
$24473197268827* Wejście 0


# com_probe_wire_asm's description
$27381538627533* Zdeasembluje wejście zgodnie z specyfikacją ISA twojej architektury.


# com_level_output_word's input pin
$27680966493404* Wyjście


# com_level_output_4_pin's input pin
$29217965518477* Wyjście 1


# com_static_eval's output pin
$29937009351190* Wynik jako szerokość


# com_level_input_4_pin's output pin
$36196915566111* Wejście 3


# com_level_output_8_pin's input pin
$38015555977208* Wyjście 3


# com_level_output_4_pin's input pin
$39260627694444* Wyjście 3


# com_level_output_8_pin's input pin
$39299381405096* Wyjście 0


# com_level_output_3_pin's input pin
$39908016538045* Wyjście 0


# com_level_input_3_pin's output pin
$42291627335021* Wejście 2


# com_delay_line_bit's late input pin
$43397945955203* Wejście


# com_level_output_2_pin's input pin
$44555908976270* Wyjście 1


# com_level_input_4_pin's output pin
$45891070331034* Wejście 1


# com_level_output_1_pin's input pin
$50802766489958* Wyjście


# com_probe_wire_asm's name
$53494192640542* Sonda deasemblująca


# com_delay_line_word's description
$53901484249817* Przechowuje wejście przez 1 cykl


# com_screen's input pin
$55023356915123* Indeks ustawienia


# com_level_input_2_pin's output pin
$55925432534232* Wejście 1


# com_push_button's description
$57617462098732* Zwróć [T], kiedy przycisk jest wciśnięty.


# com_register_word's output pin
$58518173140953* Wartość


# com_cc_level_input's output pin
$59388037506003* Wejście


# com_decoder_3's description
$61176454433312* Przełącza się pomiędzy ośmioma wyjściami w zależności od 3-bitowego złącza wejściowego.


# com_level_output_8_pin's input pin
$62385154489080* Wyjście 2


# com_screen's input pin
$63216408139965* Włącz wejścia


# com_level_output_8_pin's input pin
$64999131838438* Wyjście 4


# com_level_input_3_pin's output pin
$65765566466116* Wejście 0


# com_level_input_switched's output pin
$69212597107829* Wejście


# com_level_input_4_pin's output pin
$70142958857584* Wejście 2


# com_level_output_8_pin's input pin
$72375982885383* Wyjście 1


# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* Auto


# com_level_input_3_pin's output pin
$79311371309532* Wejście 1


# com_level_input_4_pin's output pin
$81933801309767* Wejście 0


# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* Różne


# com_level_output_counter's input pin
$84023157447564* Wyjście 0


# com_register_word_config's output pin
$84598344098990* wartość


# com_static_indexer_config's description
$85065774878853* Zaawansowana wersja „indeksera statycznego”. Przesunięcie i szerokość wyjścia są określane przez szerokości przewodów podłączonych do złączy wejściowych


# com_level_output_counter's input pin
$86331851878040* Wyjście 1


# com_decoder_2's description
$86848277190736* Przełącza się pomiędzy czterema wyjściami w zależności od 2-bitowego złącza wejściowego.

$87754378235471* Wyjście


# com_level_output_4_pin's input pin
$87954408093587* Wyjście 2


# com_screen's input pin
$88137790657923* Wartość


# com_level_output_8_pin's input pin
$88250281919265* Wyjście 5


# com_static_eval's output pin
$89594489498667* Wynik jako wartość


# com_level_output_counter's input pin
$89669851602178* Wyjście 2


# com_level_output_8_pin's input pin
$90233476470983* Wyjście 7



=== model/translations.nim ===

$11567406591202* 1 bajt

$14036822471924* {days} dni temu

$16391754618645* {size} KB

$17901039729248* {months} miesięcy temu

$18300496139706* 1 miesiąc temu

$18683857303458* {size} bajtów

$21685594109067* Przed chwilą


# Million
$22896492410578* M

$42553566189409* {minutes} minut temu

$70945526841433* {years} lat temu


# Billion
$71072134093858* B

$84076931764831* 1 dzień temu


# Thousand
$84696693690500* K

$86244493049244* {hours} godzin temu

$95018143828198* 1 rok temu

$98363990684104* 1 godzinę temu

$98703677236827* 1 minutę temu



=== presenter/board_ui.nim ===

$36331525379247* Zapisz ten schemat



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

$55369640789869* Kliknij gdziekolwiek na planszy, aby zacząć przewód\nPołącz czerwone komponenty z bramką NAND

$79416009887091* Kliknij gdziekolwiek na planszy, aby umieścić bramkę

$86840165316981* Kliknij prawym przyciskiem, aby odznaczyć bramkę



=== presenter/board_ui/bottom_panel/circular_dependency.nim ===

$13880985462901* Stwórz obwód, w którym wejście komponentu zależy od jego własnego wyjścia

$16336401898647* Test 1/2

$22446480186064* Stwórz zależność cykliczną obejmującą co najmniej 2 komponenty

$32314337981189* Sprawdź

$73467991035922* No chyba nie!

$89309211963063* Test 2/2



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

$10634456248075* Wejście 1

$10792411581963* {size} MB

$10967837475411* Wejście 1

$12673774208656* Bit 1

$12729457392140* {size} GB

$12806857886815* Bit 0

$12955769263032* Wejście

$13973719570693* Wielkość

$14527438551030* Wejście

$14913356525578* Koszt

$16406822661708* Wejście

$17231618567710* Początkowe dane

$18430168550669* Wynik

$23494294864855* Min {unit}

$23854618911893* Symulowane opóźnienie

$24632471752785* Plik

$26116781897961* Koszt

$27295540163510* Wejście 1

$30447216087962* Przesunięcie

$31208530565026* Wejście 0

$32492998000365* Wejście 0

$34792822299047* Wejście 1

$36741466396909* Wejście 2

$39848783424235* Wejście

$40353371905977* Stała


# Load a level
$41294322771286* Wczytaj

$45584048068675* Wejście 1

$47647445869837* Zera

$48920514303805* Odlewnia

$49848147518867* Wejście 2

$50011261574308* Wejście 1

$50488075986026* Wyjście

$52764622766005* Wyjście

$53201813578269* Asembler

$55717355371460* Wyjście

$56555605872372* Wyjście

$58366024847549* Wejście 0

$58805963760936* Dodatnie przesuwa w prawo, ujemne w lewo

$59987930153159* Wyjście

$61114700325299* Wejście 0

$64034551286307* Pamięć trwała

$64695289448271* Każdy z 8 bitów wartości włącza 1 z 8 obszarów wyświetlacza.

$65186041856822* Wyjście

$65254105186908* Wyjście

$65365515206856* Notka: Mimo, że komponent przechowuje wiele zdarzeń wciśnięcia i puszczenia klawisza, zwraca on tylko jedno na cykl!

$69729205667293* Edytor szesnastkowy

$70002762618597* Dół

$71918065858983* Zapisz

$75293122338496* Ilość stopni potoku

$76078010638637* Włącz

$76120552154698* Wejście 0

$76125262162505* Wejście 1

$77252050278971* Wyjście

$78475032277779* Wejście 0

$80252365204151* Karta perforowana

$81678588906692* Komunikat wstrzymania

$82521178851608* Wejście 0

$84542005958715* Etykieta

$85815999713437* Wejście 1

$88655619989708* Wejście 0

$88881918807029* Zablokuj

$89612128414294* Kierunek etykiety

$90286330794518* Wyjście

$91063734228931* Lewo

$95419083709418* Little endian

$95766090310621* Prawo

$97169317610794* Góra



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

$24027424800887* Następny poziom

$70403032472607* Świetnie! Przejdźmy do następnego poziomu.

$80966247197959* Kliknij przycisk Wejście w lewym górnym rogu, aby włączyć wejście.



=== presenter/board_ui/bottom_panel/nand_gate.nim ===

$32982011047799* Sprawdź

$43078933051174* Kliknij jeden z szarych przycisków w ostatnim wierszu tabeli.

$61241226128494* Spróbuj ponownie!

$71204033550134* Co robi bramka NAND?



=== presenter/board_ui/bottom_panel/racer_question.nim ===

$95509904060545* Wyślij



=== presenter/board_ui/bottom_panel/solution_warning.nim ===

$21618236951146* Pokaż rozwiązanie

$65770257567603* Jeśli masz pewność, że chcesz zobaczyć rozwiązanie, naciśnij przycisk poniżej.



=== presenter/board_ui/bottom_panel/user_defined_ui.nim ===

$10446152707984* Adres

$20074247151096* Instrukcja

$41540713506719* Instrukcja

$64281970848639* Opis



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

$10463931654475* Wejście 0

$14057674753878* Wejście 1

$58374689721038* BAJTY

$73841752788709* Wejście

$74796974148718* Wyjście



=== presenter/board_ui/component_menu/flat_list.nim ===

$70994998239232* Kliknij bramkę NAND, aby ją wybrać



=== presenter/board_ui/cycle_info.nim ===

$18403698792036* Typ poziomu

$41662660252584* Kursor

$53456282160464* Tryb piaskownicy

$72245209470436* Klatki/s

$74564675939961* Prędkość sym.

$99534264629442* Test



=== presenter/board_ui/file_explorer.nim ===


# Placeholder on the name input field of the file explorer
$18871898542185* Nowy folder

$56429258960561* Zmień nazwę

$69090690657232* Sklonuj


# Placeholder on the name input field of the file explorer
$84870575118100* Nowy plik

$91861509153454* Usuń



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

$36396661222670* Kliknij tu prawym przyciskiem, aby zmienić taktowanie

$39440928972984* Zresetuj ({key})

$42454393978813* Kliknij ten przycisk, aby uruchomić testy

$53448014080434* Usuń (skrót: prawy przycisk myszy)

$54853798559740* Wykonuj szybko ({key}) (prawy przycisk myszy: zmień prędkość)

$66405942066048* Poprzedni cykl

$68617247634978* Szerokość w bitach (prawy przycisk myszy: zmień szerokość)

$69987793052607* Komentarz do przewodu (kliknij przewód)

$78287906849040* Kolor przewodu

$80451578314373* Przybliż

$80746616574054* Następny cykl ({key}) (prawy przycisk myszy: przejdź do cyklu)

$84434122873489* Oddal

$85147529532131* Wielokrotny wybór (skrót: SHIFT i przeciągnij)



=== presenter/board_ui/io_state_view.nim ===


# MEMORY section title on the left panel
$13690653984793* Wyjścia


# MEMORY section title on the left panel
$34156015279634* Pamięć


# INPUTS section title on the left panel
$64033841051521* Wejścia



=== presenter/board_ui/menu_bar.nim ===

$11731996208080* Odlewnia

$30516879701896* Piaskownica

$33761197388580* Zobacz podpowiedzi

$38557550573896* Cele poziomu

$50924073287410* Zmień format liczb

$56916384895438* Menu główne

$71951682957395* Mapa poziomów

$79554853897000* Przełącz schemat

$85248932172256* Wyjdź z podpowiedzi

$85430022417382* Pokaż opóźnienie

$91515053618360* Podręcznik

$98930461722118* Wstecz



=== presenter/board_ui/menu_bar_campaign.nim ===

$68227209887733* Odlewnia


# Placeholder for the search bar in the level tree
$72813322690589* Szukaj poziomu



=== presenter/board_ui/popup/address_jumper.nim ===


# OK button on popups
$26766209496460* Ok

$36265530817755* Skocz do adresu

$40263691211335* offset w bajtach (16, 0xF, ...)



=== presenter/board_ui/popup/assembler_watchee_linker.nim ===

$37885763626223* Powiąż RAM

$51331074553774* Liczba rejestrów

$67225915898937* Prefiks

$67275059688693* Rozmiar

$77103446544344* Przykład: rej_

$77741358519166* Liczba



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

$19062117579269* Przewiń do cyklu: 



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

$16026817441460* cykle/sek.



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

$52150443679969* Kontynuuj

$89787506720574* Zamknij



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

$10090938799865* [large]Wpis w podręczniku[/large]\nWpis: [color=#68d277]{page}[/color]

$14047403461014* Energia (bramki x czas)

$16820079067437* Poziom ukończony

$20801641140962*
[b]Tryb mapy poziomów[/b]
[color=#cccccc]Kliknij „[color=#e49f44]Naprzód[/color]” i zobaczysz[/color]

$26794262854382* Odrzuć

$30368115829346* Najgorsze cykle

$32133561664335* Zachowaj oba

$33922330743421*
[b]Kolor przewodu[/b]
[color=#cccccc]Użyj kolorów do zorganizowania przewodów.[/color]

$40510295620397* Nadpisz

$41649402437253*

[b]Liczby ujemne[/b]
[color=#cccccc]Przełączaj między liczbami ze znakiem
i bez znaku[/color]

$43462148240207* Instrukcje na cykl

$43591599177045* Energia (Bramki x Opóźnienie)

$44038153424304* Zapis o nazwie „{save}” już istnieje

$45250062735373* Odblokowuje

$51096427131653* Naprzód

$53037516781370* Konflikty zapisu: 

$53389567901907* Komponent własny o nazwie „{comp}” już istnieje


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

$65428404547905* Statystyki


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


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

$69511102367948* Typ

$72987046679863* Czas (Opóźnienie x cykle)

$78783902500954*
[b]Profil sieciowy[/b]
[color=#cccccc]Znajdziesz go w menu głównym.[/color]

$84923734370936* Najgorszy test


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$90134890578411* Pozostałe

$92313038380926* Poziom

$92673421413755*

[b]Komentarze do przewodów[/b]
[color=#cccccc]Dodaj komentarze do swoich przewodów.[/color]

$94261690850981*
[b]Zapis szesnastkowy[/b]
[color=#cccccc]Przełączaj między liczbami ze znakiem,
bez znaku i szesnastkowymi[/color]



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

$11967666262990* Błąd specyfikacji! Otwórz edytor specyfikacji, aby to naprawić

$13400106910274* Linijka {nr}: {msg}


# IDE tab name
$88520918982355* Rejestry



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

$63693638857058* Zawiera {folders} folder(y).

$66107456188362* Zawiera {folders} folder(y) i {asm} plik(i) .asm.

$86093358515620* To jest pusty folder.

$93027749509988* Zawiera {asm} plik(i) .asm.



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

$84832818424728* Pliki



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

$12944436882589* Dodaj rejestr



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

$10141348037745* Wartość bezpośrednia: {nr}

$10366913897135* Klikaj, aby przełączać bity

$14831276667273* Instrukcje


# The text above the 3 LSBs
$25145891843959* Zawsze

$26521666422399* ALU

$31185395052385* WYJŚCIE


# The text above the 3 LSBs
$38497477227061* Gdy [color=#e49f44]wynik {condition} 0[/color]


# The text above the 3 LSBs
$39935096343723* Nigdy

$41846451178700* Przenieś z {from} do {to}.

$43723329256095* REJ {nr}

$53665446068319* NIEUŻYWANY

$54909668901048* Bezpośrednia


# The text below the byte
$59958585065722* Gdy [color=#e49f44]wynik {condition} 0[/color], przenieś [color=#DD6576][bold]REJ 0[/bold][/color] do licznika.

$67413863640193* Nie przenoś [color=#DD6576][bold]REJ 0[/bold][/color] do licznika.

$81322935207536* WEJŚCIE

$89294533225655* Wykonaj {operation} na [color=#DD6576][bold]REJ 1[/bold][/color] i [color=#DD6576][bold]REJ 2[/bold][/color]

$89662716409733* Bezwarunkowo przenieś [color=#DD6576][bold]REJ 0[/bold][/color] do licznika.

$92046368194170* Warunek

$98983752580592* Przenieś



=== presenter/board_ui/popup/schematic_browser/file_browser.nim ===

$14436541903929* Architektury: {list}

$17985924005596* Zawiera {nr} schemat(y).

$38011567415872* Folder jest pusty.

$51791491383290* Komponent własny jest używany w

$57790786178566* Komponenty własne: {list}

$66392158413243* Czy na pewno chcesz usunąć „{file_name}”?



=== presenter/board_ui/popup/schematic_browser/item_description.nim ===

$15827374884671* Do folderu nadrzędnego

$19184997172542* Używany w architekturach

$23950941073542* Nazwa

$32598300339944* <Udostępnij jako nowy schemat>

$32645745463577* Używany w komponentach

$34084132835354* Widoczny w menu

$36200352866864* Ostatnia edycja

$54460367152653* Udostępnij

$62604042376934* Eksportuj

$87138477300432* BBCode, z wyłączeniem [image] i [link].

$87579936985765* Wyrażam zgodę na użycie licencji [link=`CC0`]CC0[/link]

$95386916091656* Opis



=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* Wywnioskuj szerokość z wejścia

$61685569269160* Automatyczna

$70256730895162* Wartość statyczna



=== presenter/board_ui/popup/wire_comment_editor.nim ===

$36027984716180* Komentarz do przewodu



=== presenter/board_ui/racer_question.nim ===

$11176073682097* Jak zapisać {number} binarnie?

$13872783467999* Jak zapisać {number} binarnie ze znakiem?

$19099025738142* Start

$23959994711260* Gotowy do wyścigu?

$37093663674348* Poziom {x}

$41793938939207* Czas minął

$45532697833519* Dotarłeś do poziomu {level}!

$56999237564848* Pozostało {x} sekund

$92057009138253* Jak zapisać szesnastkowe {number} binarnie?



=== presenter/console.nim ===

$63321577947087* Wciśnij Enter, żeby zobaczyć polecenia



=== presenter/level_tree_ui.nim ===

$19508086025944* PROGRAMOWANIE 2

$26276191141664* Użyj klawiatury do poruszania

$35696974632265* Kolory mapy poziomów

$38100016313511* ARCHITEKTURA CPU 2

$38843517090942* DZIAŁAJĄCY KOMPUTER

$44937904689376* PROGRAMOWANIE

$51337598329530* ARYTMETYKA

$65362728703588* PAMIĘĆ

$75049509201775* LOGIKA BOOLOWSKA

$81337533438394* Ukończony

$81707212583931* Dostępny

$87420015169370* OPCJONALNE POZIOMY KOMPONENTÓW

$95146987030704* Zablokowany

$95559333192525* ARCHITEKTURA CPU



=== presenter/main_menu_ui/credits_page.nim ===

$15872341864658*
Szczere podziękowania dla:

[b]Tłumacze[/b]
{translators}

[b]Pierwsi testerzy beta[/b]
{beta_testers}

[b]Czcionki[/b]
{font_work}

[b]Gra Symphony[/b]
Ettapp

[b]Ścieżka dźwiękowa[/b]
{soundtrack}

$21717110565858* Twórcy



=== presenter/main_menu_ui/home_page.nim ===

$12639868461113* wyjdź

$13921098180953* centrum schematów

$15234594767991* twórcy

$16857608955464* piaskownica

$32835651830157* profil

$49251062339706* opcje

$66967233942803* zagraj w kampanię



=== presenter/main_menu_ui/hub/description.nim ===


# The hub schematic size
$15762392983604* Rozmiar:

$22639280459994* Pobieranie listy...

$44524092309946* Ładowanie...


# To download hub schematics
$55983490912314* Załaduj

$61693098943939* Kontynuuj


# To delete hub schematics
$62589392744014* Usuń


# To confirm deleting hub schematics
$66333328482057* Czy jesteś pewien?


# The hub author
$71812400203030* Przez:

$76747661573536* Tak

$76770986264566* Szukaj

$90731554079332* Nie znaleziono schematów



=== presenter/main_menu_ui/hub/filter.nim ===

$23829497228009* Typ

$25536941657464* Komponenty

$43488408276984* Popularne

$56045953383535* Architektury

$70134513915163* Nowo dodane

$77788981567936* Poziomy

$83319579232915* Pokaż

$87115430626073* Dodane przeze mnie



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

$13231048881956* Zresetuj cykle

$15032124477918* Kolor przewodu 4

$20313704155593* Kolor przewodu 6

$21380256293472* Zaznacz wszystko

$33884219481037* Przesuń widok w prawo

$36372993787575* Kolor przewodu 1

$50610605761210* Ponów

$52159578521318* Wklej

$53266310714298* Sterowanie

$55156524671891* Kolor przewodu 5

$58334563411624* Cofnij

$58442122157391* Pokoloruj przewód

$60118970740682* Uruchom

$64529333110609* Kolor przewodu 7

$66251711975517* Kolor przewodu 9

$67362258372706* Pokoloruj grupę przewodów

$74309706297402* Kopiuj

$76995246992803* Kolor przewodu 10

$77819900580235* Kolor przewodu 2

$78515694621006* Przesuń widok w lewo

$78673220868687* Kolor przewodu 8

$78777350869870* Naciśnij nowy klawisz

$80031998727851* Przesuń widok w górę

$83373647697807* Kolor przewodu 3

$86574817679356* Następny cykl

$87273391208106* Kolor przewodu 0

$88236351843942* Obróć

$88238310953306* Wytnij

$93140495547084* Przesuń widok w dół

$96339976117958* Pipeta koloru przewodów

$96449970906640* Dodaj komentarz do przewodu

$96601731563408* Otwórz konsolę



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

$12034378482152* Potwierdzić reset?

$13442839894535* Prędkość animacji przewodów

$15557473522933* Reset

$21908594290225* Ogólne

$23270083417453* Anuluj

$24145565754506* Głośność efektów

$29594613477534* Aby zmiana języka weszła w życie, musisz ponownie uruchomić grę.

$30910326565868* Język

$49806848871093* Tryb dla daltonistów

$54328660964287* Tryb okienkowy

$55047615798435* Tryb ułatwień dostępu

$61172959716558* Folder zapisów

$67420270098223* Zresetuj wszystko

$70994568832660* Usuń wszystko

$71208664264770*
Usunie to wszystkie rozwiązania poziomów, komponenty własne i architektury.
Tej operacji NIE MOŻNA cofnąć.
Czy na pewno chcesz to zrobić?
Zamknie to grę i zresetuje ją, gdy uruchomisz ją ponownie.

$93981778736076* Głośność muzyki

$95307230990123* Tryb Verilog



=== presenter/main_menu_ui/options/page.nim ===

$36195388998735* Ogólne



=== presenter/markup/markup.nim ===

$66207112287034* WSKAZÓWKA



=== presenter/update_state_common.nim ===

$13327741293223* Wejście {nr}

$29169064199243* Wyjście {nr}

$39906291838542* Cykl

$43118901497406* Opóźnienie

$70170261551278* Energia

$95192766583497* Bramki



=== presenter/update_state_stream.nim ===


# Text on keyboard component
$41639816417947* Rejestruj przy wykonywaniu


# Text on keyboard component
$61909856780806* Rejestruje


# Text on keyboard component
$73297471730751* Nie rejestruje



=== presenter/user_input/board_io/action/none.nim ===

$10186190492148* ALT + kliknięcie, aby przesunąć koniec przewodu

$22780831606716* Wczytaj plik

$26085882338208* Edytuj kartę perforowaną

$38481453712356* Edytuj asembler

$64854367750357* Otwórz edytor szesnastkowy

$80005228759908* Wartość tutaj: 

$98772447663910* Powiąż komponenty



=== presenter/utilities.nim ===


# Switched Output is the name under 19513138880387
$12249248261034* Nie możesz rozwiązać tego poziomu bez dodania komponentu „Przełączane wyjście”

$12256736989028* Masz więcej niż jedną sondę na tym samym polu.

$14665712485657* Tego komponentu własnego nie można użyć, ponieważ nie ma on obszaru.

$15549447390000* 2 komponenty wejścia/wyjścia są na tym samym polu. Komponent własny nie będzie mógł być użyty, ponieważ 2 złącza nie mogą się nakładać.

$25337574230078* Dwa złącza są na tym samym polu.

$27322222841583* Zwarcie między komponentami <> i <>

$29718660090112* Błędna odpowiedź

$32087108522443* Złącza szerokości mogą łączyć się tylko z innymi złączami szerokości.

$47880883686501* Zależność cykliczna – wyjście komponentu prowadzi z powrotem do jego własnego wejścia. Zobacz „Zależność cykliczna” w podręczniku.

$48909199348313* Testy zaliczone, ale rozwiązanie ma więcej niż {max_delay} opóźnienia

$56798729463813* Kod poziomu jest uszkodzony.

$73948669941805* Testy zaliczone, ale rozwiązanie ma więcej niż {max_gates} bramek


# Switched Input is the name under 11278573510238
$95056157627313* Nie możesz rozwiązać tego poziomu bez dodania komponentu „Przełączane wejście”



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


# Fallback for component name on the left panel
$11467644007149* Licznik {nr}


# Fallback for component name on the left panel
$11980538317261* Pamięć


# Fallback for component name on the left panel
$19471584538385* Wejście

$25272818268849*

[b]PODSUMOWANIE[/b]

Mam nadzieję, że zauważyłeś:
1. Istnieje dokładnie 1 sposób zapisania każdej liczby w systemie binarnym.
2. Wartość każdej cyfry jest zawsze dwukrotnością wartości poprzedniej cyfry.

$37319690622142* Dobra robota, dotarłeś do poziomu {current_level}.


# Fallback for component name on the left panel
$41936481068702* Licznik


# Fallback for component name on the left panel
$42012207828907* Rejestr


# Fallback for component name on the left panel
$44820775847452* Wyjście

$87016829502381* Dobra robota, dotarłeś do poziomu {current_level}.


# Fallback for component name on the left panel
$87591753278764* Rejestr {nr}

$97450409600317*
[b]KLUCZOWE WNIOSKI[/b]

1. Aby przejść między liczbą ujemną a dodatnią, odwracasz wszystkie bity i dodajesz[nbsp]1.
2. Jeśli najwyższy bit jest [T], wartość jest zawsze ujemna.
3. Sumator bajtów, który zbudowałeś, działa również z liczbami ze znakiem.
4. Nadal istnieje tylko 1 sposób zapisania każdej liczby.


# Fallback for component name on the left panel
$97889215332379* Pamięć {nr}

