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


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

$29435797471674*
[large]Overview[/large]
The point of an assembly language is to give human readable nicknames to the instructions that computers execute.

The assembly syntax here follows general conventions, so you should be able to read assembly from most real CPUs after you learn these.

Instruction syntax begins with an abbreviated word, called a "[color=#9966ff]mnemonic[/color]", which describes the instruction. It is followed by a list of [color=#66ccff]operands[/color], like so:[box][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]4[/color][/box]

Assembly programs are mostly just lists of instructions.

[large]Operands[/large]

There are several types of [color=#66ccff]operands[/color].

[b]Registers[/b]
In the above example [color=#66ccff]r1[/color] is replaced with 1 in the generated machine code.

[b]Numbers[/b]
In the above example [color=#66ccff]4[/color] is inserted directly into the machine code.

[b]Labels[/b]
For jump instructions, you generally want to reference offsets in the generated machine code. These offsets can be automatically calculated for you using labels: [box][color=#9966ff]jmp[/color] [color=#66ccff]my_label[/color]
...
[color=#66ccff]my_label:[/color][/box]
Labels are always declared by adding a name on a line with a colon after it.


[large]Other features[/large]

[b]Comments[/b]
Everything on the same line after [highlight];[/highlight] is considered a comment and ignored by the assembler, like so:
[box][color=#eeeeee]mov r1, 123 [/color][color=#999999]; Moving 123 into register 1[/color]
[/box]

[b]Raw data[/b]
You can insert data directly in between the assembled instructions like so:
[highlight]U8 123[/highlight]
Here we insert the byte 123. [highlight]U8[/highlight] means "unsigned 8 bit value", but the assembler also supports [highlight]U16[/highlight], [highlight]U32[/highlight] and [highlight]U64[/highlight].
You can also insert the value of ASCII characters like so:
[highlight]"Hello"[/highlight]

[b]const[/b]
Create new names for your registers or other operand types like this:
[highlight]const ROTATION = r0[/highlight]
In this example [highlight]ROTATION[/highlight] becomes an alternative name for r0. Creating local names for your registers can make your code easier to read.

[b]Sections[/b]
Insert an [highlight]@[/highlight] with an address to make the assembler to insert zeroes until it reaches that address. For example:
[highlight]@0x800[/highlight]

[b]Include[/b]
You can include other assembly files, for example including "std_lib.asm" from the parent folder:
[highlight]include ../std_lib[/highlight]

Including another assembly file will insert its assembled result where the include is placed. You can also use the labels and 'set' names defined in the included file, if they are exposed in their file by being prefixed by the 'pub' keyword, like so:
[highlight]pub print:[/highlight]

To access an exposed name or label, put the file name and a dot before the name, like so:
[highlight]jmp std_lib.print[/highlight]
Using this you can create a library of functions that can be called from any level. Just put the library file in the folder above the levels and expose the labels that correspond to each function.



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

$81923869207578* Assembly programming



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

$57024194971618*
The [highlight]\[fields][/highlight] section defines different types of fields that can be included in the instruction definitions, as well as what values they can have. 

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

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

Fields are separated by blank lines, and each field starts with a field name on the first line followed by one or more allowable field values. Values are bit patterns and all values within a field must have the same bit length.

Fields are used in instructions like this:
[box]mov r1, r3[/box]

[b]Default values[/b]
Some architectures, like aarch64, allows an optional "#" before immediates. This can be handled using fields. Notice that quotes are allowed around field names for this reason.

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

[b]Reserved field names[/b]
There are two reserved names:
* [highlight]label[/highlight] references labels within the assembler (eg: [highlight]mylabel:[/highlight]).
* [highlight]immediate[/highlight] references immediate values



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

$32103815380062* Fields



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

$20029422748716*

[b]Expression Operators[/b]
The game provides a limited set of operators for the construction of virtual operands:
[box]Operator        Description                              Example       Result if %a = -30000
!               boolean not                              !%a           0
&&              boolean and                              %a && 7       1
||              boolean or                               %a || 7       1
\==              equal                                    %a == 7       0
!=              not equal                                %a != 7       1
<u              unsigned less than                       %a <u 7       0
<               signed less than                         %a < 7        1
>=u             unsigned greater than or equal           %a >=u 7      1
>=              signed greater than or equal             %a >= 7       0
<=u             unsigned less than or equal              %a <=u 7      0
<=              signed less than or equal                %a <= 7       1
>u              unsigned greater than                    %a >u 7       1
>               signed greater than                      %a > 7        0
~               bitwise NOT                              ~%a           29999
&               bitwise AND                              %a & 7        0
|               bitwise OR                               %a | 7        -29993
^               bitwise XOR                              %a ^ 7        -29993
+               addition                                 %a + 7        -29993
-               subtraction                              %a - 7        -30007
*               multiplication                           %a * 7        -210000
/u              unsigned division                        %a /u 7       2635249153387074516
/               signed division                          %a / 7        -4285
%               modulo (remainder after division)        %a % 7        -5
<<              logical shift left (LSL)                 %a << 7       -3840000
>>              logical shift right (LSR)                %a >> 7       144115188075855637
[/box]
A notable omission is the lack of a negation operation. However, by default if a either '+' or '-' operator is missing a first operand it will use a value of 0 in it's place meaning that this is handled by the existing minus operator.



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

$21043147057012* Operators



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

$64897298154598*
[large]Overview[/large]

The [link="Assembly/Language creation"]Language creation[/link] page describes only basic instruction definitions, this page aims to cover more advanced features.

An instruction definition consists of the following lines:

[color=#66ff99]Syntax[/color]
[color=#ffe666]Virtual operands[/color] (optional)
[color=#ff6680]Assertions[/color] (optional)
[color=#66ccff]Machine code[/color]
[color=#9966ff]Description[/color]

Example:
[box][color=#66ff99]jmp %offset(label)[/color]
[color=#ffe666]%high_bits = %offset / 4[/color]
[color=#ff6680]assert(%offset % 4 == 0, "Can only jump to 4 byte aligned addresses")[/color]
[color=#66ccff]01 hhhhhh[/color]
[color=#9966ff]# Jump to %offset[/color][/box]

[large][color=#66ff99]Syntax[/color][/large]
Syntaxes are a list of [b]literals[/b] and [b]operands[/b], seperated by [b]whitespace[/b].

[b]Literals[/b]
In the above example the mnemonic [highlight]jmp[/highlight] is a literal. Instructions with multiple operands typically have operands seperated by [highlight],[/highlight] literals as well.
Use [highlight]%%[/highlight] to escape [highlight]%[/highlight] symbol in literals.

[b]Operands[/b]
Instruction operands start with the [highlight]%[/highlight] prefix and are written in the form [highlight]%name(fields)[/highlight].
* [highlight]name[/highlight] is any identifier. 
* [highlight]fields[/highlight] is a list of one or more fields created in the prior section "Fields" (or the reserved fields). The list is delimited by the pipe ([highlight]|[/highlight]) character.

[b]Whitespace[/b]
Whitespace can be either tabs or spaces. If a single whitespace character is used, the space will be optional in the assembly language. If the whitespace character is instead followed by another space, the assembler will require whitespace between the tokens.


[large][color=#ffe666]Virtual operands[/color][/large]
In the architecture of the jump example above, all instructions are 4 byte wide, so the lower two bits of the jump destination is always supposed to be 0. We can create a new virtual operand without these two lower bits like so:
[box]%high_bits = %offset / 4[/box]
We will use [highlight]%high_bits[/highlight] instead of [highlight]%offset[/highlight] in the machine code definition.
A list of supported operators can be found [link="Assembly/Language creation/Instructions/Operators"]here[/link].

Two special operands are automatically defined, [highlight]$start[/highlight] and [highlight]$end[/highlight]. $start is the offset of the machine code just before the instruction and $end is just after. These can for example be used to calculate offsets relative to the current instruction, like so:
[box]%rel_offset = %offset - $end[/box]

[large][color=#ff6680]Assertions[/color][/large]
Assertions allow you to check for user errors. In the example above, we use them to ensure that we are jumping to a 4 byte aligned address.


[large][color=#66ccff]Machine code[/color][/large]
The example above uses the following machine code syntax.
[box]01 hhhhhh[/box]
Note that [highlight]h[/highlight] refers to the [highlight]%high_bits[/highlight] virtual operand. Using this syntax, bits of operands are always represented by the first letter of their name.

An alternative but equivelent way to write the same thing is using [b]bit slicing[/b] instead:
[box]01 %offset\[8:2][/box]
Bit slicing uses standard hardware syntax for selecting a part of a bit field. The syntax is: [highlight]\[last:first][/highlight] where both first and last are inclusive.

Bit slicing can be used on multiple operands and intermixed with one bit per character syntax.


[large][color=#9966ff]Description[/color][/large]
The description has no function to the assembler, it exists purely for documentation purposes.



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

$27583144414493* Instructions



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

$29662258275697*
The [highlight][patterns][/highlight] section is where we define text-replacement macros to reduce duplication in instruction definitions. Pattern structure is similar to instructions:

[color=#66ff99]Pattern signature[/color]
[color=#66ccff]Syntax replacement[/color]
[color=#9966ff]Machine code replacement[/color]

Example:
[box][patterns]

[color=#66ff99]pattern size(width, machine_code)[/color]
[color=#66ccff]U{width}[/color]
[color=#9966ff]00{machine_code}[/color]

[instructions]

mov_%s\[[color=#66ff99]size([/color][color=#66ccff]"8"[/color], [color=#9966ff]"00"[/color][color=#66ff99])[/color] | [color=#66ff99]size([/color][color=#66ccff]"16"[/color], [color=#9966ff]"01"[/color][color=#66ff99])[/color]] %a(reg) %b(reg)
0000 [color=#9966ff]%s[/color] %a %b
\# Move to %a from %b

[/box]
After text replacement this becomes:
[box][instructions]

mov_[color=#66ccff]U8[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0000[/color] %a %b
\# Move to %a from %b

mov_[color=#66ccff]U16[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0001[/color] %a %b
\# Move to %a from %b

[/box]
In the example above, we first see a pattern being declared. The declaration starts with the "pattern" keyword and is followed by its name and after that names of arguments. The two lines below that are text snippets that will be pasted in to the syntax and machine code lines respectively.

In the instruction, the variables name [highlight]%s[/highlight] is placed in the syntax line. In the example, the parser enumerates each of the two version that [highlight]%s[/highlight] captures and instantiates a new instruction for each. It pastes in the syntax line and machine code snippets and replaces the pattern arguments with the given values.



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

$50803475056346* Patterns



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

$13660841232898*
The [highlight]\[settings][/highlight] section defines several configuration properties for your architecture:

[b]name[/b]
[box]name = "Architecture name"
[/box]Name of the architecture.

[b]variant[/b]
[box]variant = "Architecture variant"
[/box]Additional description of the architecture.

[b]endianness[/b]
Defines the byte order of the instructions.
[box]endianness = big
endianness = little[/box]
The default is big endian.

You can read more about endianness [link="Computer concepts/Endianness"]here[/link].

[box=info]RAM components have their own endianness flag, which can reverse the byte order again. This is straightforward if your instruction width happens to match the memory component' s bit width, but can be confusing if the widths differ.[/box]

[b]line_comments[/b]
Specifies the tokens used to mark the start of a single-line comment. Single-line comments start at the given token and consume the remainder of the line.
[box]line_comments = "#"
line_comments = \[";", "//"][/box]
The default line_comments value is [highlight]\[";", "//"][/highlight].

[b]block_comments[/b]
Specifies the tokens used to mark the start and end of a block comment. Block comments start at the first token and consume everything up to the final token. This includes line breaks as well as additional block comment start tokens (preventing block comments from being nested).
[box]block_comments = {"/*":"*/"}[/box]
The default block_comments value is [highlight]{"/*":"*/"}[/highlight].



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

$78090021698706* Settings



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

$41184546203403*
[large]Overview[/large]

This is an example of a simple assembly definition:
[box][fields]
register
r0 000
r1 001
r2 010
r3 011

[instructions]
mov %a(register), %b(register)
00aaabbb
\# Move a value to %a from %b

mov %a(register), %b:U8(immediate)
01000aaa bbbbbbbb
\# Move a byte to %a from %b

jmp %a(label)
10000000 aaaaaaaa
\# Jump to %a[/box]

Notice the definition is split into two sections [highlight][fields][/highlight] and [highlight][instructions][/highlight].

[large][fields] section[/large]
Fields allow you to give names to bit patterns. This is typically used for registers. More details [link="Assembly/Language creation/Fields"]here[/link].

[large][instructions] section[/large]
Instruction definitions consist of a [color=#66ff99]syntax[/color] line, a [color=#66ccff]machine code[/color] line and a [color=#9966ff]description[/color] line:

[box][color=#66ff99]mov %a(register), %b(register)[/color]
[color=#66ccff]00aaabbb[/color]
[color=#9966ff]# Move a value to %a from %b[/color][/box]
When you type assembly instructions in your language, the assembler will scan this list of definitions, find the first [color=#66ff99]syntax[/color] that matches and produce the corresponding [color=#66ccff]machine code[/color].

[b][color=#66ff99]Syntax line[/color][/b]
The syntax line is a mix of hard coded strings and operands. Operands always start with [highlight]%[/highlight] followed by a name that identifies it on the other lines. Next to this comes an operand field, which can be [highlight]label[/highlight], [highlight]immediate[/highlight] or a custom [highlight]field[/highlight] you defined in the [b][fields][/b] section.

[b][color=#66ccff]Machine code line[/color][/b]
The bitfield line matches [highlight]0[/highlight] or [highlight]1[/highlight] as well as the first letter of any of the operand names defined in the syntax line. [highlight]0[/highlight] and [highlight]1[/highlight] are interpreted literally, while operand letters will use one binary digit at a time from the value of their operand. 

[b][color=#9966ff]Description line[/color][/b]
The description has no function to the assembler, it exists purely for documentation purposes.

The assembler supports a lot more instructions features that you can read about [link="Assembly/Language creation/Instructions"]here[/link].

[large]Other sections[/large]
In addition to [b][fields][/b] and [b][instructions][/b] there are two other optional sections, [b][link="Assembly/Language creation/Settings"][settings][/link][/b] and [b][link="Assembly/Language creation/Patterns"][patterns][/link][/b].



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

$67371980949119* Language creation



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

$85571962806085* Assembly



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

$65852115931553*
Auto size is a feature that gives you more flexibility when creating custom components. For example, this schematic is a counter that works at any size and has a configurable increment:
[image="example.png"]

Notice some of the size labels have a different background color. This is because they have been set to be automatically inferred. You can set size to be auto inferred using this button.
[image="setting.png"]

Generally speaking, most components can have auto size enabled, and when that's enabled, will take on the size of the wire that leads to one of their input pins. Which pin an auto sized component takes its size from is different for each component. For example the adder above, will take the largest size of its two numeric inputs while ignoring any potential wire connected to the carry in pin.

For technical reasons this doesn't work for memory components. To get an auto sized register or delay line, you can use the special versions of them that have a blue pin, as seen in the example above. Blue pins are generally for features related to auto size.



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

$18060272082456* Auto size



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

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

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

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

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

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



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

$79928695804890* Circular dependency



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

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

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



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

$82367602514282* Delay



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

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

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

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

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

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



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

$80662783536910* Short circuit



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

$43200267887776*
Open the foundry by clicking on this button  in the upper left bar.

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

The input and output components you place become pins on the component. 

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

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



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

$83185064398279* The foundry



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

$18477347795935*
The keyboard component records key presses from your keyboard.

Every key press will result in two events, a key down and a key up event. Events can then be read one at a time from the component.

[large]Keyboard modes[/large]
Different countries use different keyboards, for example, while the first character row of an english keyboard starts with QWERTY, it starts with AZERTY on french keyboards. 

If you are making a text editor, you don't care about the physical location of the keys, you just want to know what is printed on top of them. In this case you should use [b]Localized mode[/b].

If on the other hand you want to use the upper left keys for game controls, you don't want to deal with WASD on english keyboards being ZQSD on french keyboards. You just want to refence the physical location of the keys on the keyboard, not what is printed on top of them. In this case you should use [b]Physical location mode[/b].

[large]Localized mode[/large]
In this mode, keys are mapped to the ASCII value where possible. The [highlight]w[/highlight] on a QWERTY, AZERTY or any other keyboard will always be [highlight]0x77[/highlight].

[large]Physical location mode[/large]
In this mode, keys are mapped to their the physical row and colum location. Both row and columns use 4 bits, so locations can be written neatly in hex. For example spacebar which is on the 5th row and 3rd column is 0x53 in hex.

[image="coordinate_mode.png"]

Note that the side of the keyboard to the right of the black line have larger row numbers to fit all keys within the 4 bit row and column constraint.

If your keyboard does not look like the diagram, you can experiment to see which value each key outputs.



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

$11486015900582* The keyboard



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

$76434165550872*
Link the screen to a RAM component to show the data inside. How exactly the data is displayed depends on the selected mode.

[large]Screen modes[/large]
The screen has four modes, which change the way it displays values:
0: ASCII 8
1: ASCII 32
2: Pixel 8
3: Pixel 32

Further, each mode has different settings, which can be changed while running using the screens input pins.

[large]ASCII 8 mode[/large]
Each byte is interpreted as a character on an 96 by 40 character screen. 

[b]Settings:[/b]
0 Change mode
1 Set data offset
2 Set foreground color
3 Set background color
4 Set font

[large]ASCII 32 mode[/large]
Every 4 bytes consist of a character, a foreground color, a background color and a padding byte.

8-bit colors have 3 bits for red, 3 bits for green and 2 bits for blue, like so:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

[b]Settings:[/b]
0 Change mode
1 Set data offset

[large]Pixel 8[/large]
Each byte is interpreted as a pixel color, with 3 bits for red, 
3 bits for green and 2 bits for blue, like so:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

Pixel modes resolutions are 4:3 aspect ratio, from 4×3 all the way to 1024×768.
The resolution is calculated based on the setting as follows: 
4 × (setting + 1) : 3 × (setting + 1)

[b]Settings:[/b]
0 Change mode
1 Set data offset
2 Set resolution 

[large]Pixel 32[/large]
Every 4 bytes are interpreted as a pixel color, with one byte each for red, green and blue, and a final padding byte:
[b][color=#ff5555]RRRRRRRR[/color][color=#55ff55]GGGGGGGG[/color][color=#5555ff]BBBBBBBB[/color][/b]

Pixel modes resolutions are 4:3 aspect ratio, from 4×3 all the way to 1024×768.
The resolution is calculated based on the setting as follows: 
4 × (setting + 1) : 3 × (setting + 1)

[b]Settings:[/b]
0 Change mode
1 Set data offset
2 Set resolution 

[large]ASCII fonts[/large]
These are the ASCII fonts:

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

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

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

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



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

$53269020658041* The screen



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

$42610024611500* Circuits



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

$69772243733094*
ASCII is a mapping between 7 bit numbers and characters (in this game the screen uses extended ascii which is 8 bits). 

[b]Code  Value  Description[/b]
  0    NUL    
  1    SOH    Start of header
  2    STX    Start of text
  3    ETX    End of text
  4    EOT    End of transmission
  5    ENQ    Enquiry
  6    ACK    Acknowledgment
  7    BEL    Bell
  8    BS     Backspace
  9    HT     Horizontal tab
 10    LF     Line feed
 11    VT     Vertical tab
 12    FF     Form feed
 13    CR     Carriage return
 14    SO     Shift out
 15    SI     Shift in
 16    DLE    Data link escape
 17    DC1    Device control 1 (XON)
 18    DC2    Device control 2
 19    DC3    Device control 3 (XOFF)
 20    DC4    Device control 4
 21    NAK    Negative acknowledgement
 22    SYN    Synchronous idle
 23    ETB    End of transmission block
 24    CAN    Cancel
 25    EM     End of medium
 26    SUB    Substitute
 27    ESC    Escape
 28    FS     File separator
 29    GS     Group separator
 30    RS     Request to send/record separator
 31    US     Unit separator
 32    SP     Space
 33    !      Exclamation mark
 34    "      Double quote
 35    #      Number sign
 36    $      Dollar sign
 37    %      Percent
 38    &      Ampersand
 39    '      Single quote
 40    (      Left/opening parenthesis
 41    )      Right/closing parenthesis
 42    *      Asterisk
 43    +      Plus
 44    ,      Comma
 45    -      Minus or dash
 46    .      Dot
 47    /      Forward slash
 48    0       
 49    1       
 50    2       
 51    3       
 52    4       
 53    5       
 54    6       
 55    7       
 56    8       
 57    9       
 58    :      Colon
 59    ;      Semi-colon
 60    <      Less than
 61    =      Equal sign
 62    >      Greater than
 63    ?      Question mark
 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    \[      Left/opening bracket
 92    \\      Back slash
 93    ]      Right/closing bracket
 94    ^      Caret/circumflex
 95    _      Underscore
 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    {      Left/opening brace
124    |      Vertical bar
125    }      Right/closing brace
126    ~      Tilde
127    DEL    Delete



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

$75719044675256* ASCII encoding



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

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

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

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

To represent 6 we can simply add 4 and 2:

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

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



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

$73447955210779* Binary



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

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

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



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

$68430971305988* Bytes



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

$13079267765950*
The truth tables of the four fundamental gates are symmetrical. You can convert between them by [color=#6e9759][b]inverting the input[/b][/color] (vertical arrows) or [color=#595f99][b]inverting the output[/b][/color] (horizontal arrows) as indicated by the graphic below.

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

Notes
1. You can get from any basic gate to any other, at most you have to NOT both inputs and output.
2. You can go between OR/NOR by inverting output, the same with AND/NAND. In fact NOR means NOT OR and NAND means NOT AND. Notice the component shape of OR/NOR are identical except for the little dot at the tip which means NOT. The same is true for AND/NAND.
3. Negating the output flips all the bits in the last row of the truth table. Negating the inputs mirrors the last row of the truth table around the center.



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

$66359790889628* De Morgan's laws



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

$78199387512682*
Conventionally, we display data in increasing memory addresses left to right. This ensures ASCII text also appears left to right when storing characters in increasing order.


[box]          Memory (hex) |   ASCII
Address: 0  1  2  3  4 | 0 1 2 3 4
Data:   [color=#ff6680]48[/color] [color=#ffe666]65[/color] [color=#66ff99]6C[/color] [color=#66ccff]6C[/color] [color=#9966ff]6F[/color] | [color=#ff6680]H[/color] [color=#ffe666]e[/color] [color=#66ff99]l[/color] [color=#66ccff]l[/color] [color=#9966ff]o[/color]
[/color][/box]

Further, the convention for writing numbers is that the most significant digits are on the left, such that thirteen is written [color=#ff6680]13[/color] instead of [color=#ff6680]31[/color].

Given this, the obvious way to represent a multi byte number such as 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] in memory is:

[box]          Memory (hex)
Address:   0  1  2  3
Data:     [color=#66ccff]12[/color] [color=#66ff99]34[/color] [color=#ffe666]56[/color] [color=#ff6680]78[/color][/box]

This is called [b]Big Endian[/b], because bigger (more significant) digits are stored at lower address. 

However, having numbers grow in the opposite direction of text is awkward algorithmically speaking. Some applications, like cryptography, needs unbounded numbers (BigInt), and to achieve this you need to be able to extend the number of digits or remove trailing zeroes. It is natural to order the digits such that you can grow the number without having to update the pointer that points to the number. You could of course decide that growing means going in the opposite direction, in which case you will have the same issue when appending to text (or implement two kinds of growing arrays). 

There are other aspects of storing numbers least significant bits first that turn out to be beneficial. For example it is much more common to only need the lower bits (down casting) of a number than only needing the high bits. Storing numbers least significant digit first again means that this can be done without changing the pointer.

The computationally natural convention of storing least significant digits first is called [b]Little Endian[/b]. Unfortunately viewing little endian is generally made even more confusing because values are grouped by bytes, which are each displayed in the conventional direction. Therefore 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] becomes:

[box]          Memory (hex)
Address:   0  1  2  3
Data:     [color=#ff6680]78[/color] [color=#ffe666]56[/color] [color=#66ff99]34[/color] [color=#66ccff]12[/color][/box]

Had the convention been to write numbers and text such that they grow in the same direction, there wouldn't be a need for this manual page.

Today modern CPUs all use little endian and it is has generally become the standard, with the notable exception of TCP/IP which uses big endian.



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

$25715726162519* Endianness



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

$22037524510182*

The way this game represents negative is called "two's complement". It is the standard way to represent negative numbers in modern computers. Some key insights for understanding two's compliment:
 1: To go between the negative and positive, you can flip all the bits and add[nbsp]1.
 2: If the highest bit is [T], the value is always negative.
 3: Adders work in both signed and unsigned mode.
 4: There is only 1 way to write each number.

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

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



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

$64907157003500* Negative numbers



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

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

[center]
Input 0 [F][T][F][T]
Input 1 [F][F][T][T]
Output  [T][T][T][F]
[/center]

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



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

$39788153942181* Truth tables



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

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

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

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



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

$88124920557040* Turing complete



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

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

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



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

$24291443495513* Universal gates



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

$42755701050268* Computer concepts



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

$62210202128540* Notice how the input doesn't matter?



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

$33906573915218* Pick any gate that outputs [T] when its inputs are not connected to anything



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

$18258110894478* This level unlocks your first manual page. This one is important, make sure you pay attention to it.

$61066799501731* Always On

$85978749941194* Create a circuit that is always [T].



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

$68158507707802* The AND gate can be interpreted as a NOT-NOT-AND gate, or a NOT-NAND gate



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

$18221128000007*
Create the circuit that matches the table.
[tip]Most levels have a hint button (the lightbulb) you can click if you are stuck.[/tip]

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

$70892117360845* AND Gate



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

$34539182309616* A bigger AND is but multiple ANDs in succession



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

$28751026881977* Create an AND gate with 3 inputs.

$32912994842868* Bigger AND Gate



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

$10183449965120* To check if at least 2 inputs are [T], we can check them pairwise



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

$83867604619162* To check if both inputs in a pair are [T], we can AND them



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

$34521278233301* That, though, is left as an exercise to the player!

$43216513907358* This solution is by no means the most elegant or optimal



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

$43068867747292*
This level has 4 inputs.
Output [T] when 2 or more of them are [T].

[tip]Don't overthink this level.[/tip]

$81647833476822* Double Detection



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

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



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

$17226968214352* Punchcard programming is tedious. Lets try adding 5 to the input again like in the previous level, but this time using assembly programming instead.

$72990407719621* Assembly Programming

$73801373825270*
The point of an assembly language is to give human readable nicknames to the instructions that our machines execute. 

Conventionally, an instruction syntax will begin with an abbreviated word (called a "[color=#9966ff]mnemonic[/color]") that describes the instruction, followed by a list of [color=#66ccff]operands[/color] like so:
[highlight][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]r2[/color][/highlight]

Also by convention, the destination is on the left. So in the above example we move a value to r1 from r2. If you learn these conventions you will be able to read real life assembly languages.

Click "Edit" on the RAM component to open the assembly editor. From there, click the "spec.isa" tab in the upper left corner to get the full list of Overture instructions.



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

$36228934755685* Moves 15 to reg 0

$41299869859669* This is a comment

$73562005049347* Moves input to reg 2

$80524429403045* Click the spec.isa tab in the top left to see all instructions



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

$38629344681843* {input_value} + 5 is {expected_value}, not {actual_value}.

$47165251832545* {input_value} + 5 is {expected_value}, not Z.



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

$27941792707668* Add 5 to the input using assembly programming



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

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



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

$12002017150690* Click on the "Edit" button on the "Program" component to start punchcard programming your computer. Your computer should read an input, add 5 to it and output it again.

$23659479615536* Now that you have built your first computer it is time to learn how to program it.

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

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

$47348572622406* Punchcard Programming



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

$61846111928326* {input_value} + 5 is {expected_value}, not {actual_value}.

$81797824381193* {input_value} + 5 is {expected_value}, not Z.



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

$65391114076509* Add 5 to the input using binary programming



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

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

$37988524800638* Binary Racer

$78267067157141*
Toggle the bits in the level panel so they add up to the decimal number in the question.

You must beat level 3 to pass.



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

$16764912826624* Code Breaker

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

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



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

$32998192994042* The SUM requires the same reasoning from the "Odd Number of Signals" level

$90884846016283* The CARRY is [T] if and only if both inputs are [T]



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

$10776402819741* We measure the universe with numbers. So our machine must know how to count.

$19285770105090*
Treat the inputs as [b]0[/b] or [b]1[/b] depending if they are [F] or [T]. Add them together in binary, such that the result is either [b]0[/b] or [b]1[/b].

As with normal addition, if the result cannot be described with one digit, set the carry to [b]1[/b].

$64470174232265* Half Adder



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

$40415302067949* either the input 0 is [T] AND input 1 is [F] OR the input 0 is [F] AND input 1 is [T]

$61125857472821* The truth table tells us that the output is [T] if and only if



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

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



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

$38198768813364* Bit Inverter

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

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

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



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

$29875779381032* Value

$41975883966377* Current output

$42809920196772* Invert

$62797002040657* Desired output



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

$22413958203952* The truth table is just telling us to make an XOR gate

$46480779443140* Let's first pretend the component constraint does not exist



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

$45466715038362* Now we just need to eliminate the OR gate to stay within budget

$76027454955517* A switch is very similar to an AND gate so let's replace them



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

$16488212881433* Lower circuit

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

$47029050705615* Incorrect output

$52307576546100* Upper circuit/XOR

$62622482229413* Unlike an AND gate, when the 'Enable' pin is [F], the switch doesn't output [F], it outputs nothing at all.

$80836475394613* This allows their outputs to share wires without short-circuiting as long as at most 1 switch outputs something at any point



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

$12922292218235* Bit Switch

$25663924496537*

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

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

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

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

$77268807700313* Using 2 NOT gates and 2 Switches, build an XOR gate.

$88100823584262*
If components output different values on the same wire, you get a short circuit error.

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

However, some components have grey output pins, these are not outputting at all when the component is not enabled. This is the case for the Bit Switch component.

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

When the bottom pin is [F], the output is disabled. In this case, more than 1 output can connect to the same wire without causing error.

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

Practically speaking, it only makes sense to connect multiple outputs to the same wire if they are switches. Components need to "take turns" to output for it to be useful.



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

$37690209655811* You only need 8 full adders



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

$49335074955899* Adding on a bit level, we can simply use the Full Adder component

$56143546486508* Similar to other byte components, we first break down the bytes to their bits



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

$57534334907443* Add another 7 Full Adder components, one for each bit



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

$36646953278480* Carry-out of the last bit is the carry-in of the next

$69804974830322* Connect the carry-in and carry-out of the level to complete the circuit



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

$45190053242926* Carry in

$76244671092409* Carry out



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

$31490345812891* Add the two input bytes. Each output bit in the output should be a result of the addition of the corresponding bits from the inputs, and potentially a carry.

$45061087867940*
If the result does not fit in 8 bits, turn the output carry [T] (you can think of it as the 9th bit)

Finally, there is an input carry as well. This is useful for chaining together byte adders to add larger numbers. You can think of this carry as adding either 0 [F] or 1 [T].

$53076615315445* Also, this level has a lot of tests. Right click on the run button to increase the testing speed.

$62793095496458* Adding Bytes



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

$51758065631068* [color=#E49F44][left]Carry out        Sum[/left][/color]



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

$86214455922761* First, let's recall what these shifts are: circuits of byte splitter and maker



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

$11228896363898* i.e, shift of 3 is equivalent to shift of 1 + shift of 2

$11260842500047* We can implement a version of this shift called barrel shifter

$55175982917102* To that end, we note the additive property of shift,



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

$87506885530483* We then shift Input 0 by 1, 2, 4 depending on the [T] bits of Input 1



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

$53539145017840* ASR

$79125097012724*
The shift you built in the last level is known as [b]logical[/b] shift, logically shifting right by 1 is the same as dividing by 2 for unsigned numbers. For signed numbers, if the top bit of the value is [T], we fill the empty bits with [T] instead of [F]. This is called [b]arithmetic shift right[/b], often written as [b]asr[/b] in assembly.

[color=#e49f44]-106 asr 3[/color]
  [T] [F] [F] [T] [F] [T] [T] [F]
Results in:
 |[T] [T] [T]|[T] [F] [F] [T] [F]
^             
And here we insert [T] instead of [F]



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

$67841603404086* The binary representation of 164 is [T][F][T][F] [F][T][F][F]



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

$55176290924321* Create a circuit that always outputs the number 164.

$55259569122850* Byte Constant



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

$90758832592628* Create a circuit that always outputs the number 164.



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

$15513439442399* Divide the two inputs and output the result. Note, this level is optional, because it is very hard. If the second input (the divisor) is 0, the result should be 0.

$55155519654685* Divide



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

$10903561275291* {a} / {b} is {result}



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

$86943286745277* Divide the two numbers.



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

$13186595896308* An XOR of 2 equal numbers is very beautiful



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

$85034261531833* An XOR of 2 numbers is 0 if and only if they are equal

$88637818475024* Then we check a byte is 0 by checking all its bits are [F]



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

$16679981460998* Output [T] when both inputs are the same.

$44220989927736* Equality



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

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

$32432328437519* The value {a} is not equal to {b}

$51276780017906* The value {a} is equal to {b}



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

$41065065514143* Make a circuit that outputs [T], when both inputs are the same.



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

$14667194911431* Only, the last bit is considered separately for signed numbers, here it has the opposite effect

$19896249626650* If only one number has [T] for sign bit, that number is guaranteed to be lower

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



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

$82755888644217* If the sign bits of the inputs differ, we can just compare them



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

$52492743864774* Otherwise, we can compare 2 7-bit unsigned numbers



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

$12621415211383* Create a circuit that outputs [T] when the first input is less than the second. Interpret the bytes as being [color=#dd6576]signed[/color].

$57911276445846* Signed Less



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

$18672872329218* The value {a} is not less than {b}

$60636366241019* The value {a} is less than {b}

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



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

$33907970782848* Make a circuit that outputs [T], when the first input is less than the second one.



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

$18968293717104* One way is comparing digit by digit like we do for decimal numbers

$45223418140453* Like 09 < 21 because 0 < 2, so 1100 > 1001 because 11XX > 10XX



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

$23270172293605* so for each bit, use a chain of OR gates to check if any higher are [T]

$34091176621640* This can be done using a byte XOR (remember XOR turns [T] when the inputs are not the same)

$38704349429368* First determine which bits are different between the 2 bytes

$45560562333305* But we must only consider the highest different bit,

$72421677239233* We know the number that has the highest different bit [T] is the larger number



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

$37315430614523* 09 < 11 so 09 - 11 < 0; 1100 > 1001 so 1100 - 1001 > 0

$73589178770254* Another way is comparing the difference with 0



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

$15205448412655* i.e. Input 0 ADD (NEG Input 1)

$19139933016995* We don't have a subtraction component, only addition and negation

$56709208304109* So we transform, for example, 1100 - 1001 to 1100 + (-1001)



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

$21199347421587* To represent them in signed form, we must work with 9-bit bytes

$46518640933018* But we have 8-bit unsigned inputs



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

$11293872851403* We can make a 9-bit custom component

$17291563256662* Or we can break down NEG into NOT and ADD_1 to manipulate



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

$90593296729801* Simplify the circuit



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

$39605373706887* Unsigned Less

$68842379350661* Create a circuit that outputs [T] when the first input is less than the second. Interpret the bytes as being [color=#dd6576]unsigned[/color].



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

$50702714470018* The value {a} is not less than {b}

$54835419299907* The value {a} is less than {b}

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



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

$88632565567686* Make a circuit that outputs [T], when the first input is lower than the second one.



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

$75806240403820* First, let's recall what these shifts are: circuits of byte splitter and maker



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

$12195819154781* i.e, shift of 3 is equivalent to shift of 1 + shift of 2

$28136552692253* We can implement a version of this shift called barrel shifter

$88850298427736* To that end, we note the additive property of shift,



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

$22456794338741* We then shift Input 0 by 1, 2, 4 depending on the [T] bits of Input 1



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

$17566441654249* Shift



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

$26791208073532* The task in this level is to shift the first input to the right by the value given in the second input.

$36654581830314* LSR

$57629598331916*
To shift a value 1 right just means moving all the bits in a byte to the right by 1 position.

This operation is known as [b]logical shift right[/b] and in assembly it is often abbreviated as [b]lsr[/b].

For example [b]180 lsr 1[/b]
[left]
           [T][F][T][T][F][T][F][F] Shifts this by 1:
           [F][T][F][T][T][F][T][F]
[/left]
And [b]180 lsr 3[/b]
[left]
           [T][F][T][T][F][T][F][F] Shifts this by 3:
           [F][F][F][T][F][T][T][F]
[/left]

$83781539475221* In addition to giving you a shift right component, you also get a shift left component.



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

$84095392269624* Modulo

$87605997307596* Output the modulo of the two inputs. If the second input (the divisor) is 0, the result should be the same as the first input (the dividend).



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

$38641362389638* {a} mod {b} is {result}



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

$76653207214085* Returns the remainder after dividing the two inputs.



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

$37740515704094* This level is very similar to "Bit Switch"

$71057700033977* But with A in place of Input 0 and B in place of NOT Input 0



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

$63172000393911* Select



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

$44523532982427* When the bit selector input is [F], output Byte A, otherwise output Byte B.

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

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

$75861961518456* Multiplexer



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

$15140861344476* Select {select}



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

$28574225028041* Select A or B



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

$88766421259023* Byte NAND of 2 binary numbers is just the NAND gate applied bitwise between them



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

$11980470862173* Byte NAND

$52274910421610*
NAND each bit of the input bytes and output the result.

For example:
Input 0 [T][T][F][F][F][T][F][F]
Input 1 [F][F][F][F][T][T][F][F]
Output  [T][T][T][T][T][F][T][T]

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



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

$55051011788323* Byte NOT of a binary number is just the NOT gate applied bitwise to the binary number



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

$54090032127372* "NOT" each bit of the byte input.

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

$65498108564418* Byte NOT

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

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



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

$66692685876410* Byte XOR of 2 binary numbers is just the XOR gate applied bitwise between them



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

$41472172986798* Byte XOR

$70973830134418* Create a circuit that XORs two bytes bitwise.



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

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



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

$62779271315005* Create a circuit that XORs two bytes bitwise.



=== 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/circumference/meta.txt ===

$21808795465233* Circumference

$46884494321384*
In this level you are given a radius and you calculate the circumference.

This is the equation: 2×π×r

r is the input.
And you can approximate π as 3.

Send the answer to output when it has been calculated.



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

$18136442036625* What is 2π × {radius}?



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

$24129473753872* Read the input

$47357954866257* *Assuming π ≈ 3



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

$38150072401115*
To finish this level, read the input until you see the number 37. 

Then output a count of how many times you read the input.

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

He had a hard time programming with his flippers. 

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

$40525671378957*
The goal of this level is to teach you about jumps and labels. 

A jump is an instruction that overwrites the counter. 

Overwriting the counter means we "jump" to an instruction somewhere else in our program, instead of simply proceeding to the next.

$47703565240245* Conditional Jumps

$65712025748767*
If you use a fixed number as your jump destination, you will have to update it every time you add or remove code.

Instead you can use a feature called a [color=#66ccff]label[/color] to mark a location in the program that automatically updates when you change anything, like so:

[box][left]
[color=#66ccff]my_label[/color]:     [color=#aaaaaa]; This is a label[/color]
[color=#9966ff]imm[/color] [color=#66ccff]my_label[/color]  [color=#aaaaaa]; Load the offset of the label[/color]
[/left][/box]
  



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

$35642914965530* Jumps to byte 5 of the program

$50319416070023* Moves 5 to r0

$66946505646203* You can load its offset like this

$67381454058237* This is a label

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



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

$39953782121467* The last input was not 37!

$75138288162938* You read the input {read_count} times, not {output}.



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

$65261628219716* Edit the assembly on the RAM



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

$15352671410916* with 8 being the number of bits and log2 the position of the first [T] bit.

$75683304945175* Except for when Input is 0, this is the same as finding 8 - 1 - log2(Input),

$83745112465243* Finding log2 of binary numbers is very well-trodden ground in computer science



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

$40521556880682* One of the methods is to divide the problem:

$46035077948196* What is log2 of a 2-bit non-zero binary number (i.e. 1, 2, or 3)?



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

$32041142528569* Subtracting from (2 - 1) = 1, there are 1 and 0 leading zero, respectively

$88044062357651* Then how about 4-bit number?

$88309764896321* If the number is less than 2, log2 is 0; otherwise, it is 1



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

$24472621996685* If the number is less than 4, we can reduce the problem to 2-bit

$42632561737634* Either way, the problem goes from 4 bits to 2 bits

$87709120049440* If not, then the first [T] bit is somewhere in the highest 2 bits



=== campaign/count_leading_zeroes/hint_4.txt ===

$12591714876491* The only thing missing is the case when Input is 0

$82513296271559* Apply the same steps to reduce the problem from 8 bits to 4 bits



=== campaign/count_leading_zeroes/hint_solution.txt ===

$27675083487752* This solution is by no means the most elegant or optimal

$62535209440079* That, though, is left as an exercise to the player!

$81301599100070* The simplest way is to single out the 0 case



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

$18890527031365* Count leading zeroes

$30557055303267*
Create a circuit that starts from the most significant bit and counts how many in a row are [F]

The answer for this, for example, is 3, since it has 3 leading [F] bits:
[F][F][F] [T][F][T][F][T]



=== campaign/count_leading_zeroes/test.si ===

$10248302990519* There are {count} leading zeroes in {input_value} ({binary_value})

$46565705342966* There is 1 leading zero in {input_value} ({binary_value})



=== campaign/count_leading_zeroes/ui.txt ===

$85604588212035* Count leading zeroes



=== campaign/counter/hint_0.txt ===

$74290091312759* This level is just a tweak away from saving with overwrite capability



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

$22938387275450* Just add 1 to loop wire of the Delay Line

$81327009436542* But using an Add component here is an overkill!



=== campaign/counter/label.txt ===

$24866509692444* Set



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

$42949183679479*
Build a counter that will increase by 1 each cycle.

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

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

The bit input should toggle between counting and overwriting with the value of the byte.

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

$68850421394935* Counter



=== campaign/counter/test.si ===

$27837193789838* Output should be {memory}.

$30050502504940* Add 1

$69821998974515* Overwrite with {num}



=== campaign/counter/ui.txt ===

$16305942415014* Action

$57018164959250* Next desired output



=== campaign/counting_signals/hint_0.txt ===

$20653200546136* The circuitry for the 1's bit is the same as what you did in the level "Odd Number of Signals"

$39788606928520* The circuitry for the 2's bit is what you did in "Double Detection", except when all 4 are on



=== campaign/counting_signals/hint_1.txt ===

$79041418443903* The output 0 is the same as the "Odd Number of Signals" level



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

$90442785399123* The output 2 is [T] if and only if all signals are [T]



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

$12139411441713* The output 1 is [T] if and only if at least 2, but not all 4, signals are [T]

$83417330967064* The 'at least 2' part, we have already done in the "Double Detection" level



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

$14499217305520* Counting Signals

$83123268362253*
The output component of this level is a binary counter where the three pins correspond to 1, 2 and 4.
Use the binary counter to display the number of signals.

[tip]The solution for this level is not very neat and requires more components.[/tip]



=== campaign/decoder_1/meta.txt ===

$55345008240214* 1 Bit Decoder

$64947954189801* Create a component that can switch a signal between 2 pins.



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

$40303102766749* Output 0

$56552908891774* Output 1



=== campaign/decoder_2/meta.txt ===

$44276233109848* 2 Bit Decoder

$46223188985873* With 2 bits of input there are 4 combinations. Make a circuit that selects 1 output for each of the 4 combinations. No more or less than 1 bit should be [T] at a time.



=== campaign/decoder_3/label.txt ===

$44918705544255* Disable



=== campaign/decoder_3/meta.txt ===

$28695849165746* With 3 bits of input there are 8 combinations. Make a circuit that selects 1 output for each of the 8 combinations. Additionally, there is a disable input bit. When it is [T] all the outputs should be [F].

$43603044118584* 3 Bit Decoder



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

$10870388349665* Expected output {cycle} to be [T] and other outputs to be [F]

$18073111523064* Expected all outputs to be [F] since the disable bit is [T]



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

$20191487800946* Desired bit

$23128720321555* Disabled

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



=== campaign/dependency/hint_0.txt ===

$21613887420121* A simple circuit where the input depends on its own output is a looped NOT gate

$57091568089512* Note the red erroneous wire

$64834808154176* This is an error in other levels, but the goal of this one



=== campaign/dependency/hint_1.txt ===

$13967626449720* Some even deceptive like this example, which may make sense in pure logic form

$71118235828147* The circular dependency can be complex, involving many different wires and components



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

$24156270270079*
Create a "circular dependency". This is a circuit where the input of a component relies on its own output. In a circular dependency situation, it is not possible to determine the output of a component, because you would first need to determine the input, which relies on the output and so on (hence the "circular").

This state is normally not allowed in other levels, but in this level the goal is to create it, so you understand what it is before going forward.

$25862237357880* Circular Dependency

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

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



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

$28070798445412* Construct a circuit that outputs the same as the input, just delayed by 2 cycles.

$66914768639545* This level introduces the Delay Line component. It takes its input and outputs it 1 cycle later.

$81657957055974* Delayed Lines



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

$13944257184132* In this level, a byte, a group of 8 bits, is provided, so we must split and merge them

$16215081868720* Up until this point, we have worked only with bit, a signal of [T] or [F]



=== campaign/double_number/hint_1.txt ===

$29000872588470* To double a number in binary format is to shift the bit position by one



=== campaign/double_number/meta.txt ===

$46697878992908* Double the Number

$78449227663032*
This level introduces byte values, which are shown as numbers between 0 and 255. Bytes are made of 8 bits, each bit is being a binary digit of the number. You are given two new components, one of which takes a byte and splits it into bits, while the other does the reverse.

Using those components, figure out how to double the input number (up to 127).



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

$24718289227251*
Welcome to the foundry, the circuits you create in here will be usable as components in other levels.
The circuitry you create defines the behavior of the component and the layout defines its shape.

$62612312608874* Since this level is a tool and not a challenge, you can go to the level map and continue on when you want.

$72171231322685* The Foundry

$88436914545275* Components can be added, renamed or deleted using the schematics menu.



=== campaign/full_adder/hint_0.txt ===

$50970897346580* The SUM requires the same reasoning from the "Odd Number of Signals" level



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

$54848313056941* The CARRY is [T] if and only if at least 2 inputs are [T]



=== campaign/full_adder/hint_solution.txt ===

$13880107359455* That, though, is left as an exercise to the player!

$18497022543669* This solution is by no means the most elegant or optimal



=== campaign/full_adder/label.txt ===

$12555311310864* Input 0

$13755587162128* Input 2

$34717193596171* Carry

$41149959264274* Input 1

$50183740481245* Sum



=== campaign/full_adder/meta.txt ===

$34381936755276*
In the previous level we added together 2 inputs, this time we add 3. Once again, add the inputs together in binary, such that the result is either [b]0[/b] or [b]1[/b].

As with normal addition, if the result cannot be described with one digit, set the carry to [b]1[/b].

$42735906141201* Full Adder



=== campaign/full_adder/ui.txt ===

$40317306745068* Desired Sum

$49855734765642* Desired Carry

$51965136043073* Current Carry

$84617036256734* Current Sum



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

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

$45399195121692* Hex Racer

$65517909958697*
When dealing with many bits, binary can become hard to read. Hexadecimal (base 16) represents each combination of 4 bits as its own character:

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]

As an example where hexadecimal is clearer, lets compare the representation of the largest 16 bit number:
[left]
              Binary:      1111111111111111
              Decimal:     65535
              Hexadecimal: FFFF
[/left]
It is not easy to tell if the binary is missing a digit or if the decimal number is correct, the hexadecimal on the other hand is immediately clear (once you get used to the representation at least).

$87098190175913*
Toggle the bits in the level panel so they add up to the hexadecimal number in the question.

You must beat level 3 to pass.



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

$26182817405385*
Congratulations, you have been abducted.

We are testing you on our spaceship.

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

$44716420394020* Humble Beginnings

$76679675871478* This first test checks your understanding of circuits. Here you have an input and an output with a wire in between. Turn on the input in the left hand menu to complete it.



=== campaign/logic_gate_racer/meta.txt ===

$35186537961257* This level is here to make sure you master Boolean logic before you proceed. Being good at this will help you a lot in the future.

$39180730338379* You will be tested on a few different circuits here. When you hit the "Run" button, your circuit will be tested and you will get a green mark if it was correct or a red mark otherwise. The level is complete when 4 of the 5 marks in the history box below are green.

$39721874026332* Great job. Now that you have a firm grasp of Boolean logic, it is time to work towards building your first computer. But first you must learn about memory and binary arithmetic. The path to mastery is as long as it is satisfying.

$57679157572023* Logic Exam



=== campaign/logic_gate_racer/ui.txt ===

$32183772878666* History



=== 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]

$60076150664554* Always following the left (or right) hand side of the maze will make sure you eventually reach the exit

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

$66501964970865* The pseudo code for such an algorithm looks like this:



=== campaign/maze/meta.txt ===

$19088384441761*
Read the input to figure out what the robot sees in front of him. It is always one of these:
0 Nothing
1 Wall

$56722492138232* Great job. You finished the maze and clearly master Overture assembly now. But Overture is too basic, it is good for learning, but is missing many features. Your next project will be to build towards Symphony, a more powerful computer which has RAM, a screen, a keyboard and lets you reuse code through functions. On the way there you will have to build some new components, learn about the stack and other things.

$84960209408475*
In this level you control a robot. Write an algorithm that guides him from the start to the door at the end of the maze.

These are the three commands you can output:
0 Turn left
1 Move forward
2 Turn right

You can also use the arrow keys to play around with the robot manually.

$90660848232877* The Maze



=== campaign/mod_4/hint_0.txt ===

$23027113131109* represents that number modulo 2 (even or odd), the lowest 3 bits modulo 8 and so on

$35037773638556* Likewise, in decimal 4321 modulo 100 is also simple

$40190253854900* In binary, taking modulo 4 of a number is the same as only using the two lower bits

$44666331884152* This is because the higher bits represent 4, 8, 16 etc, and they all divide 4 with no remainder

$47075416850998* This is true in general for modulo a power of 2, the lowest bit of a number

$79521133202800* (answer is 21, the higher digits are disregarded, because 100 is a power of 10)

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



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

$46388374967041*
In this level you are given a number as input and you should return that number modulo 4 as a result.

The challenge is that you only have 8 cycles to output the desired result.

Note: You don't need to change your hardware, you just have to figure out the trick to do modulo 4 quickly.

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

It doesn't really surprise me.

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

$78836302049950* Mod 4



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

$13853243145042* You must output the result before cycle 8!

$59240995307159* Read the input first.

$60992625993288* {inp} mod 4 is {result}.



=== campaign/multiply/meta.txt ===

$44500958231665* Multiply two numbers. If the result doesn't fit in 8 bits, discard the bits that don't fit.

$54529139494347* Multiply



=== campaign/multiply/test.si ===

$13790051293386* {a} * {b} is {result}

$46804407616321* The lower byte of {a} * {b} is {result}

$83214947196979* Multiply two numbers



=== campaign/multiply/ui.txt ===

$77112891598455* Multiply two numbers



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

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

$39082333495604* NAND Gate

$50880631203389* Correct! You have unlocked the NAND gate. Out of this fundamental building block, you will construct everything else in your computer.

$65167079914703* The first section is about "Boolean logic". Boolean logic describes the simplest forms of calculation computers can do. In fact these calculations are what every other calculation in the computer is made out of.

$68865507501612* This circuit contains a "NAND gate" that I want you to examine. I want you to document its behavior by filling in the "truth table" in the panel you see below. Only the two input rows of the truth table are filled out. Your task is to experiment with the inputs to the circuit, observe what the NAND gate does and fill the last row of the truth table.



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

$16731935541997*
This level introduces "two's complement", the most common representation for negative numbers.
  
Here the highest digit is negated. For bytes this means the 8th digit changes its value from 128 to -128.

You must beat level 2 to pass.

$20753698232132* Negative Numbers

$87951492143019* To know the difference between things, you need subtraction. To get subtraction, first you need negative numbers.



=== 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/nor_gate/hint_0.txt ===

$18962231551900* if and only if both the input 0 AND input 1 are [F]

$68908249643417* The truth table tells us that the NOR gate is [T]



=== campaign/nor_gate/hint_1.txt ===

$14349743750598* The AND gate can be interpreted as a NOT-NOT-AND gate, or a NOT-NAND gate



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

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

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

$56653221050913* Create the circuit that matches the table.

$72918877035793* NOR Gate



=== campaign/not_gate/hint_0.txt ===

$26513163439009* The only component we have is the NAND gate



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

$20946507323050* When the inputs are both [T], the output is [F]

$88952480145102* When the inputs are both [F], the output is [T]



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

$16394937100308* NOT Gate

$56423993638708* In the last level you made the truth table that described the circuit. In this level you build the circuit that matches truth table.

$64052600264884*
Using NAND gates, build the NOT gate

Using: [b]NAND gate[/b]
Input 0: [F][T][F][T]
Input 1: [F][F][T][T]
Output:  [T][T][T][F]

Build: [b]NOT gate[/b]
Input:   [T][F]
Output:  [F][T]

$80163590000700* Now that you unlocked the NAND gate, it is time for you to build a circuit yourself.



=== campaign/odd_number_of_signals/hint_0.txt ===

$17243045715726* You can figure out if 2 inputs have an odd number of [T] with just 1 component



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

$39747324204871* But what if, instead of off/on, we imagine them as even/odd?

$80670337048058* Up until this point, [F] has been treated as off, and [T] as on



=== campaign/odd_number_of_signals/hint_2.txt ===

$28104365880572* even number + even number = even number

$49444546097133* odd number + odd number = even number

$57603105454008* Now do we have a component that mimics this behavior?

$59534613718377* odd number + even number = odd number



=== campaign/odd_number_of_signals/hint_3.txt ===

$47175212977659* An XOR gate is the one to look to



=== campaign/odd_number_of_signals/meta.txt ===

$44190469254011* Odd Number of Signals

$63242509760527* Using a maximum of 3 components, output [T] only when an odd number of inputs are [T]



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

$36609687959808* {count} of 3

$40553112323959* You may not use more than 3 components in this level



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

$74552564780850* Components spent



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

$69947751578736* The input is merely a distraction

$75667038547709* The information comes from the cycle count, this is where the Delay Line shines



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

$14188568517859* The Delay Line can be looped back into itself

$88356074900046* to create signal based on the cycle count



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

$17699211754487* In a previous level you learned how we don't allow circular dependencies. Now you must learn the one exception.

$54648226811178* Odd cycles

$60625429879527*
Orange pins never affect the output in the same cycle. They therefore never cause circular dependencies.

  [image="delay_line.png"]

$75292456030647*
The delay line is allowed to depend on its own output. This is because its input does not influence the rest of the circuit until next cycle.

[image="delay_line.png"]

$85913836277587* Output [F] on the even cycles and [T] on the odd cycles.



=== campaign/one_hot_encoding/hint_0.txt ===

$28460985244857* One of the components you need is a shift



=== campaign/one_hot_encoding/hint_1.txt ===

$49063245216494* This level makes use of the previously implemented LSL (Left Shift) component



=== campaign/one_hot_encoding/meta.txt ===

$12296593054599* One hot encoding

$17817215316423*
The input decides which output should be turned [T]. So if the input is 7, send [T] to the 7th output and [F] to all the others.

Do not use more than 3 components. Also, you may not use any of the decoders you built before.



=== campaign/one_hot_encoding/test.si ===

$60812617177494* Do not use more than 3 components.

$74562193652628* The output on pin {pin} is wrong.



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

$29061908449874* if and only if NOT both inputs are [F]

$49190016957852* The truth table tells us that the OR gate is [T]



=== campaign/or_gate/meta.txt ===

$46797361496226*
Create the circuit that matches the table.
[tip]Double click on a component to move it together with connected wires.[/tip]
  

$81822607191994* OR Gate



=== campaign/or_gate_3/hint_0.txt ===

$67313804184537* A bigger OR is but multiple ORs in succession



=== campaign/or_gate_3/meta.txt ===

$29275887429601* Create an OR gate with 3 inputs.

$68089739910654* Bigger OR Gate



=== campaign/or_gate_3/ui.txt ===

$15378963142694* Input 2



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

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



=== campaign/overture_1_registers/hint_0.txt ===

$25938996008186* with the source in place of Inputs and destination Outputs

$87908319845833* This level is similar to "The Bus"



=== campaign/overture_1_registers/hint_1.txt ===

$66937784075495* We then use decoders find the enabled source & destination



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

$13757092116124*
[color=#ff6680]Source[/color] and [color=#e49f44]destination[/color] can be 1 of 6 registers, we will name them REG 0 to REG 5 respectively.

Additionally, this level has a dedicated input component, which can be the [color=#ff6680]source[/color] and an output component, which can be the [color=#e49f44]destination[/color].

$36376879506769* It is finally time to build your first computer. I will teach you how to build the [color=#e49f44]Overture[/color] architecture, an actual Turing complete machine, a true computer in every way.

$61875924861326*
In this level you need to create a circuit which can move a value to a [color=#e49f44]destination[/color] from a [color=#ff6680]source[/color].

The instruction byte in this level determines the [color=#e49f44]destination[/color] and the [color=#ff6680]source[/color].

Bits 0, 1 and 2 give the [color=#ff6680]source[/color]. Bits 3, 4 and 5 give the [color=#e49f44]destination[/color].

$79626649565563* Registers

$87179643828952*
These are the bit patterns for each [color=#ff6680]source[/color] and [color=#e49f44]destination[/color].

[color=#ff6680]Source[/color]:
[left]
                      [F] [F] [F]  REG 0
                      [F] [F] [T]  REG 1
                      [F] [T] [F]  REG 2
                      [F] [T] [T]  REG 3
                      [T] [F] [F]  REG 4
                      [T] [F] [T]  REG 5
                      [T] [T] [F]  INPUT
                      [T] [T] [T]  UNUSED
[/left]

[color=#e49f44]Destination[/color]:
[left]
                      [F] [F] [F]  REG 0
                      [F] [F] [T]  REG 1
                      [F] [T] [F]  REG 2
                      [F] [T] [T]  REG 3
                      [T] [F] [F]  REG 4
                      [T] [F] [T]  REG 5
                      [T] [T] [F]  OUTPUT
                      [T] [T] [T]  UNUSED
[/left]



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

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

$51132330915663* Output not enabled.

$75546240775660* Expected output: {value}.

$85392755740261* Output should not be enabled.



=== campaign/overture_1_registers/ui.txt ===

$77115196290575* Build the register circuit



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

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



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

$17602708328746*
Time to merge in the "Arithmetic Logic Unit" circuit you made previously with the register circuit. The ALU circuit was saved in the foundry and can now be added as a component. If you forgot which pin does what, check the circuit in the foundry.

Use the decoder you built to figure out if we should move between registers or do ALU calculations. Here are the 4 different modes again:
[left]
                      [F][F] Immediate
                      [F][T] ALU
                      [T][F] Move
                      [T][T] Condition
[/left]

For this level you only have to worry about the move and ALU mode. When in ALU mode, take [color=#e49f44]REG 1[/color] and [color=#e49f44]REG 2[/color] as inputs, and store the result in [color=#e49f44]REG 3[/color].

[tip]Don't forget the 3 bit decoder component has a disable bit.[/tip]

$76398546711745* ALU



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

$27417572090527* Output not enabled.

$45837083894306* Expected output: {value}.

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

$84026509534190* Output should not be enabled.



=== campaign/overture_2_alu/ui.txt ===

$49706182840588* Integrate the ALU into the circuit



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

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



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

$23614311904581* Immediate Values

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

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



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

$17793323757435* Expected output: {value}.

$63497936956369* Output should not be enabled.

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

$82564442776805* Output not enabled.



=== campaign/overture_3_immediates/ui.txt ===

$57764930098721* Add immediates to the circuit



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

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



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

$10102035559374* Program

$58149108600515* The instruction input component has been removed. It has been replaced by a RAM component containing the program. The RAM has a "load port" attached to it. When enable pin on the load port is enabled, it will output a value from the RAM, based on the given address. Every cycle, use the counter to load the next instruction from the program's memory.



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

$19443898128380* Output should not be enabled.

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

$50052313044113* Output not enabled.

$73023200204536* Counter should have value {expected_value}.

$88140381331491* Expected output: {value}.



=== campaign/overture_4_program/ui.txt ===

$62678678871254* Add a program to the circuit



=== campaign/overture_5_conditionals/label.txt ===

$37075142107851* Reg 2

$38743609381557* Reg 1

$40362507068221* Reg 4

$57061942907076* Reg 5

$79357977314471* Reg 3

$82470056393191* Reg 0



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

$27747401844990* You did it! I thought you were just this odd looking hairless ape creature, but you actually built a real computer! Amazing.

$59169726539090* Turing Complete

$77166984247940* Until this point all possible programs have been confined to running in order byte by byte.

$85320707451673* Before, only code could influence memory, now memory must influence code. With the addition of conditional logic, our computer can run any algorithm, and calculate anything calculable. Like all non-theoretical computers, this machine will only be limited by having finite memory.

$89085328104477*
The final thing we need to add is a mechanism for changing the program counter through instructions when certain conditions are met.

When the two largest bits are [T][T], we are in condition mode. In condition mode, the value in REG 3 is compared against the conditions defined by the lowest 3 bits in the instruction. If the condition is true, we overwrite the counter to the value in REG 0.
Conditionally changing the counter means we can skip instructions based on conditions or have instructions run in a loop.

Conditions:[left]
                    [F][F][F] Never
                    [F][F][T] Always
                    [F][T][F] If [color=#e49f44]REG 3[/color] = 0
                    [F][T][T] If [color=#e49f44]REG 3[/color] ≠ 0
                    [T][F][F] If [color=#e49f44]REG 3[/color] < 0
                    [T][F][T] If [color=#e49f44]REG 3[/color] ≥ 0
                    [T][T][F] If [color=#e49f44]REG 3[/color] ≤ 0
                    [T][T][T] If [color=#e49f44]REG 3[/color] > 0
[/left]
These conditions correspond to the condition component that was saved in the foundry.



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

$17521915837347* Output should not be enabled.

$33411257451562* Expected output: {value}.

$36308361121667* Output not enabled.



=== campaign/overture_5_conditionals/ui.txt ===

$65145204616501* Add conditions to the circuit



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

$18505654344513* Jump to r0.

$21095867785396* AND r1 and r2 and store the result in r3.

$24147817394058* Jump to r0 if r3 is less than 0.

$26704206992933* NAND r1 and r2 and store the result in r3.

$33850592701591* SUB r1 and r2 and store the result in r3.

$42577908074742* Move %a to r0.

$43876958520450* Jump to r0 if r3 is not 0.

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

$46599288949396* Jump to r0 if r3 is 0.

$48758564562305* Jump to r0 if r3 is less or equal to 0.

$58823897430160* OR r1 and r2 and store the result in r3.

$64808551937719* Jump to r0 if r3 is greater or equal to 0.

$71072332861445* Do nothing.

$75067212691206* NOR r1 and r2 and store the result in r3.

$75524550463342* ADD r1 and r2 and store the result in r3.

$88048573834702* Jump to r0 if r3 is greater than 0.



=== 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/overture_alu_1/hint_0.txt ===

$17808301775724* This level is similar to "Multiplexer"

$69085851994491* with the results of NAND, OR, AND and NOR replace Input A/B



=== campaign/overture_alu_1/hint_solution.txt ===

$76898193108851* The enabled switch can then be found using a decoder



=== campaign/overture_alu_1/meta.txt ===

$16562043259074* Arithmetic Logic Unit (ALU) 1

$31234606133949*
Create a device that can OR, NAND, NOR or AND two byte inputs. The third input will be the instruction. An instruction is just what we call the number that determines what to compute.

Instructions:

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



=== campaign/overture_alu_2/hint_solution.txt ===

$30599543511275* An extension using 3-bit decoder instead of 2-bit

$61118397217284* A SUB B is A ADD (NEG B)



=== campaign/overture_alu_2/meta.txt ===

$20519420764551* Arithmetic Logic Unit (ALU) 2

$39134024311972*
Add addition and subtraction to your circuit.

Instructions:

[color=#87a8c8]0 NAND
1 OR
2 AND
3 NOR
4 ADD
5 SUB[/color]



=== campaign/overture_alu_2/ui.txt ===

$53936374688885* Opcode



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

$30858693828450* So let's hook those up together with the bus

$41615813866999* The Never and Always are the easier parts

$73479968135998* Now, to check value = 0, we need to check all bits are [F]



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

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

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



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

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

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



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

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

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

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



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

$71466914240996*
This level has a value input and a 3-bit condition input.

The 3 bits select the condition as shown below. Check the value against the selected condition and output [T] if it is satisfied and [F] otherwise.

[left]
             Bit code:     Turn [T] when:
              [F][F][F]       Never
              [F][F][T]       Always
              [F][T][F]       If value = 0
              [F][T][T]       If value ≠ 0
              [T][F][F]       If value < 0
              [T][F][T]       If value ≥ 0
              [T][T][F]       If value ≤ 0
              [T][T][T]       If value > 0
[/left]

$83283206082997* Conditions



=== campaign/overture_conditions/test.si ===

$74974087807935* ALWAYS

$80507287196650* NEVER



=== campaign/overture_conditions/ui.txt ===

$11886599003881* value

$38979555213581* Description

$43384041502940* Value

$81487261104241* Condition



=== campaign/overture_decoder/label.txt ===

$15645900189277* Move

$60698949860454* ALU

$90597971391617* Immediate



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

$44644153822563* The circuit you built in the "Registers" level can copy values between registers, while the "Arithmetic Logic Unit" can do different operations on 2 inputs. But you need to be able to do both in the same circuit. To do this, build a "decoder", which will decide which mode our computer is in, based on the 2 bits we haven't used yet.

$62355105651643*
To distinguish between the instructions of 4 different kinds, the two highest bits will be used to determine which MODE we are in as follows:

[left]
                [F][F][Z][Z][Z][Z][Z][Z] Immediate
                [F][T][Z][Z][Z][Z][Z][Z] ALU
                [T][F][Z][Z][Z][Z][Z][Z] Move
                [T][T][Z][Z][Z][Z][Z][Z] Condition
[/left]
Here [Z] means any value.

Determine the MODE we are in from the input, then send [T] to the correct output.

$81732613304305* Instruction Decoder



=== campaign/overture_decoder/test.si ===

$23393810721136* ALU

$41856942338650* Condition

$67613074322431* Move

$71705253055197* Immediate



=== campaign/overture_decoder/ui.txt ===

$35299017249605* Desired mode

$55162862394836* Instruction



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

$46932595269557* Hub Preview



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

$78694087261378* Hub Preview



=== campaign/ram_component/hint_0.txt ===

$32597308066943* First of all, let's place our 4 bytes of memories on the board 



=== campaign/ram_component/hint_1.txt ===

$73686127519870* Then we need to decide on which memory cell to load from/save to

$86131527203527* This is where a decoder comes in handy



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

$51243843817679* Using the [T] output of the decoder, we can enable the corresponding cell to load from

$78963222298606* And don't forget another switch to only output when LOAD is [T]



=== campaign/ram_component/hint_3.txt ===

$51887730294248* Wire that up and the only thing left is to enable the right memory cell

$65959445914539* The value to save to a cell comes from one input



=== campaign/ram_component/label.txt ===

$10655955073336* Load

$46688176903674* Address



=== campaign/ram_component/meta.txt ===

$14374127314134* Little Box

$68663841862704*
In this level you have to build a circuit that 
can store or load from 4 different bytes of memory.

You are given 1 bit that determines if you are to load. Another bit determines if you are to store and it comes with a corresponding value.
Additionally, you have 2 address bits. 

With 2 bits, there are 4 combinations, one for each byte of memory in this level.

[tip]Spacebar rotates components.[/tip]

$76851096880864* Can you fit 4 bytes of memory in this limited space?



=== campaign/ram_component/test.si ===

$29258463778822* Output was Z, but it should have been {expected_value}.

$45179662026844* Output should have been Z.

$48251194975794* Output was {actual_value}, but it should have been {expected_value}.

$52597500133853* Save {text_value} to {text_add}

$55086379351729* Load {text_state} from {text_add}



=== campaign/ram_component/ui.txt ===

$22107475451139* [left]Save ??? to ??[/left]

$27304327624610* [color=#E49F44][b]State[/b][/color]

$27457656265551* [color=#E49F44][b]Save [/b][/color]

$57378010777762* [left]Load ??? from ??[/left]

$62207646058430* [color=#E49F44][b]Load [/b][/color]

$62589960113273* [color=#E49F44][b]Address[/b][/color]

$71008031461945* [color=#E49F44][b]   Value   [/b][/color]

$85306375920893* [color=#E49F44][b]  Address  [/b][/color]



=== 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/sandbox/meta.txt ===

$58382627590046* The Sandbox



=== campaign/saving_bytes/hint_solution.txt ===

$73980120059844* We just make the byte version out of the "Saving Gracefully" level



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

$41663630841312* Saving Bytes

$87293777622656*
Create a circuit that can store a byte.

When the "SAVE" input is [T], store the input byte.

At all times output the stored value to the output.



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

$60269032570207* Expected output {expected_output}.



=== campaign/saving_gracefully/hint_0.txt ===

$14624167685294* In this level you need to use 1 Delay Line

$52905927349424* The inputs are the 2 level inputs AND the output of the Delay Line, as the output plays a role in its input

$61760299843073* Consider the input to the Delay Line as the output for your table.

$83682732712729* Make a truth table for what should go into the Delay Line

$90057665917240* Once you have the level requirements as a table, it should be a lot easier to solve.

$90652401745526* In total you have 3 'inputs' to for this table which gives you 8 combinations



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

$16548183735739* It, however, only stores for 1 cycle, so we loop it into itself to keep refreshing it

$64973475823722* The only component we have that has 'memory' is the Delay Line



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

$11101940160071* When the Action pin is [T], or Save, we want to overwrite it with Value

$19959785727663* But doing that will cause a short circuit



=== campaign/saving_gracefully/hint_solution.txt ===

$10919459809145* So we place a Multiplexer to decide which value to write to the Delay Line



=== campaign/saving_gracefully/label.txt ===

$88860903896097* Save



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

$13114757255411*
In this level you have 2 inputs.
When the first input is [T], update the stored value.
The second input is the new value to update the stored value with.
Always output what is currently stored.

$39874917169400* Saving Gracefully

$61501859914469*
The Delay Line only allows us to store a value for 1 cycle. But sometimes a component that can store a value for longer periods of time is useful.

We want you to build such a component.



=== campaign/saving_gracefully/ui.txt ===

$10654649810679* Save

$63465863198591* Value



=== 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/second_tick/hint_0.txt ===

$81345258398584* The truth table tells us that the output is [T]

$87387306821265* if and only if the input 0 is [T] AND input 1 is [F]



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

$11961528105462* Output [T] on the second cycle only.

$69913560783046* Second Cycle



=== campaign/signed_negator/hint_0.txt ===

$59964726775903* by flipping its bits (byte NOT) and then adding one

$77523753173621* A negative of a binary number can be obtained



=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* That, though, is left as an exercise to the player!

$55687805352825* This solution is by no means the most elegant or optimal



=== campaign/signed_negator/meta.txt ===

$15862778001173*
Taking the input as signed (where the 8th bit is -128), make a component that takes a number and negates it.
For example 4 negated would become -4. -9 negated would become 9.

$54237470041206* Signed Negator



=== campaign/signed_negator/ui.txt ===

$10529708471093* Input



=== 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_1_nand/meta.txt ===

$36086882016175*

Most instructions take 2 arguments and produce 1 result (like ADD, OR etc). 

[color=#e49f44]Symphony[/color] uses 4 bytes per instruction and can encode all three in each instruction, which are stored in the RAM component named "Main Memory". This means we can for example ADD any two registers and store the result in any other register.

$62556352127349* Wire Spaghetti

$70083014183793* Finally it is time for you to start building the [color=#e49f44]Symphony[/color] architecture!

$83483553172261*
With all of that explained, implement the NAND instruction.

This is how the instructions are encoded:

[left]
                      [color=#ff9800]M[/color] = Mode
                      [color=#ff6680]O[/color] = Opcode
                      [color=#ffe666]D[/color] = Destination register
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Unused / zero
[/left]

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

Use the decoder to separate the destination and argument registers. Be careful: load and store ports accept the address in bytes, but each of the registers takes up 4 bytes. This means you need to provide the address of the register, not its index.
Also, in this level the [color=#ff9800]Mode[/color] is always 1 and the [color=#ff6680]Opcode[/color] is always 0. This means we NAND the first argument with the second and store the result to the result register. For now you can just use a 32 bit NAND gate in place of the ALU.

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

$88649654188267*
These are the names of the 16 registers of [color=#e49f44]Symphony[/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 sp
                            15 flags
[left]

"zr" will always produce 0 when read, so any write to "zr" will be discarded, we can use this to simplify our hardware. "sp" and "flags" are normal registers that just happen to have different names. They will be reserved for special purposes later.

Instead of using individual registers, use the provided RAM component that is named "Register File".



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

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

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

$40674051088628* Screen setting 3 is supposed to be {expected_value}, not {value}

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

$56149980430079* Output should have been enabled.

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

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

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

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



=== campaign/symphony_1_nand/ui.txt ===

$21345632528660* Build the foundation of the Symphony architecture



=== campaign/symphony_2_io/hint_solution.txt ===

$34652721020070* The grey wires implement the IO mode



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

$66929200224494*
In this level we add a way to input and output values to [color=#e49f44]Symphony[/color].

Again, this is how instructions are encoded:

[left]
                      [color=#ff9800]M[/color] = Mode
                      [color=#ff6680]O[/color] = Opcode
                      [color=#ffe666]D[/color] = Destination register
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Unused / zero
[/left]

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

Just like with [color=#e49f44]Overture[/color] there are 4 modes:

0 IO
1 ALU
2 JUMP
3 RAM

However, in this level you only have to worry about IO and ALU mode. When in ALU mode, execute the NAND instruction as in the previous level. When in IO mode, execute one of the following instructions, based on the opcode:

0 nop (Do nothing)
1 in  (Send input to the [color=#ffe666]destination register[/color])
2 out (Send [color=#66ccff]argument B[/color] to output)

$85119202720349* IO



=== campaign/symphony_2_io/ui.txt ===

$76620689360899* Add IO mode to Symphony



=== campaign/symphony_3_alu/hint_solution.txt ===

$23277299590423* Replace the NAND gate with the ALU component

$90347458725803* The new orange wires feed the opcode to the ALU



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

$13069282666558*
Add the ALU you built in the previous level to the circuit. The operation of each instruction is encoded in the [color=#ff6680]Opcode[/color].

[left]
                      [color=#ff9800]M[/color] = Mode
                      [color=#ff6680]O[/color] = Opcode
                      [color=#ffe666]D[/color] = Destination register
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Unused / zero
[/left]

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

$78613176066303* Integrating ALU



=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* Add the ALU to 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/default.isa ===

$11626177279992* Jump to %a if the first value was above (unsigned) the second (reading results from 'flags').

$12835125621741* Stores the value of %b in screen setting %a.

$13110303123442* Store %value to address %adr in persistent memory.

$13576771671264* Logical shift left %b by %c and store the result in %a.

$15915531259935* Sends %a to output.

$16685334571248* Logical shift right %b by %c and store the result in %a.

$18254089726214* Sends %a to output.

$19953421010778* Store %value to address %adr in main memory.

$23349431010010* ADD %b and %c and store the result in %a.

$23396316982953* Loads address %adr from main memory and stores it to %dest.

$26183125927881* Jump to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').

$27219499692147* Loads address %adr from main memory and stores it to %dest.

$27868418224252* Loads keyboard input and stores it to %a.

$28652904157569* SUB %b and %c and store the result in %a.

$29562677483890* Store %value to address %adr in main memory.

$30574433901064* OR %b and %c and store the result in %a.

$31763492459833* Jump to %a if the first value was below (unsigned) the second (reading results from 'flags').

$37102964808364* Compares %a and %b and store the result in the 'flags' register.

$37333076617857* NOR %b and %c and store the result in %a.

$39857449355186* Stores the value of %b in screen setting %a.

$40732211165530* OR %b and %c and store the result in %a.

$42626144645228* Arithmetic shift right %b by %c and store the result in %a.

$44524771082050* Loads an input and stores it in %a.

$46087142860391* NOR %b and %c and store the result in %a.

$46967848572964* XOR %b and %c and store the result in %a.

$47442552951774* Store %value to address %adr in main memory.

$51030225266712* ADD %b and %c and store the result in %a.

$53499765587663* Jump to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').

$54565380946620* Compares %a and %b and store the result in the 'flags' register.

$54577249258785* Logical shift left %b by %c and store the result in %a.

$55551510150818* Arithmetic shift right %b and %c and store the result in %a.

$57200935026773* Loads address %adr from main memory and stores it to %dest.

$59344052643304* Store %value to address %adr in persistent memory.

$61040780958703* Store %value to address %adr in main memory.

$66785854415645* XOR %b and %c and store the result in %a.

$67019902294705* Logical shift right %b by %c and store the result in %a.

$67178948469318* Jump to %a if the values were not equal (reading results from 'flags').

$67376584796076* Loads the counter value and stores it to %a.

$67495552371225* SUB %b and %c and store the result in %a.

$68219187873304* Loads the upper four bytes of the time value and stores it to %a.

$69550893885320* Store %value to address %adr in main memory.

$69632418904622* Loads address %adr from main memory and stores it to %dest.

$71317192057126* Jump to %a if the first value was greater (signed) than the second (reading results from 'flags').

$71637103729391* Jump to %a if the first value was less (signed) than the second (reading results from 'flags').

$72280171778920* Loads address %adr from persistent memory and stores it to %dest.

$72551400437977* Loads the lower four bytes of the time value and stores it to %a.

$73559051740347* Store %value to address %adr in main memory.

$74148826866592* Jump to %a.

$75302656449127* NAND %b and %c and store the result in %a.

$77040234358389* Jump to %a if the first value was less (signed) or equal to the second (reading results from 'flags').

$77232719678109* Loads address %adr from main memory and stores it to %dest.

$82087388048746* Jump to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').

$85679146831122* AND %b and %c and store the result in %a.

$85822609095465* Loads address %adr from main memory and stores it to %dest.

$86705346481666* NAND %b and %c and store the result in %a.

$86713121915282* AND %b and %c and store the result in %a.

$88180305667389* Jump to %a if the values were equal (reading results from 'flags').

$88272577071256* Does nothing.

$89257021109854* Loads address %adr from persistent memory and stores it to %dest.

$90876214388280* Jump to %a.



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

$18099138932731* Persistent Memory

$28246040923235* Register File

$35059654572638* time

$41903613959902* Main Memory

$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_alu/meta.txt ===

$52048822283735*
This is a copy of the Overture ALU. Time to upgrade it to 32 bits and a few new instructions.

Instructions:

[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]

The cmp operation is the one you already created a custom component for in the previous level.

$71902120982324* Symphony ALU



=== campaign/symphony_alu/ui.txt ===

$69427874681706* Implement the Symphony ALU



=== campaign/symphony_cmp/meta.txt ===

$37729390402296* Comparison Flags

$64818361855764*
In this level you compare two 32 bit inputs in three different ways. Each result is a 1 bit value called a "flag".

Flags:
Set bit 0 to 1 if the inputs are equal.
Set bit 1 to 1 if the first input is lower (unsigned) than the second input.
Set bit 2 to 1 if the first input is less (signed) than the second input.

To learn about making 32 bit components, open "Symphony counter" level first if you haven't already.



=== campaign/symphony_cmp/test.si ===

$55730459238598* Expected output: {a}{b}{c}.



=== campaign/symphony_cmp/ui.txt ===

$73310930628112* Implement the Symphony flags



=== campaign/symphony_condition_test/label.txt ===

$13327132168076* Result

$17010689474441* Condition

$25959617344671* Flags



=== 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/symphony_counter_1/label.txt ===

$41164574218692* Count

$42019997838216* Overwrite

$48990052180226* Value



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

$56387381898532* Symphony Counter

$76860406179468*
To change word component width, you will need to use a Bit size tool near the left panel (looks like a bidirectional arrow and a number).

Right click on the Bit size tool to specify the target width.
Left click on components when the tool is active will set the component's bit width.
Newly placed word components will have this bit width by default.

$77897142643435*
Build a 32 bit counter that increments by 4, but can alternatively be overwritten with a specific value.

Also, connect the provided memory probe to a 32-bit component holding the counter memory value.



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

$54301125260332* Memory is supposed to be {expected_memory}, not {memory_value}

$70376380014778* Output should never be Z state

$84451713761977* Output should be {expected_memory}



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

$81792554779622* Build a 32 bit counter which increments by 4 each cycle



=== campaign/symphony_decoder/label.txt ===

$16402377924132* Is Immediate

$24747841106265* Argument B

$26207217884026* Opcode

$26325060783055* Argument A

$40584554497383* Immediate Value

$48212238534381* Instruction

$48506758479060* Mode

$67128656777473* Destination



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

$13883461694525* Instruction Decoder

$41138026161536*
Use the static indexer component to solve this level. 

The static indexer component is a special component that allows you to shift certain bits from a wire, without any delay or gates cost. Changing the number on the component will shift bits (positive number shifts to the right). Then click on the component to set the output width.

$71911284169222*

Build a circuit that splits Symphony instructions into their different parts. This will be very helpful later.

There are two encodings for Symphony instructions, depending on whether we are using immediate values or not:

[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]

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

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



=== campaign/symphony_decoder/test.si ===

$15174125339458* Opcode should be {opcode}, not {actual_opcode}.

$31544476297744* Destination should be {dest}.

$31942264008156* Arg B should be {b}.

$45701446129480* Immediate value should be {immediate_value}.

$63089562267538* 'Is immediate' should be {immediate}.

$64926808682290* Mode should be {mode}.

$82638458430252* Arg A should be {a}.



=== campaign/symphony_decoder/ui.txt ===

$51036929729507* Implement the Symphony decoder



=== campaign/the_bus/hint_0.txt ===

$42863588667057* Use switches to put the inputs on the same wire



=== campaign/the_bus/hint_1.txt ===

$88955803760495* The selective input is just a Multiplexer



=== campaign/the_bus/hint_solution.txt ===

$55189990966587* Tweak the Multiplexer to share its input, instead of output, for the selective output

$86286155471986* The purple wire in the middle is the BUS



=== campaign/the_bus/label.txt ===

$25477689162292* Output select

$25535487507842* A

$43340511034957* Input select

$43474590938240* Y

$47236089523392* X

$65041743851294* B



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

$10949534274977* The bus

$25369396405852*
This level has 2 byte inputs and 2 byte outputs. Your goal is to move a number from one input to one output.

The first bit input, determines which input you should move from. The second bit input determines which output you should move to.

At each cycle, only 1 output should receive the value, the other output should receive Z (no value). This will be indicated by "-" on the output.



=== campaign/the_bus/test.si ===

$28173496384607* Output Y should be {val}.

$46672500255781* Output X should be Z.

$65293894030728* Output X should be {val}.

$69214136994673* Forward the value from {source} to {destination}

$75577618213381* Output Y should be Z.



=== campaign/the_bus/ui.txt ===

$31341803878224* Create a circuit that forwards the value from a specified input to the specified output.



=== 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!



=== campaign/xnor/hint_0.txt ===

$89305883777750* Notice how the XNOR gate output is the exact opposite of the XOR gate?



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

$29396170535219* Create the inverse XOR gate, known as XNOR.

$50956872142719* XNOR Gate

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



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

$15534865654723* Input 0

$17025412277453* Input 1

$59092390409834* Desired output

$62308032073140* either the input 0 is [T] AND input 1 is [F] OR the input 0 is [F] AND input 1 is [T]

$84782011304318* The truth table tells us that the output is [T] if and only if



=== campaign/xor_gate/hint_solution.txt ===

$16623524168613* That, though, is left as an exercise to the player!

$30671593085518* This solution is by no means the most elegant or optimal



=== campaign/xor_gate/label.txt ===

$22122562689406* Output

$45326245069696* Input



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

$21287008524643* XOR Gate

$30005674935190*
This is also known as an XOR gate. This level is difficult, so don't be discouraged if you don't get the answer right away.

[tip]You can connect one output to more than 1 gates.[/tip]

$50002893048555* Last level you built a circuit that was [T] when we were at the second cycle. This level build a circuit that is [T] when we are at the second OR third cycle.



=== campaign/xor_gate/ui.txt ===

$38271404408184* Current output



=== model/board/custom_prototype.nim ===


# Default new output pin name for custom compoennts
$14864122622568* Output


# Default new input pin name for custom compoennts
$14951951489108* Input



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


# com_mux's output pin
$10003014068713* Output


# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* Inputs


# com_concatenator_8's input pin
$10080083255838* Word 3


# com_clz's output pin
$10092537578053* Result


# com_splitter_bit_4's output pin
$10111764008386* Bit 2


# com_level_output_4_pin's name
$10190739202646* Output


# com_ctz's description
$10231593934948* Count 0s from the least significant digit until the first 1


# com_xor_word's output pin
$10269927015049* Result


# com_static_indexer_config's name
$10289043699917* Auto Static Indexer


# com_lsr's input pin
$10335381544532* Shift by


# com_halt's name
$10351143139905* Halt


# com_nand_word's input pin
$10425218359878* Input 0


# com_splitter_bit_8's description
$10488114435022* Splits a byte into 8 bits


# com_splitter_bit_8's output pin
$10491931394044* Bit 3


# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* IO


# com_probe_wire_bit's input pin
$10499689720024* Value


# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* Dev


# com_splitter_bit_4's name
$10524104374521* Splitter


# com_cc_output's name
$10557704838301* Output Pin


# com_segment_display's name
$10582128204153* 7 Segment Display


# com_switch_word's name
$10611658692685* Switch


# com_xnor_bit's description
$10614106399129* [T] when inputs are the same


# com_not_word's description
$10624873506476* Bitwise flip bits


# com_counter's output pin
$10629272823895* Count


# 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* Input


# com_maker_bit_8's input pin
$10716205698752* Bit 5


# com_decoder_3's input pin
$10755367544042* Input


# com_delay_line_word_config's output pin
$10757852071445* Result


# com_rol's input pin
$10762061266647* Value


# com_decoder_2's output pin
$10762093809413* Bit 1


# com_nor_word's input pin
$10770218762282* Input 0


# com_concatenator_2's description
$10776829749898* Concatenates 2 values, the output width is the sum of all input widths


# com_cc_output's description
$10781578424003* Output pin


# com_ror's description
$10802217509530* Rotates the bits of an input right


# com_add's output pin
$10815269647822* Carry out


# com_not_bit's description
$10844421681709* Inverts the input


# com_nand_word's description
$10859914201083* Bitwise NAND two values


# com_full_adder's output pin
$10918445419498* Result


# com_static_value's output pin
$10920459933396* Value


# com_mod's description
$10934212906097* Modulo 2 numbers


# com_level_input_word's name
$10943344093513* Input


# com_keyboard's name
$10965596602414* Keyboard


# com_less_s's output pin
$11019209691112* Result


# com_asr's name
$11034107377099* Arithmetic Shift Right


# com_maker_word_2's description
$11048127331082* Merges 2 (n/2)-bit values into one n-bit value


# com_register_word_config's input pin
$11057152094224* Size


# com_concatenator_8's input pin
$11115698874478* Word 0


# com_maker_bit_4's name
$11119510732154* Maker


# com_nand_bit's name
$11130919681688* NAND


# com_static_indexer_config's output pin
$11132082500971* Result


# com_mux's description
$11168613697835* Toggles between two values


# com_full_adder's input pin
$11264799740288* Input 0


# com_level_input_switched's name
$11278573510238* Switched Input


# com_not_word's name
$11286216680410* NOT


# com_maker_word_2's output pin
$11293966912554* Result


# com_decoder_2's output pin
$11297026031742* Bit 2


# com_level_output_word's name
$11300749636961* Output


# com_full_adder's input pin
$11312161634667* Input 1


# com_delay_line_word_config's late input pin
$11320392055125* Input


# com_mod's output pin
$11329013865174* Result


# com_or_word's input pin
$11335506036805* Input 1


# com_level_input_word's description
$11342065742485* Word input


# com_splitter_word_4's output pin
$11345730126879* Word 0


# com_static_indexer_config's input pin
$11349557191063* Input


# com_maker_word_8's output pin
$11351867388170* Result


# com_mod's input pin
$11352468367638* Dividend


# com_concatenator_8's input pin
$11366501215506* Word 2


# com_level_gate's name
$11417416554850* Level Component


# com_splitter_word_8's input pin
$11440186157356* Input


# com_level_input_4_pin's name
$11447837612693* Input


# com_inc's description
$11449663590476* Increments the input by 1


# com_splitter_word_8's output pin
$11465347976002* Word 3


# com_level_output_switched's input pin
$11520072088720* Enable


# com_asr's output pin
$11521973612539* Result


# com_splitter_bit_8's output pin
$11548514728473* Bit 0


# com_switch_bit's name
$11574334638147* Switch


# com_nand_word's input pin
$11578787451669* Input 1


# com_div's input pin
$11611913368782* Divisor


# com_switch_word's output pin
$11625195403324* Output


# com_maker_bit_8's input pin
$11634467729625* Bit 4


# com_neg's input pin
$11637742665554* Input


# com_clz's name
$11678932883790* Count leading zero


# com_ram's name
$11710093917097* RAM


# com_decoder_2's name
$11727998752868* 2 Bit Decoder


# com_maker_bit_2's input pin
$11752209410617* Bit 1


# com_and_word's description
$11791872137683* Bitwise AND two values


# com_mul's output pin
$11838813794006* Result


# com_off's name
$11860786587357* OFF


# com_splitter_bit_8's name
$11904470559153* Splitter


# com_nor_word's output pin
$11938328576163* Result


# com_delay_line_bit's output pin
$11945697622944* Result


# com_and_word's input pin
$11977039914327* Input 0


# com_neg's description
$12021716182809* Negates the input


# com_splitter_bit_2's input pin
$12046095993506* Input


# com_screen's name
$12046117430308* Screen


# com_cc_level_output's description
$12051024347384* A word output that will be converted to IO pin if level solution is saved as a component


# com_splitter_bit_4's input pin
$12060097589370* Input


# com_xnor_word's name
$12087865653212* XNOR


# com_ror's name
$12093087039542* Rotate Right


# com_delay_line_bit's name
$12121899638400* Delay Line


# com_nor_word's name
$12175906806727* NOR


# com_neg's output pin
$12196354295621* Result


# com_level_output_1_pin's name
$12242923444593* Output


# com_level_output_counter's name
$12247325526438* Counter


# com_maker_word_4's output pin
$12262460678043* Result


# com_probe_memory_bit's name
$12318534735397* Memory Probe (bit)


# com_concatenator_2's input pin
$12329350771997* Wire 2


# com_concatenator_8's input pin
$12341255296823* Word 1


# com_verilog_output's name
$12353364840899* Verilog Output


# com_probe_wire_asm's late input pin
$12365938365321* Input


# com_splitter_word_4's description
$12370556827575* Splits a (4n)-bit value into four n-bit values


# com_concatenator_4's input pin
$12371272172145* Word 1


# com_concatenator_8's input pin
$12384635971036* Word 5


# com_decoder_3's output pin
$12390018918095* Bit 7


# com_asr's input pin
$12408847893200* Shift by


# com_register_word's late input pin
$12420839132846* Save value


# com_constant's description
$12424468899005* Constant value


# com_concatenator_8's description
$12443053648819* Concatenates 8 values, the output width is the sum of all input widths


# com_keyboard's output pin
$12465282633818* Key value


# com_level_input_1_pin's output pin
$12465938629713* Input


# com_concatenator_8's output pin
$12478474747295* Result


# com_probe_memory_word's description
$12492235992906* Display a value on your custom component or in the program editor


# com_mux's input pin
$12520768681157* Value 1


# com_switch_word's input pin
$12550214308917* Value


# com_maker_word_8's input pin
$12592072659210* Word 1


# com_maker_bit_2's name
$12602955212919* Maker


# com_maker_word_8's input pin
$12616927929524* Word 3


# com_static_indexer_config's input pin
$12633414511976* Size


# com_delay_line_word's late input pin
$12644592179746* Input


# com_register_bit's name
$12678278048629* Register


# com_mux's input pin
$12687047365426* Value 0


# com_and_bit's description
$12719674432950* [T] when both inputs are [T]


# com_splitter_word_2's name
$12723870092766* Splitter


# com_counter's description
$12736827510023* Increments each cycle, unless overwritten


# com_level_input_1_pin's name
$12746117288689* Input


# com_off's description
$12749460799924* Always [F]


# com_less_s's description
$12765625016236* Checks if the first input is less than the second one


# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* Bit


# com_switch_word's input pin
$12784430582183* Enable


# com_lsl's input pin
$12849468178655* Value


# com_static_indexer_config's input pin
$12869119410565* Shift


# com_nand_bit's description
$12903183841172* [T] unless both inputs are [T]


# com_and_word's name
$12926911335769* AND


# com_lsr's name
$12931148241340* Shift Right


# com_splitter_word_4's input pin
$12938882109013* Input


# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* Displays


# com_halt's description
$12990744955549* Stops execution with a custom message


# com_or_bit's description
$13013154620359* [T] when either input is [T]


# com_level_output_8_pin's name
$13087193858087* Output


# com_maker_bit_8's input pin
$13104890311933* Bit 1


# com_rol's input pin
$13135722015590* Rotate by


# com_decoder_3's output pin
$13138546420646* Bit 6


# com_store_port's name
$13159020985209* Store port


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


# com_level_output_3_pin's description
$13174121812559* Three bit output


# com_maker_word_4's input pin
$13236424504117* Word 2


# com_xor_word's description
$13236921580268* Bitwise XOR two values


# com_level_output_2_pin's name
$13255344581755* Output


# com_level_gate's description
$13259215761047* Used for creating level maps


# com_cc_input's description
$13263310288543* Input pin


# com_delay_line_word_config's input pin
$13271299225650* Size


# com_level_input_1_pin's description
$13272198916233* One bit input


# com_register_word's late input pin
$13298317818150* Save enable


# com_concatenator_4's input pin
$13331778821779* Word 0


# com_verilog_input's output pin
$13351141217116* Input


# com_nor_bit's name
$13375115196253* NOR


# com_maker_word_8's input pin
$13378739117488* Word 6


# com_less_u's name
$13502755965496* Low < (unsigned)


# com_splitter_word_2's output pin
$13510688527850* Word 1


# com_ror's input pin
$13521735131997* Rotate by


# com_register_word's description
$13576980017857* Small memory component


# com_splitter_word_2's output pin
$13625849577132* Word 0


# com_splitter_bit_8's output pin
$13666042416530* Bit 2


# com_keyboard's output pin
$13705122401876* Event waiting


# com_splitter_bit_2's name
$13766521376720* Splitter


# com_maker_bit_4's input pin
$13826250945595* Bit 3


# com_ctz's input pin
$13829181406158* Input


# com_equal's input pin
$13859686951415* Input 0


# com_add's name
$13973952772642* Add


# com_xnor_bit's name
$14079327237795* XNOR


# com_lsl's output pin
$14132199132916* Result


# com_less_u's input pin
$14201184715010* Input 0


# com_maker_bit_4's input pin
$14237744302250* Bit 0


# com_keyboard's output pin
$14338437722935* Key down


# com_maker_bit_8's description
$14338505460996* Merges 8 bits into one byte


# com_level_input_2_pin's description
$14340334686746* Two bit input


# com_decoder_3's name
$14375716460090* 3 Bit Decoder


# com_verilog_input's description
$14408471620057* Verilog input


# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* Multi


# com_probe_wire_word's name
$14427436420428* Wire Probe


# com_not_bit's name
$14453052824732* NOT


# com_inc's name
$14456039381703* Increment


# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* Verilog


# com_nor_word's description
$14517798310461* Bitwise Nor two values


# com_maker_bit_2's description
$14531866237078* Merges 2 bits into one 2-bit value


# com_splitter_word_8's output pin
$14592399073683* Word 7


# com_splitter_bit_4's output pin
$14645527447275* Bit 0


# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* Memory


# 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* Word Maker


# com_xor_bit's name
$14832952840086* XOR


# com_register_bit's output pin
$14834136969633* Result


# com_maker_bit_2's input pin
$14834270613682* Bit 0


# com_segment_display's input pin
$14849689592952* Value


# com_maker_bit_4's input pin
$14852108377004* Bit 2


# com_level_output_2_pin's description
$14875690243444* Two bit output


# com_maker_bit_8's output pin
$14889574903079* Result


# com_mul's input pin
$14896244080868* Input 0


# com_mul's input pin
$14913258317738* Input 1


# com_probe_wire_word's input pin
$14914933156268* Value


# com_level_input_switched's input pin
$14935676453720* Enable


# com_maker_bit_8's input pin
$14944669923906* Bit 7


# com_div's name
$14959426271423* Divide


# com_verilog_output's description
$14973155280765* Verilog output


# com_less_u's output pin
$15024221028085* Result


# com_mux's input pin
$15091015683874* Select 0 / 1


# com_asr's description
$15194709458499* Shifts bits to the right, while maintaining the sign of the number


# com_probe_wire_bit's description
$15206117280094* Display a value on your custom component or in the program editor


# com_splitter_word_8's description
$15228522216068* Splits an (8n)-bit value into eight n-bit values


# com_maker_word_4's input pin
$15232070727738* Word 1


# com_lsl's name
$15268915597774* Shift Left


# com_inc's output pin
$15310910823919* Result


# com_splitter_word_4's output pin
$15360783001914* Word 2


# com_less_s's name
$15403981009644* Less < (signed)


# com_maker_word_4's description
$15410415450178* Merges 4 (n/4)-bit values into one n-bit value


# com_splitter_word_2's description
$15417695246232* Splits a (2n)-bit value into two n-bit values


# com_mux's name
$15422378975821* Mux


# com_less_s's input pin
$15432695156488* Input 0


# com_concatenator_4's description
$15492861320167* Concatenates 4 values, the output width is the sum of all input widths


# com_decoder_3's output pin
$15527856774069* Bit 2


# com_rol's description
$15557725551789* Rotates the bits of an input left


# com_splitter_word_4's output pin
$15566912320742* Word 1


# com_cc_level_output's name
$15625973306519* Output


# com_not_word's output pin
$15635980858172* Result


# com_level_output_8_pin's input pin
$15649241608462* Output 6


# com_equal's description
$15668435514829* Checks if the two inputs are equal


# com_maker_word_4's input pin
$15693531522415* Word 0


# com_splitter_bit_4's output pin
$15744234453408* Bit 3


# com_concatenator_8's input pin
$15759275278695* Word 4


# com_ror's input pin
$15762072154176* Value


# com_xnor_word's description
$15789912406647* Bitwise XNOR two values


# com_static_value's output pin
$15833633678405* Bit size


# com_maker_word_8's description
$15845204308823* Merges 8 (n/8)-bit values into one n-bit value


# com_constant's name
$15858905835416* Constant


# com_on's name
$15896157427528* ON


# com_decoder_2's output pin
$15898724303882* Bit 3


# com_concatenator_4's name
$15908922745328* Concatenator


# com_or_word's input pin
$15962339721851* Input 0


# com_probe_wire_word's description
$15969687819995* Display a value on your custom component or in the program editor


# com_clz's input pin
$15988469904002* Input


# com_register_word's name
$16007777261800* Register


# com_time's name
$16011300295966* Time


# com_splitter_word_4's output pin
$16099286786157* Word 3


# com_static_indexer's description
$16103423834548* Shift the values on a wire by fixed amount at no delay or gate cost. Positive values shift right, negative shift left


# com_lsr's input pin
$16105779236896* Value


# com_less_s's input pin
$16118461327893* Input 1


# com_splitter_word_8's output pin
$16120663256468* Word 4


# com_level_output_word's description
$16148744080822* Word output that will be converted to IO pin if level solution is saved as a component


# com_maker_word_2's input pin
$16178897760565* Word 1


# com_splitter_bit_8's input pin
$16196769003341* Input


# com_on's description
$16212935718484* Always [T]


# com_mod's name
$16223673009720* Modulo


# com_level_output_4_pin's input pin
$16259545926196* Output 0


# com_ror's output pin
$16261916666444* Result


# com_level_output_3_pin's name
$16269858195218* Output


# com_static_eval's name
$16294314784377* Static Evaluator


# com_less_u's input pin
$16307028951926* Input 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* Logic


# com_load_port's name
$16380513614754* Load port


# com_counter's late input pin
$16380665909610* Overwrite


# com_splitter_bit_4's description
$16428357982878* Splits a 4-bit value into 4 bits


# com_load_port's description
$16440979564796* Add a load pin to a memory component


# com_concatenator_4's output pin
$16450922709110* Result


# com_lsl's description
$16482114876737* Shifts the bits of an input left


# com_mul's name
$16549841656852* Multiply


# com_add's output pin
$16559516323162* Result


# com_splitter_word_4's name
$16563671560208* Splitter


# com_level_input_3_pin's description
$16604606953092* Three bit input


# com_maker_word_4's name
$16610055905190* Word Maker


# com_decoder_3's output pin
$16637198920534* Bit 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* Outputs


# com_xor_word's input pin
$16674052164634* Input 0


# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* Custom


# com_decoder_1's description
$16685462633615* Toggles between two outputs


# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* Levels


# com_rol's name
$16755142829250* Rotate Left


# com_segment_display's description
$16761198694928* Good for displaying numbers


# com_keyboard's description
$16766452660421* Records keypresses from your physical keyboard


# com_decoder_3's input pin
$16773243310913* Disable


# com_level_input_switched's description
$16797889673362* Loads the input from levels


# com_and_word's output pin
$16806711173957* Result


# com_cc_level_input's name
$16810631435170* Input


# com_and_3_bit's description
$16839706221116* 3-input AND gate


# com_xor_word's name
$16843812162355* XOR


# com_xor_bit's description
$16856280609387* [T] when inputs are different


# com_level_input_2_pin's name
$16870364449392* Input


# com_static_eval's description
$16874064281189* Calculates a value before simulation (it becomes a constant during simulation)


# com_probe_memory_bit's description
$16875362121056* Display a value on your custom component or in the program editor


# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* Word


# com_switch_bit's description
$16917313833836* Toggles a bit


# com_concatenator_8's name
$16974631589430* Concatenator


# com_cc_level_output's input pin
$17030391013189* Output


# com_splitter_bit_8's output pin
$17053062486634* Bit 4


# com_or_word's name
$17053670145576* OR


# com_xnor_word's output pin
$17089816656649* Result


# 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* Static Value


# com_store_port's description
$17240636780043* Add a store pin to a memory component


# com_mod's input pin
$17244932190980* Divisor


# com_or_bit's name
$17247779246257* OR


# com_splitter_bit_2's output pin
$17293853955838* Bit 1


# com_switch_word's description
$17345192339084* Toggles a value


# com_delay_line_word's name
$17407828844862* Delay Line


# com_splitter_word_8's output pin
$17425893786880* Word 6


# com_concatenator_2's name
$17495243848605* Concatenator


# com_nor_bit's description
$17510848535619* [T] when neither inputs are [T]


# com_maker_bit_8's input pin
$17515061804367* Bit 0


# com_full_adder's description
$17559382166174* Adds 3 bits and outputs the sum and the carry


# com_or_3_bit's description
$17576327690867* 3-input OR gate


# com_maker_word_8's name
$17581447274882* Word Maker


# com_register_word_config's name
$17630501850089* Auto Register


# com_level_output_3_pin's input pin
$17644027370563* Output 2


# com_splitter_bit_8's output pin
$17664445405251* Bit 5


# com_full_adder's name
$17669928463861* Full Adder


# com_register_bit's description
$17670626909848* 1 bit of memory


# com_maker_word_4's input pin
$17742753106024* Word 3


# com_register_bit's late input pin
$17744526831576* Enable


# com_concatenator_2's output pin
$17758165407719* Result


# com_counter's late input pin
$17764401720104* Overwrite value


# com_equal's input pin
$17767800149691* Input 1


# com_static_value's description
$17781742628050* Easily set values or width on individual custom components


# com_add's input pin
$17802619460312* Carry in


# com_cc_input's name
$17814826739168* Input Pin


# com_add's input pin
$17820183531095* Input 0


# com_splitter_bit_4's output pin
$17862413256378* Bit 1


# com_equal's output pin
$17864898529357* Result


# com_maker_bit_4's input pin
$17897455882076* Bit 1


# com_store_port's input pin
$17908666907710* Store value


# com_concatenator_8's input pin
$17908668221433* Word 7


# com_maker_bit_8's input pin
$17957417956069* Bit 3


# com_level_output_switched's input pin
$17979647868788* Output


# com_load_port's output pin
$17988237627670* Output


# com_nand_word's name
$17989404583269* NAND


# com_store_port's input pin
$18001316449428* Address


# com_counter's name
$18007194288764* Counter


# com_splitter_word_8's name
$18008204445107* Splitter


# com_add's input pin
$18009367936916* Input 1


# com_div's input pin
$18043895181775* Dividend


# com_maker_bit_2's output pin
$18060429242565* Result


# com_probe_wire_asm's late input pin
$18082830776248* Address


# com_not_word's input pin
$18100827224098* Input


# com_and_word's input pin
$18149321315676* Input 1


# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* IO


# com_keyboard's input pin
$18168295822085* Read next


# com_store_port's input pin
$18196820862263* Enable


# com_delay_line_bit's description
$18206009264853* Stores the input for 1 cycle


# com_decoder_3's output pin
$18208851966397* Bit 3


# com_decoder_1's name
$18250587600120* 1 Bit Decoder


# com_level_output_2_pin's input pin
$18282543476901* Output 0


# com_level_output_4_pin's description
$18308856504509* Four bit output


# com_level_output_switched's description
$18319747827404* Switched output


# com_level_output_1_pin's description
$18342586404936* One bit output


# com_maker_word_2's input pin
$18365137610205* Word 0


# com_neg's name
$18379907297327* Negate


# com_load_port's input pin
$18399493738021* Enable


# com_register_bit's late input pin
$18405644304073* Value


# com_full_adder's output pin
$18410639135888* Carry out


# com_concatenator_2's input pin
$18414950181373* Wire 1


# com_splitter_word_8's output pin
$18425501753807* Word 0


# com_add's description
$18429814030509* Adds two inputs


# com_splitter_bit_8's output pin
$18437214963047* Bit 7


# com_delay_line_word_config's description
$18447417990806* Stores the input for 1 cycle


# com_full_adder's input pin
$18480011054605* Carry in


# com_probe_memory_word's name
$18495107507052* Memory Probe


# com_time's output pin
$18510923212418* Nano seconds since Jan 1st 1970


# com_maker_bit_4's output pin
$18538545767544* Result


# com_splitter_word_8's output pin
$18541722201520* Word 2


# com_asr's input pin
$18563543025377* Value


# com_splitter_bit_2's description
$18566798809283* Splits a 2-bit value into 2 bits


# com_register_word_config's late input pin
$18592599175225* Save value


# com_or_word's output pin
$18599325743999* Result


# com_nand_word's output pin
$18604301487974* Result


# com_mul's description
$18631919890554* Multiplies two inputs


# com_less_u's description
$18645721548287* Checks if the first input is less than the second one


# com_maker_word_8's input pin
$18747558269936* Word 7


# com_maker_bit_8's name
$18747779812970* Maker


# com_time's description
$18774996925434* Nano seconds since January 1st 1970


# com_maker_bit_4's description
$18837875001662* Merges 4 bits into one 4-bit value


# com_clz's description
$18865460617183* Count 0s from the most significant digit until the first 1


# com_and_bit's name
$18912167455465* AND


# com_concatenator_4's input pin
$18970466583796* Word 2


# com_decoder_3's output pin
$19041825668970* Bit 0


# com_level_output_counter's description
$19047791955795* Three bit output


# com_maker_word_8's input pin
$19068496076705* Word 2


# com_load_port's input pin
$19069820293504* Address


# com_concatenator_8's input pin
$19112189486457* Word 6


# com_lsl's input pin
$19120200575252* Shift by


# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* Probes


# com_level_input_4_pin's description
$19187328896214* Four bit input


# com_register_word_config's description
$19209488297941* Automatically resizable version of the register


# com_maker_bit_8's input pin
$19209724501083* Bit 2


# com_ctz's name
$19218324472471* Count trailing zero


# com_splitter_word_8's output pin
$19229992367375* Word 5


# com_div's description
$19251828025705* Divide 2 numbers


# com_decoder_2's output pin
$19275565166747* Bit 0


# com_verilog_output's input pin
$19276197821142* Input


# com_concatenator_4's input pin
$19277763516215* Word 3


# com_xnor_word's input pin
$19329533997829* Input 0


# com_nor_word's input pin
$19354802063529* Input 1


# com_equal's name
$19369982838671* Equal


# com_lsr's description
$19394421220436* Shifts the bits of an input right


# com_div's output pin
$19403575811053* Result


# com_or_word's description
$19406015796751* Bitwise OR two values


# com_delay_line_word_config's name
$19421095581293* Auto Delay Line


# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* Math


# com_level_output_switched's name
$19513138880387* Switched Output


# com_probe_wire_bit's name
$19521764791439* Wire Probe (bit)


# com_maker_word_8's input pin
$19579002124406* Word 4


# com_inc's input pin
$19579388993928* Input


# com_xnor_word's input pin
$19579585753615* Input 1


# com_or_3_bit's name
$19630419947500* 3 Pin OR


# com_splitter_word_2's input pin
$19630801846451* Input


# com_and_3_bit's name
$19664974941910* 3 Pin AND


# com_register_word_config's late input pin
$19717901345023* Save enable


# com_xor_word's input pin
$19719622211817* Input 1


# com_maker_word_8's input pin
$19740232065347* Word 0


# com_lsr's output pin
$19748092068880* Result


# com_maker_word_8's input pin
$19779691531031* Word 5


# com_verilog_input's name
$19796166910463* Verilog Input


# com_static_indexer's name
$19804933576629* Static Indexer


# com_ram's description
$19814732518166* Large memory component


# com_cc_level_input's description
$19864966939331* An input that will be converted to custom input, if the solution is saved to the foundry


# com_ctz's output pin
$19883191600386* Result


# com_splitter_word_8's output pin
$19903808503639* Word 1


# com_rol's output pin
$19903955254861* Result


# com_screen's description
$19974317694842* Configurable screen


# com_push_button's name
$20020953885936* Push Button


# com_level_output_3_pin's input pin
$21084166025569* Output 1


# com_level_input_word's output pin
$21448308897245* Input


# com_level_input_2_pin's output pin
$24473197268827* Input 0


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


# com_level_output_word's input pin
$27680966493404* Output


# com_level_output_4_pin's input pin
$29217965518477* Output 1


# com_static_eval's output pin
$29937009351190* Result as size


# com_level_input_4_pin's output pin
$36196915566111* Input 3


# com_level_output_8_pin's input pin
$38015555977208* Output 3


# com_level_output_4_pin's input pin
$39260627694444* Output 3


# com_level_output_8_pin's input pin
$39299381405096* Output 0


# com_level_output_3_pin's input pin
$39908016538045* Output 0


# com_delay_line_word's output pin
$40182352594863* Result


# com_level_output_8_pin's description
$41781588125341* Four bit output


# com_level_input_3_pin's output pin
$42291627335021* Input 2


# com_delay_line_bit's late input pin
$43397945955203* Input


# com_level_output_2_pin's input pin
$44555908976270* Output 1


# com_level_input_4_pin's output pin
$45891070331034* Input 1


# com_level_output_1_pin's input pin
$50802766489958* Output


# com_probe_wire_asm's name
$53494192640542* Disassembling probe


# com_delay_line_word's description
$53901484249817* Stores the input for 1 cycle


# com_screen's input pin
$55023356915123* Setting index


# com_level_input_2_pin's output pin
$55925432534232* Input 1


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


# com_register_word's output pin
$58518173140953* Value


# com_cc_level_input's output pin
$59388037506003* Input


# com_decoder_3's description
$61176454433312* Toggles between eight outputs based on a 3 bit input pin


# com_level_output_8_pin's input pin
$62385154489080* Output 2


# com_screen's input pin
$63216408139965* Enable


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


# com_level_output_8_pin's input pin
$64999131838438* Output 4


# com_level_input_3_pin's output pin
$65765566466116* Input 0


# com_level_input_switched's output pin
$69212597107829* Input


# com_level_input_4_pin's output pin
$70142958857584* Input 2


# com_level_output_8_pin's input pin
$72375982885383* Output 1


# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* Auto


# com_level_input_3_pin's output pin
$79311371309532* Input 1


# com_level_input_4_pin's output pin
$81933801309767* Input 0


# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* Misc


# com_level_output_counter's input pin
$84023157447564* Output 0


# com_register_word_config's output pin
$84598344098990* value


# com_static_indexer_config's description
$85065774878853* Advanced version of "static indexer". Shift and output size is inferred from the size of wires connected to input pins


# com_level_output_counter's input pin
$86331851878040* Output 1


# com_decoder_2's description
$86848277190736* Toggles between four outputs based on a 2 bit input pin

$87754378235471* Output


# com_level_output_4_pin's input pin
$87954408093587* Output 2


# com_screen's input pin
$88137790657923* Value


# com_level_output_8_pin's input pin
$88250281919265* Output 5


# com_static_eval's output pin
$89594489498667* Result as value


# com_level_output_counter's input pin
$89669851602178* Output 2


# com_level_output_8_pin's input pin
$90233476470983* Output 7



=== 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 ===

$11567406591202* 1 byte

$14036822471924* {days} days ago

$16391754618645* {size} KB

$17901039729248* {months} months ago

$18300496139706* 1 month ago

$18683857303458* {size} bytes

$21685594109067* Just now


# Million
$22896492410578* M

$42553566189409* {minutes} minutes ago


# Quadrillion
$49300594926837* Q

$70945526841433* {years} years ago


# Billion
$71072134093858* B

$84076931764831* 1 day ago


# Thousand
$84696693690500* K

$86244493049244* {hours} hours ago


# Trillion
$87907122406742* T

$95018143828198* 1 year ago

$98363990684104* 1 hour ago

$98703677236827* 1 minute ago



=== presenter/board_ui.nim ===

$36331525379247* Save this schematic



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

$55369640789869*
Click anywhere on the board to start a wire
Connect the red components to the NAND gate

$79416009887091* Click anywhere on the board to place the gate

$86840165316981* Right click to deselect the gate



=== presenter/board_ui/bottom_panel/circular_dependency.nim ===

$13880985462901* Make a circuit where the input of a component depends on its own output

$16336401898647* Test 1/2

$22446480186064* Create a circular dependency involving at least 2 components

$32314337981189* Check

$73467991035922* Nope!

$89309211963063* Test 2/2



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

$81974422302188* Manual



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

$10634456248075* Input 1

$10792411581963* {size} MB

$10967837475411* Input 1

$12673774208656* Bit 1

$12729457392140* {size} GB

$12806857886815* Bit 0

$12955769263032* Input

$13973719570693* Size

$14527438551030* Input

$14913356525578* Cost

$16406822661708* Input

$17231618567710* Init data

$18430168550669* Result

$23494294864855* Min {unit}

$23854618911893* Simulated delay

$24632471752785* File

$26116781897961* Cost

$27295540163510* Input 1

$30447216087962* Shift

$31208530565026* Input 0

$32492998000365* Input 0


# com_static_eval's expression
$32721727081818* Expression

$34792822299047* Input 1

$36741466396909* Input 2

$39848783424235* Input

$39851490511821* Location mode

$40353371905977* Constant


# Load a level
$41294322771286* Load

$45584048068675* Input 1

$47647445869837* Zeroes

$48920514303805* Foundry

$49848147518867* Input 2

$50011261574308* Input 1

$50488075986026* Output

$52764622766005* Output

$53201813578269* Assembler

$55717355371460* Output

$56555605872372* Output

$58366024847549* Input 0

$58805963760936* Positive shifts right, negative shifts left

$59987930153159* Output

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

$61114700325299* Input 0

$64034551286307* Persistent

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

$65186041856822* Output

$65254105186908* Output

$65365515206856* Note: Although the component stores many key up & key down event, it only outputs one per cycle!

$69729205667293* Hex Editor

$70002762618597* Down

$71918065858983* Save

$75293122338496* Pipeline depth

$76078010638637* Enable

$76120552154698* Input 0

$76125262162505* Input 1

$77252050278971* Output

$78475032277779* Input 0

$80252365204151* Punch Card

$81678588906692* Halt message

$82521178851608* Input 0

$84542005958715* Label

$85815999713437* Input 1

$86658255589213* Mutable data

$88655619989708* Input 0

$88881918807029* Immutable

$89612128414294* Label direction

$90286330794518* Output

$91063734228931* Left

$95419083709418* Little endian

$95766090310621* Right

$97169317610794* Up



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

$24027424800887* Next level

$70403032472607* Well done! Let's go to the next level.

$80966247197959* Click the Input button in the upper left to enable the input.



=== presenter/board_ui/bottom_panel/nand_gate.nim ===

$32982011047799* Check

$43078933051174* Click any of the gray buttons in the last row of the table.

$61241226128494* Try again!

$71204033550134* What does the NAND gate do?



=== presenter/board_ui/bottom_panel/racer_question.nim ===

$95509904060545* Submit



=== presenter/board_ui/bottom_panel/solution_warning.nim ===

$21618236951146* View solution

$65770257567603* If you are sure you want to see the solution, press the button below.



=== presenter/board_ui/bottom_panel/user_defined_ui.nim ===

$10446152707984* Address

$20074247151096* Instruction

$41540713506719* Instruction

$64281970848639* Description



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

$10463931654475* Input 0

$14057674753878* Input 1

$58374689721038* BYTES

$73841752788709* Input

$74796974148718* Output



=== presenter/board_ui/component_menu/flat_list.nim ===

$70994998239232* Click on the NAND gate to select



=== presenter/board_ui/cycle_info.nim ===

$18403698792036* Level type

$41662660252584* Cursor

$53456282160464* Sandbox mode

$72245209470436* FPS

$74564675939961* Sim speed

$99534264629442* Test



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


# Placeholder on the name input field of the file explorer
$18871898542185* New folder

$56429258960561* Rename

$69090690657232* Clone


# Load a schematic
$70369485875359* Load


# Placeholder on the name input field of the file explorer
$84870575118100* New file

$91861509153454* Delete



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

$36396661222670* Right-click here to increase cycle speed

$39440928972984* Reset ({key})

$42454393978813* Click this button to run tests

$53448014080434* Delete (Hotkey: Right click)

$54853798559740* Run fast ({key}) (right click: change speed)

$66405942066048* Prev

$68617247634978* Bit size (right click: change size)

$69987793052607* Wire comment (Click on wire)

$78287906849040* Wire color

$80451578314373* Zoom in

$80746616574054* Next ({key}) (Right click for go to cycle)

$84434122873489* Zoom out

$85147529532131* Multi select (Hotkey: SHIFT & drag)



=== presenter/board_ui/io_state_view.nim ===


# MEMORY section title on the left panel
$13690653984793* Outputs


# MEMORY section title on the left panel
$34156015279634* Memory


# INPUTS section title on the left panel
$64033841051521* Inputs



=== presenter/board_ui/menu_bar.nim ===

$11731996208080* Foundry

$30516879701896* Sandbox

$33761197388580* View hints

$38557550573896* Level objectives

$50924073287410* Toggle number format

$56916384895438* Main menu

$71951682957395* Level map

$79554853897000* Switch schematic

$85248932172256* Exit hints

$85430022417382* Show delay

$91515053618360* Manual

$98930461722118* Back



=== presenter/board_ui/menu_bar_campaign.nim ===

$68227209887733* Foundry


# Placeholder for the search bar in the level tree
$72813322690589* Level search



=== presenter/board_ui/popup/address_jumper.nim ===


# OK button on popups
$26766209496460* Ok

$36265530817755* Jump to address

$40263691211335* offset in bytes (16, 0xF, ...)



=== presenter/board_ui/popup/assembler_watchee_linker.nim ===

$37885763626223* Link RAM

$51331074553774* How many registers

$67225915898937* Prefix

$67275059688693* Size

$77103446544344* Example: reg_

$77741358519166* Count



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

$19062117579269* Run to cycle: 



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

$16026817441460* cycles/sec



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

$52150443679969* Continue

$89787506720574* Close



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

$10090938799865*
[large]Manual Entry[/large]
Entry: [color=#68d277]{page}[/color]

$14047403461014* Energy (gate x time)

$16820079067437* Level Complete

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

$26794262854382* Discard

$30368115829346* Worst cycle

$32133561664335* Keep both

$33922330743421*
[b]Wire color[/b]
[color=#cccccc]Keep your wires organized with colors.[/color]

$40510295620397* Overwrite

$41649402437253*
[b]Negative numbers[/b]
[color=#cccccc]Toggle between signed
and unsigned numbers[/color]

$43462148240207* Instructions per cycle

$43591599177045* Energy (Gate x Delay)

$44038153424304* A save called "{save}" already exists

$45250062735373* Unlocks

$51096427131653* Onwards

$53037516781370* Save conflicts: 

$53389567901907* A custom component called "{comp}" already exists


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

$65428404547905* Stats


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


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

$69511102367948* Type

$72987046679863* Time (Delay x cycle)

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

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

$84923734370936* Worst test


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

$92313038380926* Level

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

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



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


# IDE tab name
$11106925604855* Files

$11967666262990* Spec error! Open the spec editor to fix it

$13400106910274* Line {nr}: {msg}


# IDE tab name
$88520918982355* Registers



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

$63693638857058* It contains {folders} folder(s).

$66107456188362* It contains {folders} folder(s) and {asm} .asm file(s).

$86093358515620* It is an empty folder.

$93027749509988* It contains {asm} .asm file(s).



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

$84832818424728* Files



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

$12944436882589* Add register



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

$10141348037745* Immediate: {nr}

$10366913897135* Click to toggle the bits

$14831276667273* Instructions


# The text above the 3 LSBs
$25145891843959* Always

$26521666422399* ALU

$31185395052385* OUTPUT


# The text above the 3 LSBs
$38497477227061* When [color=#e49f44]result {condition} 0[/color]


# The text above the 3 LSBs
$39935096343723* Never

$41846451178700* Move to {to} from {from}

$43723329256095* REG {nr}

$53665446068319* UNUSED

$54909668901048* Immediate


# The text below the byte
$59958585065722* When [color=#e49f44]result {condition} 0[/color], move [color=#DD6576][bold]REG 0[/bold][/color] to counter

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

$81322935207536* INPUT

$89294533225655* {operation} [color=#DD6576][bold]REG 1[/bold][/color] and [color=#DD6576][bold]REG 2[/bold][/color]

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

$92046368194170* Condition

$98983752580592* Move



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

$14436541903929* Architectures: {list}

$66392158413243* Are you sure you want to delete "{file_name}"?

$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 ===

$15827374884671* To parent folder

$19184997172542* Used in architectures

$23950941073542* Name

$32598300339944* <Share as new schematic>

$32645745463577* Used in components

$34084132835354* Visible in menu

$36200352866864* Last edit

$38755675398147* Use WOR

$54460367152653* Share

$62604042376934* Export

$74184088067843* Select

$84344684205464* Path

$87138477300432* BBCode, with [image] & [link] disabled

$87579936985765* Agree to use [link=`CC0`]CC0[/link] license

$95386916091656* Description



=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* Infer size from input

$61685569269160* Automatic

$70256730895162* Static value



=== presenter/board_ui/popup/wire_comment_editor.nim ===

$36027984716180* Wire comment



=== presenter/board_ui/racer_question.nim ===

$11176073682097* What is {number} in binary?

$13872783467999* What is {number} in signed binary?

$19099025738142* Start

$23959994711260* Ready to race?

$37093663674348* Level {x}

$41793938939207* Time out

$45532697833519* You made it to level {level}!

$56999237564848* {x} seconds left

$92057009138253* What is {number} in hex?



=== presenter/console.nim ===

$63321577947087* Press Enter to see manual



=== presenter/level_tree_ui.nim ===

$19508086025944* PROGRAMMING 2

$26276191141664* Use keyboard to pan

$35696974632265* Level map colors

$38100016313511* CPU ARCHITECTURE 2

$38843517090942* WORKING COMPUTER

$44937904689376* PROGRAMMING

$51337598329530* ARITHMETIC

$55841332003989* DECREASE DELAY TO PASS

$65362728703588* MEMORY

$75049509201775* BOOLEAN LOGIC

$81337533438394* Complete

$81707212583931* Available

$87420015169370* OPTIONAL COMPONENT LEVELS

$95146987030704* Locked

$95559333192525* CPU ARCHITECTURE



=== presenter/main_menu_ui/credits_page.nim ===

$15872341864658*
Sincere thanks to:

[b]Translators[/b]
{translators}

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

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

[b]Symphony game[/b]
Ettapp

[b]Soundtrack[/b]
{soundtrack}

$21717110565858* Credits



=== presenter/main_menu_ui/home_page.nim ===

$12639868461113* exit

$13921098180953* schematic hub

$15234594767991* credits

$16857608955464* sandbox

$32835651830157* profile

$49251062339706* options

$66967233942803* play campaign



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


# The hub schematic size
$15762392983604* Size:

$22639280459994* Downloading list...

$44524092309946* Loading...


# To download hub schematics
$55983490912314* Load

$61693098943939* Continue


# To delete hub schematics
$62589392744014* Delete


# To confirm deleting hub schematics
$66333328482057* Are you sure?


# The hub author
$71812400203030* By:

$76747661573536* Yes

$76770986264566* Search

$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.

$90731554079332* No schematics found



=== presenter/main_menu_ui/hub/filter.nim ===

$23829497228009* Type

$25536941657464* Components

$43488408276984* Popular

$56045953383535* Architectures

$70134513915163* Newly added

$77788981567936* Levels

$83319579232915* Order by

$87115430626073* My uploads



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

$13231048881956* Reset cycle

$15032124477918* Wire color 4

$20313704155593* Wire color 6

$21380256293472* Select all

$33884219481037* Pan right

$36372993787575* Wire color 1

$50610605761210* Redo

$52159578521318* Paste

$53266310714298* Control

$55156524671891* Wire color 5

$58334563411624* Undo

$58442122157391* Color wire

$60118970740682* Run

$64529333110609* Wire color 7

$66251711975517* Wire color 9

$67362258372706* Color wire cluster

$74309706297402* Copy

$76995246992803* Wire color 10

$77819900580235* Wire color 2

$78515694621006* Pan left

$78673220868687* Wire color 8

$78777350869870* Press new key

$80031998727851* Pan up

$83373647697807* Wire color 3

$86574817679356* Next cycle

$87273391208106* Wire color 0

$88236351843942* Rotate

$88238310953306* Cut

$93140495547084* Pan down

$96339976117958* Pipette wire

$96449970906640* Comment wire

$96601731563408* Open console



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

$12034378482152* Confirm reset?

$13442839894535* Wire animation speed

$15557473522933* Reset

$21908594290225* General

$23270083417453* Cancel

$24145565754506* Effects volume

$29594613477534* You must restart the game for the language change to take effect.

$30910326565868* Language

$49806848871093* Color blind mode

$54328660964287* Window mode

$55047615798435* Accessibility mode

$61172959716558* Save location

$67420270098223* Factory reset

$70994568832660* Delete all

$71208664264770*
This will delete all level solutions, custom components and architectures.
This CANNOT be undone.
Are you sure you want to do it?
This will close the game, it will reset once you start it again.

$93981778736076* Music volume

$95307230990123* Verilog mode



=== presenter/main_menu_ui/options/page.nim ===

$36195388998735* General



=== presenter/markup/markup.nim ===

$66207112287034* TIP



=== presenter/update_state_common.nim ===

$13327741293223* Input {nr}

$29169064199243* Output {nr}

$39906291838542* Cycle

$43118901497406* Delay

$70170261551278* Energy

$95192766583497* Gate



=== presenter/update_state_stream.nim ===

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


# Text on keyboard component
$41639816417947* Record when running


# Text on keyboard component
$61909856780806* Recording


# Text on keyboard component
$73297471730751* Not recording



=== presenter/user_input/board_io/action/none.nim ===

$10186190492148* ALT click to move wire head

$22780831606716* Load file

$26085882338208* Edit punch card

$38481453712356* Edit assembly

$64854367750357* Open hex editor

$80005228759908* Value here: 

$98772447663910* Link components



=== presenter/utilities.nim ===


# Switched Output is the name under 19513138880387
$12249248261034* You cannot solve this level without adding a 'Switched Output' component

$12256736989028* You have more than one probe in the same square.

$14665712485657* This custom component can not be used as it has no area.

$15549447390000* 2 input/output components are in the same square. The custom component will be unusable since 2 pins can't overlap.

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

$25337574230078* Two pins are on the same square.

$27322222841583* Short circuit between <> and <>

$29718660090112* Wrong answer

$32087108522443* Size pins may only connect to other size pins.

$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.

$47880883686501* Circular dependency - The output of a component leads back to its own input. See 'Circular dependency' in the manual.

$48909199348313* Tests passed, but your solution uses more than {max_delay} delay

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

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

$56798729463813* Level code broken.

$73948669941805* Tests passed, but your solution uses more than {max_gates} gates


# Switched Input is the name under 11278573510238
$95056157627313* You cannot solve this level without adding a 'Switched Input' component



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


# Fallback for component name on the left panel
$11467644007149* Counter {nr}


# Fallback for component name on the left panel
$11980538317261* Memory


# Fallback for component name on the left panel
$19471584538385* Input

$25272818268849*
[b]RECAP[/b]

Hopefully you noticed:
1. There is exactly 1 way to write each number in binary.
2. The value of each digit is always double of the previous digit.

$37319690622142* Good job, you reached level {current_level}.


# Fallback for component name on the left panel
$41936481068702* Counter


# Fallback for component name on the left panel
$42012207828907* Register


# Fallback for component name on the left panel
$44820775847452* Output

$87016829502381* Good job, you reached level {current_level}.


# Fallback for component name on the left panel
$87591753278764* Reg {nr}

$97450409600317*
[b]KEY TAKEAWAYS[/b]

1. To go between the negative and positive, you flip all the bits and add[nbsp]1.
2. If the highest bit is [T], the value is always negative.
3. The byte adder you built also works with signed numbers.
4. There is still only 1 way to write each number.


# Fallback for component name on the left panel
$97889215332379* Memory {nr}


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


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

$17985924005596* : {nr} 개의 회로도가 포함되어 있습니다.

$38011567415872* : 폴더가 비어 있습니다.

$51791491383290* : 사용자 정의 컴포넌트가 사용된 곳

$57790786178566* : 사용자 정의 컴포넌트: {list}

