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

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


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

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


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

$24291443495513* 24291443495513 Universal gates


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

$85674599929809* 85674599929809 Most Earthlings were giant reptiles last we were here. None of them were intelligent or polite enough to join the Galactic Federation.
$50956872142719* 50956872142719 XNOR Gate
$29396170535219* 29396170535219 Create the inverse XOR gate, known as XNOR.


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

$28070798445412* 28070798445412 Construct a circuit that outputs the same as the input, just delayed by 2 cycles.
$81657957055974* 81657957055974 Delayed Lines
$66914768639545* 66914768639545 This level introduces the Delay Line component. It takes its input and outputs it 1 cycle later.


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

$24866509692444* 24866509692444 Set


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

$36654581830314* 36654581830314 LSR
$57629598331916*
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]

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

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


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

$42755701050268* 42755701050268 Computer concepts


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

$35820332981557* 35820332981557 Implement the stack operations for Symphony


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

$61501859914469*
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.
$39874917169400* 39874917169400 Saving Gracefully
$13114757255411*
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.




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

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


=== campaign/assembly_programming/label.txt ===



=== campaign/symphony_decoder/ui.txt ===

$51036929729507* 51036929729507 Implement the Symphony decoder


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

$90664310835282*
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.

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


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

$81732613304305* 81732613304305 Instruction Decoder
$62355105651643*
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.
$44644153822563* 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.


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

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


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

$38755675398147* 38755675398147 Use WOR
$15827374884671* 15827374884671 To parent folder
$84344684205464* 84344684205464 Path
$87138477300432* 87138477300432 BBCode, with [image] & [link] disabled
$34084132835354* 34084132835354 Visible in menu
$32645745463577* 32645745463577 Used in components
$19184997172542* 19184997172542 Used in architectures
$54460367152653* 54460367152653 Share
$62604042376934* 62604042376934 Export
$87579936985765* 87579936985765 Agree to use [link=`CC0`]CC0[/link] license
$95386916091656* 95386916091656 Description
$36200352866864* 36200352866864 Last edit
$23950941073542* 23950941073542 Name
$74184088067843* 74184088067843 Select
$32598300339944* 32598300339944 <Share as new schematic>


=== campaign/decoder_1/label.txt ===



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

$12944436882589* 12944436882589 Add register


=== campaign/saving_gracefully/hint_solution.txt ===

$10919459809145* 10919459809145 So we place a Multiplexer to decide which value to write to the Delay Line


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

$21808795465233* 21808795465233 Circumference
$46884494321384*
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/symphony_4_immediates/ui.txt ===

$90023711394112* 90023711394112 Add immediate values to Symphony


=== campaign/saving_gracefully/hint_0.txt ===

$90057665917240* 90057665917240 Once you have the level requirements as a table, it should be a lot easier to solve.
$83682732712729* 83682732712729 Make a truth table for what should go into the Delay Line
$90652401745526* 90652401745526 In total you have 3 'inputs' to for this table which gives you 8 combinations
$61760299843073* 61760299843073 Consider the input to the Delay Line as the output for your table.
$14624167685294* 14624167685294 In this level you need to use 1 Delay Line
$52905927349424* 52905927349424 The inputs are the 2 level inputs AND the output of the Delay Line, as the output plays a role in its input


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

$53936374688885* 53936374688885 Opcode


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

$83123268362253*
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]

$14499217305520* 14499217305520 Counting Signals


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

$62556352127349* 62556352127349 Wire Spaghetti
$70083014183793* 70083014183793 Finally it is time for you to start building the [color=#e49f44]Symphony[/color] architecture!
$36086882016175*
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.
$83483553172261*
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*
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/any_doubles/meta.txt ===

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

[tip]Don't overthink this level.[/tip]
$81647833476822* 81647833476822 Double Detection


=== campaign/symphony_condition_test/label.txt ===

$25959617344671* 25959617344671 Flags
$13327132168076* 13327132168076 Result
$17010689474441* 17010689474441 Condition


=== campaign/overture_alu_1/label.txt ===



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

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


=== campaign/multiply/label.txt ===



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

$41184546203403*
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].




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

$65261628219716* 65261628219716 Edit the assembly on the RAM


=== campaign/bit_adder/ui.txt ===



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

$76398546711745* 76398546711745 ALU
$17602708328746*
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]


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

$73973243772156* 73973243772156 Expected a signed number literal
$25983481845150* 25983481845150 Expected '{symbol}', got EOF
$11064758781325* 11064758781325 Expected '"', ''', or '`' at the start of UI table cell content
$43326454052643* 43326454052643 Expected an U for unsigned or S for signed here
$22452670489981* 22452670489981 Expected a number literal
$33400766069212* 33400766069212 Expected an opening parantheses (one of '(', '[' or '{{'), got '{open}'
$19807940646400* 19807940646400 Expected one of {expected}, got {actual}
$49180229055343* 49180229055343 Expected a value
$66187706284192* 66187706284192 Expected ':' after the key
$12492443144951* 12492443144951 Expected a ',' or end of table
$56457570130031* 56457570130031 Invalid escape character '{nc}'
$64926004981217* 64926004981217 Invalid int literal
$71666516845083* 71666516845083 Expected an unsigned number literal
$73113688099439* 73113688099439 Expected one of {expected}
$22378976352410* 22378976352410 Line {num}: 
$51855228989260* 51855228989260 Invalid unsigned int literal
$13040813748160* 13040813748160 Expected a key
$44942745729831* 44942745729831 Invalid hex escape sequence
$75565287060042* 75565287060042 Unexpected EOF while parsing a string
$64743950507593* 64743950507593 Expected a list value
$10198498286711* 10198498286711 Unfinished escape sequence
$29112746104375* 29112746104375 Expected a bool here.
$33551107641907* 33551107641907 Int literal too big
$77089554485217* 77089554485217 Expected a size declaration here
$82386938622647* 82386938622647 Expected some character after the escape character '\\'
$36313699368590* 36313699368590 Invalid octal escape sequence
$72110029133381* 72110029133381 Expected {prefix}
$27682737127628* 27682737127628 Expected an opening quote (one of ", ' or `)


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

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


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

$13660841232898*
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].



=== presenter/main_menu_ui/home_page.nim ===

$13921098180953* 13921098180953 schematic hub
$49251062339706* 49251062339706 options
$32835651830157* 32835651830157 profile
$16857608955464* 16857608955464 sandbox
$15234594767991* 15234594767991 credits
$66967233942803* 66967233942803 play campaign
$12639868461113* 12639868461113 exit


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

$88550064597726* 88550064597726 Add jumps to Symphony


=== campaign/score/label.txt ===



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

$70777086019982* 70777086019982 Tool making and usage is key in the early evolutionary stages of developing intelligence.
$60317070264440* 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* 65498108564418 Byte NOT
$54090032127372* 54090032127372 "NOT" each bit of the byte input.
$79214241606407* 79214241606407 Our previous model of brain size being the main predictor of intelligence was naive.


=== campaign/the_bus/test.si ===

$46672500255781* 46672500255781 Output X should be Z.
$65293894030728* 65293894030728 Output X should be {val}.
$75577618213381* 75577618213381 Output Y should be Z.
$28173496384607* 28173496384607 Output Y should be {val}.
$69214136994673* 69214136994673 Forward the value from {source} to {destination}


=== campaign/byte_not/ui.txt ===



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

$10949534274977* 10949534274977 The bus
$25369396405852*
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/byte_asr/ui.txt ===



=== campaign/symphony_alu/meta.txt ===

$52048822283735*
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* 71902120982324 Symphony ALU


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

$18497022543669* 18497022543669 This solution is by no means the most elegant or optimal
$13880107359455* 13880107359455 That, though, is left as an exercise to the player!


=== presenter/board_ui/popup/word_size_editor.nim ===



=== campaign/symphony_11_functions/default.isa ===



=== campaign/symphony_decoder/label.txt ===

$26325060783055* 26325060783055 Argument A
$40584554497383* 40584554497383 Immediate Value
$67128656777473* 67128656777473 Destination
$48212238534381* 48212238534381 Instruction
$48506758479060* 48506758479060 Mode
$16402377924132* 16402377924132 Is Immediate
$26207217884026* 26207217884026 Opcode
$24747841106265* 24747841106265 Argument B


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

$15140861344476* 15140861344476 Select {select}


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

$16394937100308* 16394937100308 NOT Gate
$64052600264884*
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]

$56423993638708* 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.
$80163590000700* 80163590000700 Now that you unlocked the NAND gate, it is time for you to build a circuit yourself.


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

$51514522389782* 51514522389782 Observe how function calls work


=== campaign/second_tick/ui.txt ===



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

$58374689721038* 58374689721038 BYTES
$74796974148718* 74796974148718 Output
$10463931654475* 10463931654475 Input 0
$14057674753878* 14057674753878 Input 1
$73841752788709* 73841752788709 Input


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

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


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

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


=== campaign/any_doubles/label.txt ===



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

$80507287196650* 80507287196650 NEVER
$74974087807935* 74974087807935 ALWAYS


=== campaign/overture_2_alu/label.txt ===



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

$73589178770254* 73589178770254 Another way is comparing the difference with 0
$37315430614523* 37315430614523 09 < 11 so 09 - 11 < 0; 1100 > 1001 so 1100 - 1001 > 0


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

$75524550463342* 75524550463342 ADD r1 and r2 and store the result in r3.
$43876958520450* 43876958520450 Jump to r0 if r3 is not 0.
$64808551937719* 64808551937719 Jump to r0 if r3 is greater or equal to 0.
$18505654344513* 18505654344513 Jump to r0.
$71072332861445* 71072332861445 Do nothing.
$42577908074742* 42577908074742 Move %a to r0.
$75067212691206* 75067212691206 NOR r1 and r2 and store the result in r3.
$88048573834702* 88048573834702 Jump to r0 if r3 is greater than 0.
$21095867785396* 21095867785396 AND r1 and r2 and store the result in r3.
$26704206992933* 26704206992933 NAND r1 and r2 and store the result in r3.
$33850592701591* 33850592701591 SUB r1 and r2 and store the result in r3.
$24147817394058* 24147817394058 Jump to r0 if r3 is less than 0.
$58823897430160* 58823897430160 OR r1 and r2 and store the result in r3.
$48758564562305* 48758564562305 Jump to r0 if r3 is less or equal to 0.
$45432635426071* 45432635426071 Move a value to %a from %b.
$46599288949396* 46599288949396 Jump to r0 if r3 is 0.


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

$15039285047182* 15039285047182 Output should be {expected}.
$46433606967015* 46433606967015 Add 1 to {cycle}


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

$46932595269557* 46932595269557 Hub Preview


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

$60636366241019* 60636366241019 The value {a} is less than {b}
$67770115019509* 67770115019509 {a} < {b} is {result}
$18672872329218* 18672872329218 The value {a} is not less than {b}


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

$32183772878666* 32183772878666 History


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

$16809493892244* 16809493892244 To check if a binary number is negative, we just check if the sign bit is [T]
$70638453446538* 70638453446538 The rest of the conditions are just combinations of value = 0 and value < 0


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

$75138288162938* 75138288162938 You read the input {read_count} times, not {output}.
$39953782121467* 39953782121467 The last input was not 37!


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

$15378963142694* 15378963142694 Input 2


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

$87387306821265* 87387306821265 if and only if the input 0 is [T] AND input 1 is [F]
$81345258398584* 81345258398584 The truth table tells us that the output is [T]


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

$52976618691411* 52976618691411 Output should have been {char}, not {output}
$37137490280093* 37137490280093 You did not read character {character} from the string yet


=== campaign/and_gate_3/label.txt ===



=== campaign/saving_bytes/hint_solution.txt ===

$73980120059844* 73980120059844 We just make the byte version out of the "Saving Gracefully" level


=== campaign/xnor/label.txt ===



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

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


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

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


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

$22037524510182*
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/Turing complete/doc.txt ===

$38118080841071*
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.


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

$20456965663323* 20456965663323 Instruction Aliases
$41535895646297*
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_2_io/label.txt ===



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

$36308361121667* 36308361121667 Output not enabled.
$17521915837347* 17521915837347 Output should not be enabled.
$33411257451562* 33411257451562 Expected output: {value}.


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

$27747401844990* 27747401844990 You did it! I thought you were just this odd looking hairless ape creature, but you actually built a real computer! Amazing.
$85320707451673* 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.
$77166984247940* 77166984247940 Until this point all possible programs have been confined to running in order byte by byte.
$89085328104477*
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.
$59169726539090* 59169726539090 Turing Complete


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

$71118235828147* 71118235828147 The circular dependency can be complex, involving many different wires and components
$13967626449720* 13967626449720 Some even deceptive like this example, which may make sense in pure logic form


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

$36850349097673*
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.
$22440157378882* 22440157378882 Capitalize


=== campaign/any_doubles/ui.txt ===



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

$73447955210779* 73447955210779 Binary


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

$29662258275697*
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.




=== campaign/or_gate/ui.txt ===



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

$67744627518982* 67744627518982 coin
$64851396075477* 64851396075477 2 * instruction size = 8
$55263046326109* 55263046326109 hit wall -> cancel movement
$75937352730902* 75937352730902 0.5 second = 500_000_000 nano second = 0x0000_0000_1DCD_6500
$50501450979711* 50501450979711 robot up
$45301848117435* 45301848117435 ghost down
$16841324702501* 16841324702501 Robot
$29369794309677* 29369794309677 TODO: handle coin and empty differently
$38695844571056* 38695844571056 overflow
$35647670060017* 35647670060017 empty
$10169473219025* 10169473219025 1 second = 1_000_000_000 nano second = 0x0000_0000_3B9A_CA00
$25474902303790* 25474902303790 increment direction
$26430777268618* 26430777268618 robot down
$40959483784712* 40959483784712 robot right
$37647180126584* 37647180126584 draw robot on new position
$23344524651761* 23344524651761 update next cycle
$55673115734516* 55673115734516 padding to preserve 32 bits alignment
$25470599373421* 25470599373421 draw ghost on new position
$28230914387367* 28230914387367 coin
$33450896282702* 33450896282702 placeholder
$22405816552972* 22405816552972 direction
$50069163371185* 50069163371185 ghost left
$31647601023268* 31647601023268 Sprite addresses jump table
$72366220861688* 72366220861688 ghost up
$11549850182703* 11549850182703 y coord
$62236058044269* 62236058044269 [padding]
$73803385159414* 73803385159414 so the first value is 0
$61792431057747* 61792431057747 x coord
$34042928458359* 34042928458359 modulo 3
$33327526977497* 33327526977497 Ghost
$37230877526029* 37230877526029 ghost right
$36791496238134* 36791496238134 2 * instruction length = 8
$69893421560125* 69893421560125 robot left


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

$57603105454008* 57603105454008 Now do we have a component that mimics this behavior?
$49444546097133* 49444546097133 odd number + odd number = even number
$59534613718377* 59534613718377 odd number + even number = odd number
$28104365880572* 28104365880572 even number + even number = even number


=== presenter/board_ui/cycle_info.nim ===

$53456282160464* 53456282160464 Sandbox mode
$72245209470436* 72245209470436 FPS
$41662660252584* 41662660252584 Cursor
$99534264629442* 99534264629442 Test
$18403698792036* 18403698792036 Level type
$74564675939961* 74564675939961 Sim speed


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

$15531830527231* 15531830527231 r3
$78214997465973* 78214997465973 Counter
$47858891143005* 47858891143005 r2
$42538649427331* 42538649427331 Program
$17025449350330* 17025449350330 r5
$76878335565401* 76878335565401 r4
$59383212597903* 59383212597903 r0
$89909032864119* 89909032864119 r1
$57877356797542* 57877356797542 DoneCount


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

$10776402819741* 10776402819741 We measure the universe with numbers. So our machine must know how to count.
$19285770105090*
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* 64470174232265 Half Adder


=== campaign/byte_constant/label.txt ===



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

$78613176066303* 78613176066303 Integrating ALU
$13069282666558*
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]



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

$78199387512682*
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.



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

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


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

$16026817441460* 16026817441460 cycles/sec


=== campaign/symphony_1_nand/ui.txt ===

$21345632528660* 21345632528660 Build the foundation of the Symphony architecture


=== campaign/symphony_10_stack/default.isa ===



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

$49190016957852* 49190016957852 The truth table tells us that the OR gate is [T]
$29061908449874* 29061908449874 if and only if NOT both inputs are [F]


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

$63394282539727* 63394282539727 Add IO instructions to Symphony


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

$46035077948196* 46035077948196 What is log2 of a 2-bit non-zero binary number (i.e. 1, 2, or 3)?
$40521556880682* 40521556880682 One of the methods is to divide the problem:


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

$33181499064044* 33181499064044 Result should never be Z state
$73051402798264* 73051402798264 The correct output is {U1 result}


=== campaign/symphony_alu/ui.txt ===

$69427874681706* 69427874681706 Implement the Symphony ALU


=== campaign/ram_component/meta.txt ===

$14374127314134* 14374127314134 Little Box
$76851096880864* 76851096880864 Can you fit 4 bytes of memory in this limited space?
$68663841862704*
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]



=== campaign/odd_ticks/label.txt ===



=== campaign/counting_signals/label.txt ===



=== campaign/byte_equal/label.txt ===



=== campaign/counting_signals/ui.txt ===



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

$55155519654685* 55155519654685 Divide
$15513439442399* 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.


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

$39479426746559*
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.


=== campaign/not_gate/label.txt ===



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

$66258723258123* 66258723258123 We are experimenting with how backgrounds influence cognitive function in Earthlings.
$38198768813364* 38198768813364 Bit Inverter
$76209391067704* 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.
$53559965601096* 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.


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

$47348572622406* 47348572622406 Punchcard Programming
$23659479615536* 23659479615536 Now that you have built your first computer it is time to learn how to program it.
$12002017150690* 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.
$35877580485177*
35877580485177 Since both you and the dolphin built a computer, the competition for who gets to represent Earth at the Galactic Federation will go on until one of you drops out. 

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


=== campaign/nor_gate/ui.txt ===



=== campaign/nor_gate/label.txt ===



=== presenter/main_menu_ui/credits_page.nim ===

$15872341864658*
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* 21717110565858 Credits


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

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


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

$85571962806085* 85571962806085 Assembly


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

$30888506574129* 30888506574129 The orange wires implement the JUMP mode


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

$37740515704094* 37740515704094 This level is very similar to "Bit Switch"
$71057700033977* 71057700033977 But with A in place of Input 0 and B in place of NOT Input 0


=== campaign/decoder_2/ui.txt ===



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

$84654787309709* 84654787309709 {register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}
$74043498193765* 74043498193765 Output should have been {expected_output}, not {output_value}.
$40674051088628* 40674051088628 Screen setting 3 is supposed to be {expected_value}, not {value}
$68153781027719* 68153781027719 Persistent Memory address {i} is supposed to have value {expected_value}, not {value}
$81124009043205* 81124009043205 The 'zr' register should always be zero (address 0 in the 'Register File').
$55420494010123* 55420494010123 Main Memory address {i} is supposed to have value {expected_value}, not {value}
$56149980430079* 56149980430079 Output should have been enabled.
$34545926188340* 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* 35453700742253 The time component shouldn't have been enabled since the last time_0 instruction's execution.


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


# Placeholder on the name input field of the file explorer
$18871898542185* 18871898542185 New folder

# Placeholder on the name input field of the file explorer
$84870575118100* 84870575118100 New file
$69090690657232* 69090690657232 Clone
$56429258960561* 56429258960561 Rename

# Load a schematic
$70369485875359* 70369485875359 Load
$91861509153454* 91861509153454 Delete


=== presenter/user_input/board_io/action/none.nim ===

$98772447663910* 98772447663910 Link components
$80005228759908* 80005228759908 Value here: 
$38481453712356* 38481453712356 Edit assembly
$64854367750357* 64854367750357 Open hex editor
$22780831606716* 22780831606716 Load file
$26085882338208* 26085882338208 Edit punch card
$10186190492148* 10186190492148 ALT click to move wire head


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

$71000564779980*
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.
$46388374967041*
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.

$76392666043520* 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* 78836302049950 Mod 4


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

$11486015900582* 11486015900582 The keyboard


=== campaign/always_on/label.txt ===



=== campaign/overture_conditions/label.txt ===



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

$40553112323959* 40553112323959 You may not use more than 3 components in this level
$36609687959808* 36609687959808 {count} of 3


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

$24027424800887* 24027424800887 Next level
$80966247197959* 80966247197959 Click the Input button in the upper left to enable the input.
$70403032472607* 70403032472607 Well done! Let's go to the next level.


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

$81792554779622* 81792554779622 Build a 32 bit counter which increments by 4 each cycle


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

$80662783536910* 80662783536910 Short circuit


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

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


=== campaign/or_gate/label.txt ===



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

$73023200204536* 73023200204536 Counter should have value {expected_value}.
$50052313044113* 50052313044113 Output not enabled.
$88140381331491* 88140381331491 Expected output: {value}.
$19443898128380* 19443898128380 Output should not be enabled.
$49097812105667* 49097812105667 Register {reg_i} should have value {value}.


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

$85471608475185*
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]

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

[image="symphony_diagram_2.png"]
$46968415562883* 46968415562883 Immediates


=== campaign/count_leading_zeroes/label.txt ===



=== presenter/board_ui/popup/assembler_watchee_linker.nim ===

$67225915898937* 67225915898937 Prefix
$77741358519166* 77741358519166 Count
$67275059688693* 67275059688693 Size
$37885763626223* 37885763626223 Link RAM
$51331074553774* 51331074553774 How many registers
$77103446544344* 77103446544344 Example: reg_


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

$41138026161536*
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.
$13883461694525* 13883461694525 Instruction Decoder
$71911284169222*
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/count_leading_zeroes/hint_solution.txt ===

$62535209440079* 62535209440079 That, though, is left as an exercise to the player!
$81301599100070* 81301599100070 The simplest way is to single out the 0 case
$27675083487752* 27675083487752 This solution is by no means the most elegant or optimal


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

$68842379350661* 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].
$39605373706887* 39605373706887 Unsigned Less


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

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


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

$75719044675256* 75719044675256 ASCII encoding


=== campaign/xor_gate/label.txt ===

$22122562689406* 22122562689406 Output
$45326245069696* 45326245069696 Input


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

$68865507501612* 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.
$36846418389807* 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.
$65167079914703* 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.
$39082333495604* 39082333495604 NAND Gate
$50880631203389* 50880631203389 Correct! You have unlocked the NAND gate. Out of this fundamental building block, you will construct everything else in your computer.


=== campaign/saving_bytes/label.txt ===



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

$65712025748767*
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]
  
$40525671378957*
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* 47703565240245 Conditional Jumps
$38613585637577*
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.
$38150072401115*
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.


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

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


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

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


=== campaign/xor_gate/ui.txt ===

$38271404408184* 38271404408184 Current output


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

$19817843844200* 19817843844200 Nim
$47072576894526* 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*
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/decoder_3/meta.txt ===

$43603044118584* 43603044118584 3 Bit Decoder
$28695849165746* 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].


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

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


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

$37988524800638* 37988524800638 Binary Racer
$17561499905402* 17561499905402 This level is my favorite pastime. Converting decimal into binary under time pressure.
$78267067157141*
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.



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

$66359790889628* 66359790889628 De Morgan's laws


=== campaign/overture_alu_1/ui.txt ===



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

$22306447815263* 22306447815263 Optimize Overture


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

$27941792707668* 27941792707668 Add 5 to the input using assembly programming


=== campaign/signed_negator/hint_0.txt ===

$77523753173621* 77523753173621 A negative of a binary number can be obtained
$59964726775903* 59964726775903 by flipping its bits (byte NOT) and then adding one


=== presenter/board_ui.nim ===

$36331525379247* 36331525379247 Save this schematic


=== campaign/symphony_cmp/meta.txt ===

$37729390402296* 37729390402296 Comparison Flags
$64818361855764*
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_2_io/hint_solution.txt ===

$34652721020070* 34652721020070 The grey wires implement the IO mode


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

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


=== campaign/symphony_12_budget/label.txt ===



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

$81974422302188* 81974422302188 Manual


=== campaign/ram_component/hint_3.txt ===

$51887730294248* 51887730294248 Wire that up and the only thing left is to enable the right memory cell
$65959445914539* 65959445914539 The value to save to a cell comes from one input


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

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


=== presenter/update_state_stream.nim ===


# Text on keyboard component
$73297471730751* 73297471730751 Not recording
$12823129240050* 12823129240050 Click the upper-left button to link the screen

# Text on keyboard component
$61909856780806* 61909856780806 Recording

# Text on keyboard component
$41639816417947* 41639816417947 Record when running


=== campaign/double_buffer/label.txt ===



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

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


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

$13755587162128* 13755587162128 Input 2
$41149959264274* 41149959264274 Input 1
$12555311310864* 12555311310864 Input 0
$50183740481245* 50183740481245 Sum
$34717193596171* 34717193596171 Carry


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

$16215081868720* 16215081868720 Up until this point, we have worked only with bit, a signal of [T] or [F]
$13944257184132* 13944257184132 In this level, a byte, a group of 8 bits, is provided, so we must split and merge them


=== campaign/bit_switch/test.si ===



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

$65852115931553*
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.


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

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


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

$49706182840588* 49706182840588 Integrate the ALU into the circuit


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

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


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

$56387381898532* 56387381898532 Symphony Counter
$76860406179468*
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*
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_1_nand/label.txt ===



=== campaign/overture_alu_2/label.txt ===



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

$57134685411828*
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]



=== presenter/board_ui/menu_bar.nim ===

$79554853897000* 79554853897000 Switch schematic
$50924073287410* 50924073287410 Toggle number format
$71951682957395* 71951682957395 Level map
$85430022417382* 85430022417382 Show delay
$98930461722118* 98930461722118 Back
$85248932172256* 85248932172256 Exit hints
$91515053618360* 91515053618360 Manual
$38557550573896* 38557550573896 Level objectives
$33761197388580* 33761197388580 View hints
$56916384895438* 56916384895438 Main menu
$30516879701896* 30516879701896 Sandbox
$11731996208080* 11731996208080 Foundry


=== presenter/board_ui/component_menu/flat_list.nim ===

$70994998239232* 70994998239232 Click on the NAND gate to select


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

$54301125260332* 54301125260332 Memory is supposed to be {expected_memory}, not {memory_value}
$70376380014778* 70376380014778 Output should never be Z state
$84451713761977* 84451713761977 Output should be {expected_memory}


=== campaign/overture_3_immediates/label.txt ===



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

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


=== campaign/byte_less_u/label.txt ===



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

$83185064398279* 83185064398279 The foundry


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

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


=== campaign/bit_switch/ui.txt ===



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

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


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

$35910734851012* 35910734851012 {expected_value} is supposed to be on top of the stack, not {actual_value}.
$77129086767196* 77129086767196 You did not output the last popped value.


=== campaign/symphony_4_immediates/label.txt ===



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

$88124920557040* 88124920557040 Turing complete


=== campaign/byte_nand/label.txt ===



=== campaign/symphony_3_alu/label.txt ===



=== presenter/board_ui/bottom_panel/solution_warning.nim ===

$21618236951146* 21618236951146 View solution
$65770257567603* 65770257567603 If you are sure you want to see the solution, press the button below.


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

$45433710484419* 45433710484419 Expected a size before the number, like: U64 {number}
$18981788561705* 18981788561705 Expected whitespace here
$15585581119466* 15585581119466 Instruction '{instruction_name}' is missing the bit field definition
$71714150108621* 71714150108621 Error evaluating operand %{operand_name}: {err}
$57794055991905* 57794055991905 Error evaluating assert {assertion}: {err}
$82512572175623* 82512572175623 Unexpected end of instruction after {partial_instruction}
$60515742509356* 60515742509356 Expected a number after a size declaration
$48895355188042* 48895355188042 Expect a number literal after '@'
$59248806788382* 59248806788382 Cannot reference private label {name}
$62050046600010* 62050046600010 The file name {name} cannot be used as referencable alias, declare another alias using the keyword 'as', e.g. 'include .A as A'
$90294506138532* 90294506138532 Definition value must be either a number or a field
$60631582636278* 60631582636278 Undefined label {name}
$15728875852508* 15728875852508 Fail to parse {file}
$86607635528717* 86607635528717 Undefined constant {field_string}
$19581803133960* 19581803133960 Expected '{syntax}' after '{partial_instruction}'
$58979769991732* 58979769991732 Expected a new line after 'include'
$83649060120708* 83649060120708 Signed numbers are not supported
$66273157704409* 66273157704409 Missing a '{field_type}' operand here
$53378617686677* 53378617686677 Value {num} outside of range for {field}
$69537550553443* 69537550553443 Expected at least one whitespace character after '{partial_instruction}'
$84557608492963* 84557608492963 Unknown code found after instruction: 
$87525828760679* 87525828760679 Failed to resolve pattern ({err}): {resolved_pattern}
$47300717145684* 47300717145684 Missing '=' after 'const'
$33085034295813* 33085034295813 Expected either a number or a symbol
$83023561541280* 83023561541280 Was expecting a label name here
$67922577781529* 67922577781529 Only positive multiples of 8 bits are supported for now
$66575346967082* 66575346967082 File does not exist: 
$35210741057769* 35210741057769 Can't understand this line
$30066682696902* 30066682696902 Assert {source} did not match
$68530592279217* 68530592279217 Expected a valid operand name, got '{operand_name}' among {all_operand_names}
$51466436379956* 51466436379956 Can only pad forward, current address is at: {address}
$51460031660101* 51460031660101 Could not assemble instruction on resolving label {name}: {err}
$21828993759952* 21828993759952 Unknown instruction
$79977943868423* 79977943868423 '{field_string}' is not a '{field_type}'
$39195841380612* 39195841380612 Label {name} is already declared
$19131785861372* 19131785861372 Recursive inclusion of: 
$37770431994640* 37770431994640 Invalid instruction
$35071857261934* 35071857261934 Expected some whitespace after 'as'
$76017808702292* 76017808702292 The width of instruction '{instruction_name}' is {width} bits, but only multiples of 8 are supported
$12097260550100* 12097260550100 Value {num} outside of range for {field}
$42442531119863* 42442531119863 {constant_name} is already declared
$23413102374088* 23413102374088 Invalid instruction
$80097289956044* 80097289956044 Expected some whitespace between the size and the number, like U{size} {number}


=== campaign/symphony_cmp/test.si ===

$55730459238598* 55730459238598 Expected output: {a}{b}{c}.


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

$53593011909329* 53593011909329 Delicious order
$23043475637417* 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.
$79528307974753* 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/full_adder/meta.txt ===

$42735906141201* 42735906141201 Full Adder
$34381936755276*
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].


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

$34521278233301* 34521278233301 That, though, is left as an exercise to the player!
$43216513907358* 43216513907358 This solution is by no means the most elegant or optimal


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

$13079267765950*
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/Assembly/Language creation/Instructions/Operators/title.txt ===

$21043147057012* 21043147057012 Operators


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

$41856942338650* 41856942338650 Condition
$67613074322431* 67613074322431 Move
$71705253055197* 71705253055197 Immediate
$23393810721136* 23393810721136 ALU


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

$86131527203527* 86131527203527 This is where a decoder comes in handy
$73686127519870* 73686127519870 Then we need to decide on which memory cell to load from/save to


=== campaign/overture_1_registers/label.txt ===



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

$74552564780850* 74552564780850 Components spent


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

$84617036256734* 84617036256734 Current Sum
$49855734765642* 49855734765642 Desired Carry
$40317306745068* 40317306745068 Desired Sum
$51965136043073* 51965136043073 Current Carry


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

$50002893048555* 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.
$30005674935190*
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]
$21287008524643* 21287008524643 XOR Gate


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

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


=== presenter/main_menu_ui/hub/filter.nim ===

$23829497228009* 23829497228009 Type
$70134513915163* 70134513915163 Newly added
$87115430626073* 87115430626073 My uploads
$56045953383535* 56045953383535 Architectures
$77788981567936* 77788981567936 Levels
$25536941657464* 25536941657464 Components
$83319579232915* 83319579232915 Order by
$43488408276984* 43488408276984 Popular


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

$79378464416004* 79378464416004 Use the arrow keys to pick cards


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

$10248302990519* 10248302990519 There are {count} leading zeroes in {input_value} ({binary_value})
$46565705342966* 46565705342966 There is 1 leading zero in {input_value} ({binary_value})


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

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


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

$58149108600515* 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.
$10102035559374* 10102035559374 Program


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

$34091176621640* 34091176621640 This can be done using a byte XOR (remember XOR turns [T] when the inputs are not the same)
$38704349429368* 38704349429368 First determine which bits are different between the 2 bytes
$23270172293605* 23270172293605 so for each bit, use a chain of OR gates to check if any higher are [T]
$72421677239233* 72421677239233 We know the number that has the highest different bit [T] is the larger number
$45560562333305* 45560562333305 But we must only consider the highest different bit,


=== campaign/byte_adder/test.si ===



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

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


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

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


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

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


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

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


=== presenter/board_ui/popup/address_jumper.nim ===

$36265530817755* 36265530817755 Jump to address
$40263691211335* 40263691211335 offset in bytes (16, 0xF, ...)

# OK button on popups
$26766209496460* 26766209496460 Ok


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

$85502688597126* 85502688597126 Use the arrow keys to take cards
$64085588225039* 64085588225039 Hit enter to see what the oponent does
$90440029783715* 90440029783715 You took the last card
$42147812867053* 42147812867053 You won!
$49299754864790* 49299754864790 Hit enter to take {card_count} cards
$27262056315410* 27262056315410 You lost!
$29769682738867* 29769682738867 You may only take 1, 2 or 3 cards


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

$76027454955517* 76027454955517 A switch is very similar to an AND gate so let's replace them
$45466715038362* 45466715038362 Now we just need to eliminate the OR gate to stay within budget


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

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


=== campaign/ram_component/label.txt ===

$10655955073336* 10655955073336 Load
$46688176903674* 46688176903674 Address


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

$82470056393191* 82470056393191 Reg 0
$79357977314471* 79357977314471 Reg 3
$37075142107851* 37075142107851 Reg 2
$38743609381557* 38743609381557 Reg 1
$57061942907076* 57061942907076 Reg 5
$40362507068221* 40362507068221 Reg 4


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

$90884846016283* 90884846016283 The CARRY is [T] if and only if both inputs are [T]
$32998192994042* 32998192994042 The SUM requires the same reasoning from the "Odd Number of Signals" level


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

$54328660964287* 54328660964287 Window mode
$12034378482152* 12034378482152 Confirm reset?
$55047615798435* 55047615798435 Accessibility mode
$70994568832660* 70994568832660 Delete all
$93981778736076* 93981778736076 Music volume
$49806848871093* 49806848871093 Color blind mode
$61172959716558* 61172959716558 Save location
$95307230990123* 95307230990123 Verilog mode
$13442839894535* 13442839894535 Wire animation speed
$67420270098223* 67420270098223 Factory reset
$21908594290225* 21908594290225 General
$15557473522933* 15557473522933 Reset
$71208664264770*
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.
$23270083417453* 23270083417453 Cancel
$24145565754506* 24145565754506 Effects volume
$30910326565868* 30910326565868 Language
$29594613477534* 29594613477534 You must restart the game for the language change to take effect.


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

$71744044447857* 71744044447857 To check all bits are [F], we split the value into bits and apply a big NOR gate
$78036114842982* 78036114842982 Next, for value < 0, we check if a binary number is negative


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

$60992625993288* 60992625993288 {inp} mod 4 is {result}.
$13853243145042* 13853243145042 You must output the result before cycle 8!
$59240995307159* 59240995307159 Read the input first.


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

$20029422748716*
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.



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

$79162322081640* 79162322081640 keyboard
$28246040923235* 28246040923235 Register File
$18099138932731* 18099138932731 Persistent Memory
$80985404567327* 80985404567327 screen
$41903613959902* 41903613959902 Main Memory
$35059654572638* 35059654572638 time


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

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


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

$77115196290575* 77115196290575 Build the register circuit


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

$19520914707885* 19520914707885 [left]value ≥ 0 means NOT (value < 0)[/left]
$75072852663289* 75072852663289 [left]value > 0 means NOT (value ≤ 0)[/left]
$44207156733924* 44207156733924 [left]value ≤ 0 means (value < 0) OR (value = 0)[/left]


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

$75292456030647*
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"]
$60625429879527*
60625429879527 Orange pins never affect the output in the same cycle. They therefore never cause circular dependencies.

  [image="delay_line.png"]
$54648226811178* 54648226811178 Odd cycles
$17699211754487* 17699211754487 In a previous level you learned how we don't allow circular dependencies. Now you must learn the one exception.
$85913836277587* 85913836277587 Output [F] on the even cycles and [T] on the odd cycles.


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

$40303102766749* 40303102766749 Output 0
$56552908891774* 56552908891774 Output 1


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

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


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

$81327009436542* 81327009436542 But using an Add component here is an overkill!
$22938387275450* 22938387275450 Just add 1 to loop wire of the Delay Line


=== campaign/xnor/hint_0.txt ===

$89305883777750* 89305883777750 Notice how the XNOR gate output is the exact opposite of the XOR gate?


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

$11101940160071* 11101940160071 When the Action pin is [T], or Save, we want to overwrite it with Value
$19959785727663* 19959785727663 But doing that will cause a short circuit


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

$30858693828450* 30858693828450 So let's hook those up together with the bus
$41615813866999* 41615813866999 The Never and Always are the easier parts
$73479968135998* 73479968135998 Now, to check value = 0, we need to check all bits are [F]


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

$12621415211383* 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* 57911276445846 Signed Less


=== campaign/xor_gate/hint_solution.txt ===

$30671593085518* 30671593085518 This solution is by no means the most elegant or optimal
$16623524168613* 16623524168613 That, though, is left as an exercise to the player!


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

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


=== campaign/and_gate_3/ui.txt ===



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

$83417330967064* 83417330967064 The 'at least 2' part, we have already done in the "Double Detection" level
$12139411441713* 12139411441713 The output 1 is [T] if and only if at least 2, but not all 4, signals are [T]


=== campaign/bit_inverter/hint_0.txt ===



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

$17566441654249* 17566441654249 Shift


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

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


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

$64897298154598*
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.




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

$43585926436336* 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*
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*
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.
$41276257356528* 41276257356528 RAM
$73426457129430*
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/byte_asr/hint_0.txt ===

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


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

$68908249643417* 68908249643417 The truth table tells us that the NOR gate is [T]
$18962231551900* 18962231551900 if and only if both the input 0 AND input 1 are [F]


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

$19139933016995* 19139933016995 We don't have a subtraction component, only addition and negation
$15205448412655* 15205448412655 i.e. Input 0 ADD (NEG Input 1)
$56709208304109* 56709208304109 So we transform, for example, 1100 - 1001 to 1100 + (-1001)


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

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


=== presenter/level_tree_ui.nim ===

$95146987030704* 95146987030704 Locked
$26276191141664* 26276191141664 Use keyboard to pan
$75049509201775* 75049509201775 BOOLEAN LOGIC
$55841332003989* 55841332003989 DECREASE DELAY TO PASS
$19508086025944* 19508086025944 PROGRAMMING 2
$38100016313511* 38100016313511 CPU ARCHITECTURE 2
$65362728703588* 65362728703588 MEMORY
$44937904689376* 44937904689376 PROGRAMMING
$95559333192525* 95559333192525 CPU ARCHITECTURE
$35696974632265* 35696974632265 Level map colors
$81337533438394* 81337533438394 Complete
$38843517090942* 38843517090942 WORKING COMPUTER
$51337598329530* 51337598329530 ARITHMETIC
$81707212583931* 81707212583931 Available
$87420015169370* 87420015169370 OPTIONAL COMPONENT LEVELS


=== campaign/bit_adder/label.txt ===



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

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


=== campaign/decoder_1/test.si ===



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

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


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

$62793095496458* 62793095496458 Adding Bytes
$53076615315445* 53076615315445 Also, this level has a lot of tests. Right click on the run button to increase the testing speed.
$45061087867940*
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].
$31490345812891* 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.


=== campaign/the_bus/label.txt ===

$25477689162292* 25477689162292 Output select
$25535487507842* 25535487507842 A
$43474590938240* 43474590938240 Y
$47236089523392* 47236089523392 X
$43340511034957* 43340511034957 Input select
$65041743851294* 65041743851294 B


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

$39134024311972*
39134024311972 Add addition and subtraction to your circuit.

Instructions:

[color=#87a8c8]0 NAND
1 OR
2 AND
3 NOR
4 ADD
5 SUB[/color]
$20519420764551* 20519420764551 Arithmetic Logic Unit (ALU) 2


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

$24718289227251*
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.
$88436914545275* 88436914545275 Components can be added, renamed or deleted using the schematics menu.
$62612312608874* 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* 72171231322685 The Foundry


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

$86840165316981* 86840165316981 Right click to deselect the gate
$79416009887091* 79416009887091 Click anywhere on the board to place the gate
$55369640789869*
55369640789869 Click anywhere on the board to start a wire
Connect the red components to the NAND gate


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

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


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

$37690209655811* 37690209655811 You only need 8 full adders


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

$81923869207578* 81923869207578 Assembly programming


=== campaign/signed_negator/label.txt ===



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

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

To succeed you must learn to think logically, while not destroying things.
$72918877035793* 72918877035793 NOR Gate
$56653221050913* 56653221050913 Create the circuit that matches the table.


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

$88850298427736* 88850298427736 To that end, we note the additive property of shift,
$12195819154781* 12195819154781 i.e, shift of 3 is equivalent to shift of 1 + shift of 2
$28136552692253* 28136552692253 We can implement a version of this shift called barrel shifter


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

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


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

$12922292218235* 12922292218235 Bit Switch
$77268807700313* 77268807700313 Using 2 NOT gates and 2 Switches, build an XOR gate.
$88100823584262*
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.
$25663924496537*
25663924496537 
Alternatively to thinking of the output as being disconnected, it can be thought of as outputting neither [F] or [T], but a third state we call "Z state" [Z].

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

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

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



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

$67457044658869*
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* 78454657849319 IO Devices
$29247683714165*
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]



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

$29435797471674*
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.


=== campaign/ram_component/ui.txt ===

$27457656265551* 27457656265551 [color=#E49F44][b]Save [/b][/color]
$71008031461945* 71008031461945 [color=#E49F44][b]   Value   [/b][/color]
$62207646058430* 62207646058430 [color=#E49F44][b]Load [/b][/color]
$85306375920893* 85306375920893 [color=#E49F44][b]  Address  [/b][/color]
$27304327624610* 27304327624610 [color=#E49F44][b]State[/b][/color]
$22107475451139* 22107475451139 [left]Save ??? to ??[/left]
$62589960113273* 62589960113273 [color=#E49F44][b]Address[/b][/color]
$57378010777762* 57378010777762 [left]Load ??? from ??[/left]


=== presenter/board_ui/bottom_panel/foundry.nim ===



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

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


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

$11980470862173* 11980470862173 Byte NAND
$66454601163361* 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.
$52274910421610*
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]



=== campaign/symphony_alu/label.txt ===



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

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


=== campaign/signed_negator/ui.txt ===

$10529708471093* 10529708471093 Input


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

$24156270270079*
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.
$57043666310618* 57043666310618 I am not sure it benefits the students, but teachers love it.
$25862237357880* 25862237357880 Circular Dependency
$60783049086609* 60783049086609 In our education system we traditionally teach by tricking students into doing the wrong thing and then teasing them.


=== campaign/byte_not/label.txt ===



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

$17745932940157* 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.
$22469925230320* 22469925230320 Persistent Memory address {i} is supposed to have value {expected_value}, not {value}
$74663212299349* 74663212299349 Main Memory address {i} is supposed to have value {expected_value}, not {value}
$85916420035294* 85916420035294 Output should have been enabled.
$70740757119887* 70740757119887 {register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}
$21000091589999* 21000091589999 Output should have been {expected_output}, not {output_value}.
$29078414770160* 29078414770160 The 'zr' register should always be zero (address 0 in the 'Register File').
$60841927788704* 60841927788704 The time component shouldn't have been enabled since the last time_0 instruction's execution.


=== campaign/symphony_alu/test.si ===



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

$16562043259074* 16562043259074 Arithmetic Logic Unit (ALU) 1
$31234606133949*
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/the_bus/hint_0.txt ===

$42863588667057* 42863588667057 Use switches to put the inputs on the same wire


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

$85765173996083* 85765173996083 Increment the input by 1


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

$85119202720349* 85119202720349 IO
$66929200224494*
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)





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

$82513296271559* 82513296271559 Apply the same steps to reduce the problem from 8 bits to 4 bits
$12591714876491* 12591714876491 The only thing missing is the case when Input is 0


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

$18890527031365* 18890527031365 Count leading zeroes
$30557055303267*
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/byte_asr/label.txt ===



=== campaign/byte_asr/test.si ===



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

$16764912826624* 16764912826624 Code Breaker
$20948899837760*
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.


=== presenter/board_ui/racer_question.nim ===

$19099025738142* 19099025738142 Start
$13872783467999* 13872783467999 What is {number} in signed binary?
$56999237564848* 56999237564848 {x} seconds left
$92057009138253* 92057009138253 What is {number} in hex?
$23959994711260* 23959994711260 Ready to race?
$11176073682097* 11176073682097 What is {number} in binary?
$45532697833519* 45532697833519 You made it to level {level}!
$41793938939207* 41793938939207 Time out
$37093663674348* 37093663674348 Level {x}


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

$68315222097089*
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.

$29798404581087* 29798404581087 Stack
$90806029597852*
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/binary_programming/label.txt ===



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

$42632561737634* 42632561737634 Either way, the problem goes from 4 bits to 2 bits
$87709120049440* 87709120049440 If not, then the first [T] bit is somewhere in the highest 2 bits
$24472621996685* 24472621996685 If the number is less than 4, we can reduce the problem to 2-bit


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

$76434165550872*
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"]



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

$76244671092409* 76244671092409 Carry out
$45190053242926* 45190053242926 Carry in


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

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


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

$76705374584193* 76705374584193 Persistent Memory
$23620554597332*
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]


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

$20911185106374*
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* 90224867995967 Condition Match


=== campaign/byte_lsr/ui.txt ===



=== campaign/one_hot_encoding/label.txt ===



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

$69772243733094*
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




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

$68850421394935* 68850421394935 Counter
$51274378991709* 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.
$42949183679479*
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.


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

$73562005049347* 73562005049347 Moves input to reg 2
$41299869859669* 41299869859669 This is a comment
$80524429403045* 80524429403045 Click the spec.isa tab in the top left to see all instructions
$36228934755685* 36228934755685 Moves 15 to reg 0


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


# Fallback for component name on the left panel
$44820775847452* 44820775847452 Output

# Fallback for component name on the left panel
$11467644007149* 11467644007149 Counter {nr}
$25272818268849*
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.

# Fallback for component name on the left panel
$41936481068702* 41936481068702 Counter

# Fallback for component name on the left panel
$11980538317261* 11980538317261 Memory
$97450409600317*
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.
$37319690622142* 37319690622142 Good job, you reached level {current_level}.

# Fallback for component name on the left panel
$87591753278764* 87591753278764 Reg {nr}
$87016829502381* 87016829502381 Good job, you reached level {current_level}.

# Fallback for component name on the left panel
$19471584538385* 19471584538385 Input

# Fallback for component name on the left panel
$42012207828907* 42012207828907 Register

# Fallback for component name on the left panel
$97889215332379* 97889215332379 Memory {nr}


=== campaign/the_bus/hint_solution.txt ===

$86286155471986* 86286155471986 The purple wire in the middle is the BUS
$55189990966587* 55189990966587 Tweak the Multiplexer to share its input, instead of output, for the selective output


=== model/board/custom_prototype.nim ===


# Default new input pin name for custom compoennts
$14951951489108* 14951951489108 Input

# Default new output pin name for custom compoennts
$14864122622568* 14864122622568 Output


=== campaign/overture_alu_1/hint_0.txt ===

$69085851994491* 69085851994491 with the results of NAND, OR, AND and NOR replace Input A/B
$17808301775724* 17808301775724 This level is similar to "Multiplexer"


=== campaign/sandbox/meta.txt ===

$58382627590046* 58382627590046 The Sandbox


=== campaign/symphony_decoder/test.si ===

$31942264008156* 31942264008156 Arg B should be {b}.
$31544476297744* 31544476297744 Destination should be {dest}.
$82638458430252* 82638458430252 Arg A should be {a}.
$63089562267538* 63089562267538 'Is immediate' should be {immediate}.
$45701446129480* 45701446129480 Immediate value should be {immediate_value}.
$15174125339458* 15174125339458 Opcode should be {opcode}, not {actual_opcode}.
$64926808682290* 64926808682290 Mode should be {mode}.


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

$84590049728141* 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.
$35331465118106* 35331465118106 Overture
$59818810946218* 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".
$59797408403606*
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.
  


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

$75667038547709* 75667038547709 The information comes from the cycle count, this is where the Delay Line shines
$69947751578736* 69947751578736 The input is merely a distraction


=== campaign/double_buffer/ui.txt ===



=== campaign/byte_nand/ui.txt ===



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

$43384041502940* 43384041502940 Value
$11886599003881* 11886599003881 value
$81487261104241* 81487261104241 Condition
$38979555213581* 38979555213581 Description


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

$44716420394020* 44716420394020 Humble Beginnings
$76679675871478* 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.
$26182817405385*
26182817405385 Congratulations, you have been abducted.

We are testing you on our spaceship.

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


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

$61996387838431* 61996387838431 The purple wires implement the immediate mode


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

$16305942415014* 16305942415014 Action
$57018164959250* 57018164959250 Next desired output


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

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


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

$64973475823722* 64973475823722 The only component we have that has 'memory' is the Delay Line
$16548183735739* 16548183735739 It, however, only stores for 1 cycle, so we loop it into itself to keep refreshing it


=== campaign/byte_mod/label.txt ===



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

$67371980949119* 67371980949119 Language creation


=== presenter/main_menu_ui/options/page.nim ===

$36195388998735* 36195388998735 General


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

$17052191264122* 17052191264122 Lower the delay of Symphony


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

$64947954189801* 64947954189801 Create a component that can switch a signal between 2 pins.
$55345008240214* 55345008240214 1 Bit Decoder


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

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


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

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


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

$42610024611500* 42610024611500 Circuits


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

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


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


# The hub author
$71812400203030* 71812400203030 By:
$90731554079332* 90731554079332 No schematics found
$22639280459994* 22639280459994 Downloading list...
$76770986264566* 76770986264566 Search

# To download hub schematics
$55983490912314* 55983490912314 Load

# The hub schematic size
$15762392983604* 15762392983604 Size:

# To confirm deleting hub schematics
$66333328482057* 66333328482057 Are you sure?
$61693098943939* 61693098943939 Continue
$84668607423763* 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.

# To delete hub schematics
$62589392744014* 62589392744014 Delete
$44524092309946* 44524092309946 Loading...
$76747661573536* 76747661573536 Yes


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

$24524168624111* 24524168624111 Counter memory should be {expected_value}.
$45858569181521* 45858569181521 Your have read {.input_index} inputs, but you were supposed to have read {.emulator_input_index}.
$35224907301551* 35224907301551 Register {reg_i} should have value {value}.


=== campaign/symphony_9_aliases/default.isa ===

$47442552951774* 47442552951774 Store %value to address %adr in main memory.
$59344052643304* 59344052643304 Store %value to address %adr in persistent memory.
$54565380946620* 54565380946620 Compares %a and %b and store the result in the 'flags' register.
$46967848572964* 46967848572964 XOR %b and %c and store the result in %a.
$39857449355186* 39857449355186 Stores the value of %b in screen setting %a.
$37102964808364* 37102964808364 Compares %a and %b and store the result in the 'flags' register.
$90876214388280* 90876214388280 Jump to %a.
$44524771082050* 44524771082050 Loads an input and stores it in %a.
$71317192057126* 71317192057126 Jump to %a if the first value was greater (signed) than the second (reading results from 'flags').
$85822609095465* 85822609095465 Loads address %adr from main memory and stores it to %dest.
$29562677483890* 29562677483890 Store %value to address %adr in main memory.
$30574433901064* 30574433901064 OR %b and %c and store the result in %a.
$77040234358389* 77040234358389 Jump to %a if the first value was less (signed) or equal to the second (reading results from 'flags').
$31763492459833* 31763492459833 Jump to %a if the first value was below (unsigned) the second (reading results from 'flags').
$15915531259935* 15915531259935 Sends %a to output.
$89257021109854* 89257021109854 Loads address %adr from persistent memory and stores it to %dest.
$82087388048746* 82087388048746 Jump to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').
$67178948469318* 67178948469318 Jump to %a if the values were not equal (reading results from 'flags').
$88272577071256* 88272577071256 Does nothing.
$72551400437977* 72551400437977 Loads the lower four bytes of the time value and stores it to %a.
$77232719678109* 77232719678109 Loads address %adr from main memory and stores it to %dest.
$23349431010010* 23349431010010 ADD %b and %c and store the result in %a.
$16685334571248* 16685334571248 Logical shift right %b by %c and store the result in %a.
$74148826866592* 74148826866592 Jump to %a.
$11626177279992* 11626177279992 Jump to %a if the first value was above (unsigned) the second (reading results from 'flags').
$71637103729391* 71637103729391 Jump to %a if the first value was less (signed) than the second (reading results from 'flags').
$67019902294705* 67019902294705 Logical shift right %b by %c and store the result in %a.
$40732211165530* 40732211165530 OR %b and %c and store the result in %a.
$18254089726214* 18254089726214 Sends %a to output.
$19953421010778* 19953421010778 Store %value to address %adr in main memory.
$12835125621741* 12835125621741 Stores the value of %b in screen setting %a.
$46087142860391* 46087142860391 NOR %b and %c and store the result in %a.
$27219499692147* 27219499692147 Loads address %adr from main memory and stores it to %dest.
$67376584796076* 67376584796076 Loads the counter value and stores it to %a.
$13110303123442* 13110303123442 Store %value to address %adr in persistent memory.
$37333076617857* 37333076617857 NOR %b and %c and store the result in %a.
$42626144645228* 42626144645228 Arithmetic shift right %b by %c and store the result in %a.
$53499765587663* 53499765587663 Jump to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').
$27868418224252* 27868418224252 Loads keyboard input and stores it to %a.
$28652904157569* 28652904157569 SUB %b and %c and store the result in %a.
$67495552371225* 67495552371225 SUB %b and %c and store the result in %a.
$26183125927881* 26183125927881 Jump to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').
$61040780958703* 61040780958703 Store %value to address %adr in main memory.
$73559051740347* 73559051740347 Store %value to address %adr in main memory.
$86713121915282* 86713121915282 AND %b and %c and store the result in %a.
$69550893885320* 69550893885320 Store %value to address %adr in main memory.
$68219187873304* 68219187873304 Loads the upper four bytes of the time value and stores it to %a.
$75302656449127* 75302656449127 NAND %b and %c and store the result in %a.
$54577249258785* 54577249258785 Logical shift left %b by %c and store the result in %a.
$88180305667389* 88180305667389 Jump to %a if the values were equal (reading results from 'flags').
$69632418904622* 69632418904622 Loads address %adr from main memory and stores it to %dest.
$66785854415645* 66785854415645 XOR %b and %c and store the result in %a.
$86705346481666* 86705346481666 NAND %b and %c and store the result in %a.
$51030225266712* 51030225266712 ADD %b and %c and store the result in %a.
$23396316982953* 23396316982953 Loads address %adr from main memory and stores it to %dest.
$85679146831122* 85679146831122 AND %b and %c and store the result in %a.
$13576771671264* 13576771671264 Logical shift left %b by %c and store the result in %a.
$72280171778920* 72280171778920 Loads address %adr from persistent memory and stores it to %dest.
$57200935026773* 57200935026773 Loads address %adr from main memory and stores it to %dest.
$55551510150818* 55551510150818 Arithmetic shift right %b and %c and store the result in %a.


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

$65145204616501* 65145204616501 Add conditions to the circuit


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

$64065714320299*
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.


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

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


=== campaign/nand_gate/label.txt ===



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

$41513122622358* 41513122622358 Functions
$28617596738571*
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.

$64240772623662*
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.
$56028205797304* 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.
$42088257134737* 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.


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

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


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

$60698949860454* 60698949860454 ALU
$15645900189277* 15645900189277 Move
$90597971391617* 90597971391617 Immediate


=== campaign/decoder_2/label.txt ===



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

$16579770195459*
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.


=== campaign/signed_negator/test.si ===



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

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


=== presenter/board_ui/menu_bar_campaign.nim ===


# Placeholder for the search bar in the level tree
$72813322690589* 72813322690589 Level search
$68227209887733* 68227209887733 Foundry


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

$84832818424728* 84832818424728 Files


=== presenter/board_ui/io_state_view.nim ===


# MEMORY section title on the left panel
$13690653984793* 13690653984793 Outputs

# MEMORY section title on the left panel
$34156015279634* 34156015279634 Memory

# INPUTS section title on the left panel
$64033841051521* 64033841051521 Inputs


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

$88356074900046* 88356074900046 to create signal based on the cycle count
$14188568517859* 14188568517859 The Delay Line can be looped back into itself


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

$30599543511275* 30599543511275 An extension using 3-bit decoder instead of 2-bit
$61118397217284* 61118397217284 A SUB B is A ADD (NEG B)


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

$71972143734450* 71972143734450 Hex value


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

$60812617177494* 60812617177494 Do not use more than 3 components.
$74562193652628* 74562193652628 The output on pin {pin} is wrong.


=== campaign/or_gate_3/label.txt ===



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

$52150443679969* 52150443679969 Continue
$89787506720574* 89787506720574 Close


=== campaign/and_gate/label.txt ===



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

$63172000393911* 63172000393911 Select


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

$40415302067949* 40415302067949 either the input 0 is [T] AND input 1 is [F] OR the input 0 is [F] AND input 1 is [T]
$61125857472821* 61125857472821 The truth table tells us that the output is [T] if and only if


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

$68089739910654* 68089739910654 Bigger OR Gate
$29275887429601* 29275887429601 Create an OR gate with 3 inputs.


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



=== campaign/decoder_2/test.si ===



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

$46804407616321* 46804407616321 The lower byte of {a} * {b} is {result}
$83214947196979* 83214947196979 Multiply two numbers
$13790051293386* 13790051293386 {a} * {b} is {result}


=== model/translations.nim ===


# Million
$22896492410578* 22896492410578 M
$16391754618645* 16391754618645 {size} KB
$98703677236827* 98703677236827 1 minute ago
$18683857303458* 18683857303458 {size} bytes
$95018143828198* 95018143828198 1 year ago
$86244493049244* 86244493049244 {hours} hours ago
$21685594109067* 21685594109067 Just now

# Trillion
$87907122406742* 87907122406742 T
$98363990684104* 98363990684104 1 hour ago
$84076931764831* 84076931764831 1 day ago
$11567406591202* 11567406591202 1 byte
$18300496139706* 18300496139706 1 month ago
$17901039729248* 17901039729248 {months} months ago
$0*
0 
const DECIMAL_SEPARATORS* = {'_'}
const DECIMAL_DIGITS* = {'0' .. '9'}
const DIVIDER_TOKEN* = 
$42553566189409* 42553566189409 {minutes} minutes ago
$70945526841433* 70945526841433 {years} years ago

# Thousand
$84696693690500* 84696693690500 K

# Quadrillion
$49300594926837* 49300594926837 Q
$14036822471924* 14036822471924 {days} days ago

# Billion
$71072134093858* 71072134093858 B


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

$42740851915963* 42740851915963 Remaining power
$33479507858734* 33479507858734 Calculate 2 to the power 5
$27592840036827* 27592840036827 Second input is 5
$18457350783754* 18457350783754 First input is 2
$30769341721428* 30769341721428 Left hand side of the multiply
$63878589013500* 63878589013500 Keep multiplying until "remaining power" is 0
$42717933764735* 42717933764735 r1 and r2 are used for arguments, r1 is the function result
$27088227324511* 27088227324511 Remaining right hand side of the multiply
$21553876748933* 21553876748933 Accumulator
$70634976221207* 70634976221207 Push r3 so we can use it within the function but still restore it before returning
$59000482794872* 59000482794872 Should output 32
$43461252553161* 43461252553161 Calling convention:
$32724600358227* 32724600358227 Restore outside value
$21707356398727* 21707356398727 Load two numbers given from the level
$68500361393623* 68500361393623 Give names to registers to make things easier to read
$11016773181609* 11016773181609 The last multiply call already put the result in r1
$14412657671278* 14412657671278 Push r3 and r4 so we can use them within the function but still restore them before returning
$10902022971046* 10902022971046 Except for r1 and r2, a function should return with all registers having the original value
$65068280556611* 65068280556611 Restore outside values


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

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


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

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


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

$65391114076509* 65391114076509 Add 5 to the input using binary programming


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

$18477347795935*
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/Circular dependency/title.txt ===

$79928695804890* 79928695804890 Circular dependency


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

$60269032570207* 60269032570207 Expected output {expected_output}.


=== campaign/symphony_7_ssd/label.txt ===



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

$66501964970865* 66501964970865 The pseudo code for such an algorithm looks like this:
$18756407685566* 18756407685566 [left][b]Turn right as long as there is a wall ahead[/b][/left]
$60076150664554* 60076150664554 Always following the left (or right) hand side of the maze will make sure you eventually reach the exit
$10423837492124* 10423837492124 [left][b]Turn left[/b][/left]
$51767168505953* 51767168505953 [left][b]Repeat[/b][/left]
$63325960964451* 63325960964451 [left][b]Step forward[/b][/left]


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

$25938996008186* 25938996008186 with the source in place of Inputs and destination Outputs
$87908319845833* 87908319845833 This level is similar to "The Bus"


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

$56722492138232* 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*
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* 90660848232877 The Maze
$19088384441761*
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




=== campaign/saving_gracefully/ui.txt ===

$63465863198591* 63465863198591 Value
$10654649810679* 10654649810679 Save


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

$32912994842868* 32912994842868 Bigger AND Gate
$28751026881977* 28751026881977 Create an AND gate with 3 inputs.


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

$50319416070023* 50319416070023 Moves 5 to r0
$66946505646203* 66946505646203 You can load its offset like this
$67381454058237* 67381454058237 This is a label
$78380513477546* 78380513477546 Click the spec.isa tab to see the other jump instructions
$35642914965530* 35642914965530 Jumps to byte 5 of the program


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

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


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

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


=== campaign/odd_number_of_signals/label.txt ===



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

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


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

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


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

$80670337048058* 80670337048058 Up until this point, [F] has been treated as off, and [T] as on
$39747324204871* 39747324204871 But what if, instead of off/on, we imagine them as even/odd?


=== campaign/symphony_5_jumps/label.txt ===



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

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


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

$43200267887776*
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.


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

$17985924005596* 17985924005596 It contains {nr} schematic(s).
$66392158413243* 66392158413243 Are you sure you want to delete "{file_name}"?
$14436541903929* 14436541903929 Architectures: {list}
$68586106474430* 68586106474430 Note: all architecture levels share saves, so this will be deleted for all levels!
$51791491383290* 51791491383290 The custom component is used in
$38011567415872* 38011567415872 The folder is empty.
$89354977462546* 89354977462546 No
$57790786178566* 57790786178566 Custom components: {list}


=== campaign/symphony_counter_1/label.txt ===

$48990052180226* 48990052180226 Value
$42019997838216* 42019997838216 Overwrite
$41164574218692* 41164574218692 Count


=== campaign/symphony_6_ram/label.txt ===



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

$16731935541997*
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* 20753698232132 Negative Numbers
$87951492143019* 87951492143019 To know the difference between things, you need subtraction. To get subtraction, first you need negative numbers.


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

$68430971305988* 68430971305988 Bytes


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

$70892117360845* 70892117360845 AND Gate
$28388869498626* 28388869498626 Right now the elephant is dominating all the other test subjects from Earth. Adjusting for brain size, you are also doing well.
$18221128000007*
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]


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

$81322935207536* 81322935207536 INPUT
$92046368194170* 92046368194170 Condition

# The text above the 3 LSBs
$39935096343723* 39935096343723 Never
$41846451178700* 41846451178700 Move to {to} from {from}
$10366913897135* 10366913897135 Click to toggle the bits
$31185395052385* 31185395052385 OUTPUT

# The text above the 3 LSBs
$38497477227061* 38497477227061 When [color=#e49f44]result {condition} 0[/color]
$10141348037745* 10141348037745 Immediate: {nr}
$98983752580592* 98983752580592 Move
$43723329256095* 43723329256095 REG {nr}
$14831276667273* 14831276667273 Instructions

# The text above the 3 LSBs
$25145891843959* 25145891843959 Always
$67413863640193* 67413863640193 Never move [color=#DD6576][bold]REG 0[/bold][/color] to counter

# The text below the byte
$59958585065722* 59958585065722 When [color=#e49f44]result {condition} 0[/color], move [color=#DD6576][bold]REG 0[/bold][/color] to counter
$53665446068319* 53665446068319 UNUSED
$89294533225655* 89294533225655 {operation} [color=#DD6576][bold]REG 1[/bold][/color] and [color=#DD6576][bold]REG 2[/bold][/color]
$26521666422399* 26521666422399 ALU
$89662716409733* 89662716409733 Always move [color=#DD6576][bold]REG 0[/bold][/color] to counter
$54909668901048* 54909668901048 Immediate


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

$77234329031993* 77234329031993 Expected slice syntax after field/pattern reference in bit pattern
$61772889138477* 61772889138477 Expected a '(' before the pattern parameter list
$68066163358870* 68066163358870 Expected whitespace after 'when'
$50971737349470* 50971737349470 Pattern operands not supported in disassembly yet
$16564670893367* 16564670893367 Was expecting a pattern name here
$20574862674671* 20574862674671 Expected newline after virtual field
$72620639818015* 72620639818015 Expected newline after section header
$62103010038950* 62103010038950 Expected newline after section header
$27111936748508* 27111936748508 Expected a closing parenthesis after the pattern type
$25285447732570* 25285447732570 Expected top bound not to be less than bottom bound
$33504435568130* 33504435568130 Could not interpret virtual operand %{variable_name}: {err}
$32763965727763* 32763965727763 Sign extension bits do not match
$77851254343918* 77851254343918 No operand starts with character '{c}'.
$42160516340132* 42160516340132 Expected either '(' or '[' after the operand name, like: {variable_name}(immediate), {variable_name}[pattern()]
$58295598661589* 58295598661589 Description in patterns must be left empty
$63246722572594* 63246722572594 Expected slice syntax after field reference in bit pattern
$78591996283483* 78591996283483 Was expecting a field name or a sized immediate here
$26426549472884* 26426549472884 Too many virtual operands
$90809893168338* 90809893168338 Immediate operand must have size constraint, e.g. %a:U8(immediate).
$43708359021513* 43708359021513 Pattern must have a body
$18304638469397* 18304638469397 Expected a non-empty string to start line comments
$33890983338825* 33890983338825 Expected a list of strings
$48321097736953* 48321097736953 Expected hex number not to exceed 32767 digits
$33645913580119* 33645913580119 Too many field types, at most {max_field_types} are allowed
$18247681204565* 18247681204565 Expected ')' after assertion
$72958581072457* 72958581072457 Expected a name for the pattern
$56352157276583* 56352157276583 Operand value outside of {n}-bit signed range
$35053289858864* 35053289858864 Too many patterns, at most {max_patterns} are allowed
$48942522553057* 48942522553057 Expected slice syntax after field/pattern reference in bit pattern
$59877879891546* 59877879891546 Could not interpret 'when'-condition expression: {err}
$47258389995911* 47258389995911 Expected ',' between pattern parameters
$45267257140327* 45267257140327 Expected newline after section header
$62712568576067* 62712568576067 Duplicate field type name: {name}
$75146029145419* 75146029145419 Expected a name for the pattern parameter
$55444523984237* 55444523984237 Expected a closing parenthesis after the field type
$33105996916812* 33105996916812 Patterns can only invoke those defined before them
$67707174963301* 67707174963301 Expected an identifier after '%'
$52261961290701* 52261961290701 Flipped slice syntax after base-16 number reference in bit pattern
$63072912015761* 63072912015761 Expected newline before pattern body
$82876816015252* 82876816015252 Too many operand option paths for automatic disassembly, at most {num_path} are allowed
$76494975412451* 76494975412451 Expected a valid operand name, got '{operand_name}' among {all_operand_names}
$15904571494199* 15904571494199 Expected slice syntax after field/pattern reference in bit pattern
$20981379307111* 20981379307111 Fixed bits in %{operand} do not match
$55929094649794* 55929094649794 Expected a table of strings
$45631078896174* 45631078896174 Expected top bound not to exceed 32767
$64093416909416* 64093416909416 Expected an identifier after '%'
$40815956642962* 40815956642962 Expected slice syntax after base-16 number reference in bit pattern
$73627734748417* 73627734748417 Expected keyword 'pattern' before the pattern name
$29837913233106* 29837913233106 Expected newline between instructions
$87843223218582* 87843223218582 The width of the instruction is {width} bits, but only multiples of 8 are supported
$62334191081955* 62334191081955 Expected slice syntax after base-16 number reference in bit pattern
$81691406697268* 81691406697268 Expected top bound in slice syntax after field reference in bit pattern
$11703098452145* 11703098452145 Unknown setting name {name}
$42907704133778* 42907704133778 Expected a ')' after the pattern parameter list
$25249187420360* 25249187420360 Expected the name of an option or start of the next section
$52710717731997* 52710717731997 Was expecting a newline here after syntax declaration
$19678805612580* 19678805612580 Repeat field references do not match
$39427635035157* 39427635035157 Duplicate setting '{name}'
$59115040206693* 59115040206693 Expected a non-empty string to start block comments
$63957561177031* 63957561177031 Pattern '{pattern_name}' with {argument_count} parameters not defined
$11824708197936* 11824708197936 Expected a valid field/pattern name, got '{operand_name}'
$51752498682665* 51752498682665 Field name '{field_name}' not defined
$28197258085607* 28197258085607 Expected slice syntax after field/pattern reference in bit pattern
$48639756889210* 48639756889210 The width of the instruction cannot be 0
$55537815420873* 55537815420873 Expected ',' or ')' after pattern argument
$59388744207582* 59388744207582 Was expecting a newline at the end of the bit pattern
$77449878176461* 77449878176461 Expected an identifier after '%'
$23037984432484* 23037984432484 Expected ':' after 'when'-condition
$85972591916322* 85972591916322 Expected newline after setting assignment
$68533544457789* 68533544457789 Operand {variable_name} on syntax line shadowed another operand
$83804207975330* 83804207975330 Expected top bound not to exceed 32767
$79195048703101* 79195048703101 Expected an '=' here
$68462760531745* 68462760531745 The bit pattern of {field_name} is {actual} bits long, expected {expected}
$57773886232356* 57773886232356 Expected a name for the field type
$61352853872444* 61352853872444 Only immediates of width 0 to {max_field_size} are allowed
$70814401439344* 70814401439344 Expected top bound not to be less than bottom bound
$45247724910259* 45247724910259 Operand value outside of {n}-bit unsigned range
$79975911393070* 79975911393070 Expected slice syntax after field/pattern reference in bit pattern
$35468867558322* 35468867558322 Expected newline after section header
$67219559926029* 67219559926029 Field names can not contain whitespace characters
$55289908013299* 55289908013299 Virtual operand {variable_name} shadowed another operand on syntax line
$68587613470552* 68587613470552 Expected a field value name
$24713798894610* 24713798894610 Expected top bound not to exceed 32767
$31223930569837* 31223930569837 Expected top bound not to be less than bottom bound
$70205284263092* 70205284263092 Expected a non-empty string to end block comments
$40392382190976* 40392382190976 Expected a bit pattern for {field_name}
$72400465574342* 72400465574342 Only up to {max_field_width}-bit field lengths supported
$25123045290962* 25123045290962 Was expecting the [instructions] header here


=== campaign/symphony_8_io_devices/label.txt ===



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

$72990407719621* 72990407719621 Assembly Programming
$17226968214352* 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.
$73801373825270*
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/byte_xor/hint_0.txt ===

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


=== campaign/ram_component/test.si ===

$55086379351729* 55086379351729 Load {text_state} from {text_add}
$45179662026844* 45179662026844 Output should have been Z.
$52597500133853* 52597500133853 Save {text_value} to {text_add}
$29258463778822* 29258463778822 Output was Z, but it should have been {expected_value}.
$48251194975794* 48251194975794 Output was {actual_value}, but it should have been {expected_value}.


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

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


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

$11967666262990* 11967666262990 Spec error! Open the spec editor to fix it
$13400106910274* 13400106910274 Line {nr}: {msg}

# IDE tab name
$88520918982355* 88520918982355 Registers

# IDE tab name
$11106925604855* 11106925604855 Files


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

$49335074955899* 49335074955899 Adding on a bit level, we can simply use the Full Adder component
$56143546486508* 56143546486508 Similar to other byte components, we first break down the bytes to their bits


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

$69913560783046* 69913560783046 Second Cycle
$11961528105462* 11961528105462 Output [T] on the second cycle only.


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

$57764930098721* 57764930098721 Add immediates to the circuit


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

$32041142528569* 32041142528569 Subtracting from (2 - 1) = 1, there are 1 and 0 leading zero, respectively
$88044062357651* 88044062357651 Then how about 4-bit number?
$88309764896321* 88309764896321 If the number is less than 2, log2 is 0; otherwise, it is 1


=== campaign/double_number/ui.txt ===



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

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


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

$50803475056346* 50803475056346 Patterns


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

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


=== presenter/update_state_common.nim ===

$43118901497406* 43118901497406 Delay
$70170261551278* 70170261551278 Energy
$39906291838542* 39906291838542 Cycle
$29169064199243* 29169064199243 Output {nr}
$95192766583497* 95192766583497 Gate
$13327741293223* 13327741293223 Input {nr}


=== campaign/xnor/ui.txt ===



=== presenter/board_ui/bottom_panel/racer_question.nim ===

$95509904060545* 95509904060545 Submit


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

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


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

$20065838867866*
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.


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

$46518640933018* 46518640933018 But we have 8-bit unsigned inputs
$21199347421587* 21199347421587 To represent them in signed form, we must work with 9-bit bytes


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

$23614311904581* 23614311904581 Immediate Values
$63109056149876*
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/signed_negator/meta.txt ===

$15862778001173*
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* 54237470041206 Signed Negator


=== campaign/second_tick/label.txt ===



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

$11293872851403* 11293872851403 We can make a 9-bit custom component
$17291563256662* 17291563256662 Or we can break down NEG into NOT and ADD_1 to manipulate


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

$16820079067437* 16820079067437 Level Complete
$26794262854382* 26794262854382 Discard
$20801641140962*
20801641140962 [b]Level map mode[/b]
[color=#cccccc]Click "[color=#e49f44]Onwards[/color]" and you will see[/color]
$65428404547905* 65428404547905 Stats
$40510295620397* 40510295620397 Overwrite
$43591599177045* 43591599177045 Energy (Gate x Delay)
$44038153424304* 44038153424304 A save called "{save}" already exists
$69511102367948* 69511102367948 Type
$53389567901907* 53389567901907 A custom component called "{comp}" already exists
$84923734370936* 84923734370936 Worst test
$32133561664335* 32133561664335 Keep both

# This is a level kind, similar to Architecture, Programming & Component levels on the website
$58769207148712* 58769207148712 Component
$30368115829346* 30368115829346 Worst cycle
$10090938799865*
10090938799865 [large]Manual Entry[/large]
Entry: [color=#68d277]{page}[/color]
$92673421413755*
92673421413755 [b]Wire comments[/b]
[color=#cccccc]Add comments to your wires.[/color]
$51096427131653* 51096427131653 Onwards
$14047403461014* 14047403461014 Energy (gate x time)
$33922330743421*
33922330743421 [b]Wire color[/b]
[color=#cccccc]Keep your wires organized with colors.[/color]
$92313038380926* 92313038380926 Level
$41649402437253*
41649402437253 [b]Negative numbers[/b]
[color=#cccccc]Toggle between signed
and unsigned numbers[/color]

# This is a level kind, similar to Architecture, Programming & Component levels on the website
$90134890578411* 90134890578411 Misc
$53037516781370* 53037516781370 Save conflicts: 

# This is a level kind, similar to Architecture, Programming & Component levels on the website
$66101029228279* 66101029228279 Programming
$78783902500954*
78783902500954 [b]Online profile[/b]
[color=#cccccc]Find it in the main menu.[/color]
$45250062735373* 45250062735373 Unlocks
$72987046679863* 72987046679863 Time (Delay x cycle)

# This is a level kind, similar to Architecture, Programming & Component levels on the website
$69219742310717* 69219742310717 Architecture
$76805548224716* 76805548224716 Total RAM size is too high! This solution won't get scored on server.
$94261690850981*
94261690850981 [b]Hexadecimal[/b]
[color=#cccccc]Toggle between signed, unsigned and hex numbers[/color]
$43462148240207* 43462148240207 Instructions per cycle


=== campaign/introduction/label.txt ===



=== presenter/board_ui/popup/wire_comment_editor.nim ===

$36027984716180* 36027984716180 Wire comment


=== presenter/board_ui/bottom_panel/user_defined_ui.nim ===

$41540713506719* 41540713506719 Instruction
$64281970848639* 64281970848639 Description
$20074247151096* 20074247151096 Instruction
$10446152707984* 10446152707984 Address


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

$35186537961257* 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.
$57679157572023* 57679157572023 Logic Exam
$39721874026332* 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.
$39180730338379* 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.


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

$90593296729801* 90593296729801 Simplify the circuit


=== campaign/byte_lsr/test.si ===



=== campaign/overture_4_program/label.txt ===



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

$81427576809439*
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]
$29450953142176* 29450953142176 Tower of Hanoi
$72724057674158*
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.
$62636370223849*
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.
$23374750315066* 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.


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

$32103815380062* 32103815380062 Fields


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

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


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

$55357258069734* 55357258069734 Toggles the bits of %b and stores it in %a.
$72894099288447* 72894099288447 Negates a %b and stores it in %a.
$28545157055801* 28545157055801 Pushes %a on to the stack. This instruction is a synonym for:   sub sp, sp, 4   store_32 [sp], %a
$57788320241950* 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
$48332460366102* 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
$57504570243305* 57504570243305 Negates a value and stores it in %a.
$40508048121543* 40508048121543 Toggles the bits of a value and stores it in %a.
$34859363394334* 34859363394334 Moves a value to %a.
$53941960758392* 53941960758392 Moves a value to %a from %b.
$54469754973269* 54469754973269 Pops %a off the stack. This instruction is a synonym for:   load_32 %a, [sp]   add sp, sp, 4


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

$44918705544255* 44918705544255 Disable


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

$51703376131802* 51703376131802 Add load and store instructions to Symphony


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

$89678353617146* 89678353617146 Add persistent memory to Symphony


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

$86943286745277* 86943286745277 Divide the two numbers.


=== campaign/saving_bytes/ui.txt ===



=== campaign/one_hot_encoding/ui.txt ===



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

$22413958203952* 22413958203952 The truth table is just telling us to make an XOR gate
$46480779443140* 46480779443140 Let's first pretend the component constraint does not exist


=== campaign/the_bus/hint_1.txt ===

$88955803760495* 88955803760495 The selective input is just a Multiplexer


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

$19062117579269* 19062117579269 Run to cycle: 


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

$69821998974515* 69821998974515 Overwrite with {num}
$27837193789838* 27837193789838 Output should be {memory}.
$30050502504940* 30050502504940 Add 1


=== campaign/not_gate/ui.txt ===



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

$13757092116124*
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].
$61875924861326*
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].
$36376879506769* 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.
$87179643828952*
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]
$79626649565563* 79626649565563 Registers


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

$47075416850998* 47075416850998 This is true in general for modulo a power of 2, the lowest bit of a number
$81555476661504* 81555476661504 Now you just have to figure out how to get the last 2 digits of a number
$35037773638556* 35037773638556 Likewise, in decimal 4321 modulo 100 is also simple
$79521133202800* 79521133202800 (answer is 21, the higher digits are disregarded, because 100 is a power of 10)
$40190253854900* 40190253854900 In binary, taking modulo 4 of a number is the same as only using the two lower bits
$44666331884152* 44666331884152 This is because the higher bits represent 4, 8, 16 etc, and they all divide 4 with no remainder
$23027113131109* 23027113131109 represents that number modulo 2 (even or odd), the lowest 3 bits modulo 8 and so on


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

$85604588212035* 85604588212035 Count leading zeroes


=== campaign/byte_divide/label.txt ===



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

$18060272082456* 18060272082456 Auto size


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

$42664577834105* 42664577834105 Which means the lower circuit is subtly wrong, with both switches outputting [Z] when the inputs both are [F]
$80836475394613* 80836475394613 This allows their outputs to share wires without short-circuiting as long as at most 1 switch outputs something at any point
$47029050705615* 47029050705615 Incorrect output
$52307576546100* 52307576546100 Upper circuit/XOR
$16488212881433* 16488212881433 Lower circuit
$62622482229413* 62622482229413 Unlike an AND gate, when the 'Enable' pin is [F], the switch doesn't output [F], it outputs nothing at all.


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

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


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

$41958293329044* 41958293329044 Comparing 2 signed numbers is similar to comparing 2 unsigned numbers
$19896249626650* 19896249626650 If only one number has [T] for sign bit, that number is guaranteed to be lower
$14667194911431* 14667194911431 Only, the last bit is considered separately for signed numbers, here it has the opposite effect


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

$41975883966377* 41975883966377 Current output
$62797002040657* 62797002040657 Desired output
$29875779381032* 29875779381032 Value
$42809920196772* 42809920196772 Invert


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

$57225943470132*
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].
$39122914366346* 39122914366346 Jumps


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

$11260842500047* 11260842500047 We can implement a version of this shift called barrel shifter
$11228896363898* 11228896363898 i.e, shift of 3 is equivalent to shift of 1 + shift of 2
$55175982917102* 55175982917102 To that end, we note the additive property of shift,


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

$11499640163947*
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.


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

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


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

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


=== campaign/symphony_10_stack/label.txt ===



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

$83123414679662* 83123414679662 r2 should have had hex value 0xffffedcb.
$44683006232656* 44683006232656 The first instruction should have moved hex value 0x1235 to r1.
$67087756287234* 67087756287234 r3 should have had hex value 0x1234


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

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


=== campaign/the_bus/ui.txt ===

$31341803878224* 31341803878224 Create a circuit that forwards the value from a specified input to the specified output.


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

$87098190175913*
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.

$11327399415058* 11327399415058 This level is my second favorite pastime. Converting hexadecimal to binary under time pressure.
$45399195121692* 45399195121692 Hex Racer
$65517909958697*
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).


=== presenter/board_ui/bottom_panel/circular_dependency.nim ===

$16336401898647* 16336401898647 Test 1/2
$32314337981189* 32314337981189 Check
$13880985462901* 13880985462901 Make a circuit where the input of a component depends on its own output
$73467991035922* 73467991035922 Nope!
$89309211963063* 89309211963063 Test 2/2
$22446480186064* 22446480186064 Create a circular dependency involving at least 2 components


=== campaign/symphony_11_functions/label.txt ===



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

$10870388349665* 10870388349665 Expected output {cycle} to be [T] and other outputs to be [F]
$18073111523064* 18073111523064 Expected all outputs to be [F] since the disable bit is [T]


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

$46223188985873* 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.
$44276233109848* 44276233109848 2 Bit Decoder


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

$55162862394836* 55162862394836 Instruction
$35299017249605* 35299017249605 Desired mode


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

$84095392269624* 84095392269624 Modulo
$87605997307596* 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/preview_foundry/meta.txt ===

$78694087261378* 78694087261378 Hub Preview


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

$86940018019179* 86940018019179 Invalid identifier: %{operand}
$76203559781109* 76203559781109 Expected ']' or ':', got '{sep}'
$16677833364088* 16677833364088 Unrecognized identifier: %{operand}
$49919016022369* 49919016022369 Unrecognized address: ${identifier}
$50863314907270* 50863314907270 Expected ')'
$36919792698704* 36919792698704 Instruction pointer not available
$14037712136328* 14037712136328 Operand {op} not found
$62520916869207* 62520916869207 Expected ','
$18996202754936* 18996202754936 Expected ')'
$17795651801484* 17795651801484 Expected ':'
$15525193700799* 15525193700799 Unrecognized prefix operator 
$21791372106633* 21791372106633 Expected '('


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

$75546240775660* 75546240775660 Expected output: {value}.
$85392755740261* 85392755740261 Output should not be enabled.
$51132330915663* 51132330915663 Output not enabled.
$18540192543555* 18540192543555 Register {reg_i} should have value {value}.


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

$18968293717104* 18968293717104 One way is comparing digit by digit like we do for decimal numbers
$45223418140453* 45223418140453 Like 09 < 21 because 0 < 2, so 1100 > 1001 because 11XX > 10XX


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

$74639900282369* 74639900282369 unsigned {n}-bit immediate
$18299156828551* 18299156828551 signed {n}-bit immediate

# Assembly label
$17885987456433* 17885987456433 label
$12246885387560* 12246885387560 variable {name}


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

$44523532982427* 44523532982427 When the bit selector input is [F], output Byte A, otherwise output Byte B.
$66984132947598*
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* 75861961518456 Multiplexer


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

$80031998727851* 80031998727851 Pan up
$52159578521318* 52159578521318 Paste
$93140495547084* 93140495547084 Pan down
$50610605761210* 50610605761210 Redo
$88238310953306* 88238310953306 Cut
$13231048881956* 13231048881956 Reset cycle
$60118970740682* 60118970740682 Run
$78515694621006* 78515694621006 Pan left
$88236351843942* 88236351843942 Rotate
$58442122157391* 58442122157391 Color wire
$74309706297402* 74309706297402 Copy
$55156524671891* 55156524671891 Wire color 5
$78777350869870* 78777350869870 Press new key
$96339976117958* 96339976117958 Pipette wire
$33884219481037* 33884219481037 Pan right
$86574817679356* 86574817679356 Next cycle
$76995246992803* 76995246992803 Wire color 10
$21380256293472* 21380256293472 Select all
$53266310714298* 53266310714298 Control
$66251711975517* 66251711975517 Wire color 9
$96449970906640* 96449970906640 Comment wire
$87273391208106* 87273391208106 Wire color 0
$64529333110609* 64529333110609 Wire color 7
$77819900580235* 77819900580235 Wire color 2
$67362258372706* 67362258372706 Color wire cluster
$96601731563408* 96601731563408 Open console
$36372993787575* 36372993787575 Wire color 1
$58334563411624* 58334563411624 Undo
$15032124477918* 15032124477918 Wire color 4
$83373647697807* 83373647697807 Wire color 3
$78673220868687* 78673220868687 Wire color 8
$20313704155593* 20313704155593 Wire color 6


=== campaign/always_on/ui.txt ===



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

$21613887420121* 21613887420121 A simple circuit where the input depends on its own output is a looped NOT gate
$57091568089512* 57091568089512 Note the red erroneous wire
$64834808154176* 64834808154176 This is an error in other levels, but the goal of this one


=== campaign/symphony_3_alu/hint_solution.txt ===

$90347458725803* 90347458725803 The new orange wires feed the opcode to the ALU
$23277299590423* 23277299590423 Replace the NAND gate with the ALU component


=== campaign/byte_less_s/label.txt ===



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

$12955769263032* 12955769263032 Input
$23494294864855* 23494294864855 Min {unit}
$95419083709418* 95419083709418 Little endian
$39851490511821* 39851490511821 Location mode
$12729457392140* 12729457392140 {size} GB
$45584048068675* 45584048068675 Input 1
$36741466396909* 36741466396909 Input 2
$14913356525578* 14913356525578 Cost
$26116781897961* 26116781897961 Cost
$10792411581963* 10792411581963 {size} MB
$65254105186908* 65254105186908 Output
$50488075986026* 50488075986026 Output
$76120552154698* 76120552154698 Input 0
$50011261574308* 50011261574308 Input 1
$85815999713437* 85815999713437 Input 1
$14527438551030* 14527438551030 Input
$77252050278971* 77252050278971 Output
$32492998000365* 32492998000365 Input 0
$52764622766005* 52764622766005 Output
$12806857886815* 12806857886815 Bit 0

# com_static_eval's expression
$32721727081818* 32721727081818 Expression
$64695289448271* 64695289448271 The 8 bits of the value each turn on 1 of the 8 areas of the display.
$55717355371460* 55717355371460 Output
$40353371905977* 40353371905977 Constant
$89612128414294* 89612128414294 Label direction
$88655619989708* 88655619989708 Input 0
$12673774208656* 12673774208656 Bit 1
$31208530565026* 31208530565026 Input 0
$58805963760936* 58805963760936 Positive shifts right, negative shifts left
$53201813578269* 53201813578269 Assembler
$71918065858983* 71918065858983 Save
$49848147518867* 49848147518867 Input 2
$91063734228931* 91063734228931 Left
$69729205667293* 69729205667293 Hex Editor
$58366024847549* 58366024847549 Input 0
$76125262162505* 76125262162505 Input 1
$23854618911893* 23854618911893 Simulated delay
$97169317610794* 97169317610794 Up
$65186041856822* 65186041856822 Output
$76078010638637* 76078010638637 Enable
$90286330794518* 90286330794518 Output
$34792822299047* 34792822299047 Input 1
$47647445869837* 47647445869837 Zeroes
$82521178851608* 82521178851608 Input 0
$18430168550669* 18430168550669 Result
$48920514303805* 48920514303805 Foundry
$10634456248075* 10634456248075 Input 1
$78475032277779* 78475032277779 Input 0
$10967837475411* 10967837475411 Input 1
$88881918807029* 88881918807029 Immutable
$81678588906692* 81678588906692 Halt message
$60193172250813* 60193172250813 The setting you have chosen for this component will take up {size} of memory on your computer. Are you OK with this?
$17231618567710* 17231618567710 Init data
$59987930153159* 59987930153159 Output
$16406822661708* 16406822661708 Input
$95766090310621* 95766090310621 Right
$86658255589213* 86658255589213 Mutable data
$61114700325299* 61114700325299 Input 0
$30447216087962* 30447216087962 Shift
$75293122338496* 75293122338496 Pipeline depth
$27295540163510* 27295540163510 Input 1
$64034551286307* 64034551286307 Persistent
$24632471752785* 24632471752785 File
$13973719570693* 13973719570693 Size
$84542005958715* 84542005958715 Label
$80252365204151* 80252365204151 Punch Card

# Load a level
$41294322771286* 41294322771286 Load
$70002762618597* 70002762618597 Down
$65365515206856* 65365515206856 Note: Although the component stores many key up & key down event, it only outputs one per cycle!
$39848783424235* 39848783424235 Input
$56555605872372* 56555605872372 Output


=== campaign/symphony_cmp/ui.txt ===

$73310930628112* 73310930628112 Implement the Symphony flags


=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* 54189071002426 Add the ALU to Symphony


=== campaign/symphony/default.isa ===



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

$53269020658041* 53269020658041 The screen


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

$25269304368822*
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).




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

$77112891598455* 77112891598455 Multiply two numbers


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

$88637818475024* 88637818475024 Then we check a byte is 0 by checking all its bits are [F]
$85034261531833* 85034261531833 An XOR of 2 numbers is 0 if and only if they are equal


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

$71466914240996*
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* 83283206082997 Conditions


=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* 49596217848125 That, though, is left as an exercise to the player!
$55687805352825* 55687805352825 This solution is by no means the most elegant or optimal


=== campaign/saving_gracefully/label.txt ===

$88860903896097* 88860903896097 Save


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


# com_clz's input pin
$15988469904002* 15988469904002 Input

# com_maker_bit_8's name
$18747779812970* 18747779812970 Maker

# com_lsl's output pin
$14132199132916* 14132199132916 Result

# com_mux's output pin
$10003014068713* 10003014068713 Output

# com_maker_word_2's name
$14812135740513* 14812135740513 Word Maker

# com_maker_bit_8's output pin
$14889574903079* 14889574903079 Result

# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* 18160228892566 IO

# com_probe_memory_word's name
$18495107507052* 18495107507052 Memory Probe

# com_level_output_4_pin's input pin
$39260627694444* 39260627694444 Output 3

# com_probe_wire_asm's name
$53494192640542* 53494192640542 Disassembling probe

# com_ctz's input pin
$13829181406158* 13829181406158 Input

# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* 14485213322089 Verilog

# com_splitter_word_8's input pin
$11440186157356* 11440186157356 Input

# com_nand_word's name
$17989404583269* 17989404583269 NAND

# com_neg's description
$12021716182809* 12021716182809 Negates the input

# com_screen's input pin
$63216408139965* 63216408139965 Enable

# com_full_adder's input pin
$11264799740288* 11264799740288 Input 0

# com_splitter_word_2's output pin
$13625849577132* 13625849577132 Word 0

# com_maker_bit_8's input pin
$17957417956069* 17957417956069 Bit 3

# com_keyboard's output pin
$12465282633818* 12465282633818 Key value

# com_maker_word_8's input pin
$12616927929524* 12616927929524 Word 3

# com_nand_word's input pin
$11578787451669* 11578787451669 Input 1

# com_mux's input pin
$12687047365426* 12687047365426 Value 0

# com_register_word's late input pin
$13298317818150* 13298317818150 Save enable

# com_level_output_8_pin's input pin
$62385154489080* 62385154489080 Output 2

# com_xor_word's output pin
$10269927015049* 10269927015049 Result

# com_nor_word's output pin
$11938328576163* 11938328576163 Result

# com_splitter_bit_2's output pin
$10655485270988* 10655485270988 Bit 0

# com_xnor_word's output pin
$17089816656649* 17089816656649 Result

# com_nand_word's description
$10859914201083* 10859914201083 Bitwise NAND two values

# com_load_port's name
$16380513614754* 16380513614754 Load port

# com_lsl's input pin
$12849468178655* 12849468178655 Value

# com_nor_bit's description
$17510848535619* 17510848535619 [T] when neither inputs are [T]

# com_clz's output pin
$10092537578053* 10092537578053 Result

# com_probe_memory_bit's name
$12318534735397* 12318534735397 Memory Probe (bit)

# com_delay_line_word_config's description
$18447417990806* 18447417990806 Stores the input for 1 cycle

# com_splitter_word_8's output pin
$14592399073683* 14592399073683 Word 7

# com_static_eval's output pin
$89594489498667* 89594489498667 Result as value

# com_full_adder's input pin
$18480011054605* 18480011054605 Carry in

# com_time's description
$18774996925434* 18774996925434 Nano seconds since January 1st 1970

# com_register_bit's late input pin
$18405644304073* 18405644304073 Value

# com_concatenator_2's input pin
$18414950181373* 18414950181373 Wire 1

# com_splitter_word_4's output pin
$11345730126879* 11345730126879 Word 0

# com_cc_level_input's description
$19864966939331* 19864966939331 An input that will be converted to custom input, if the solution is saved to the foundry

# com_xor_word's description
$13236921580268* 13236921580268 Bitwise XOR two values

# com_splitter_word_8's output pin
$18541722201520* 18541722201520 Word 2

# com_mul's output pin
$11838813794006* 11838813794006 Result

# com_concatenator_8's input pin
$17908668221433* 17908668221433 Word 7

# com_nand_bit's name
$11130919681688* 11130919681688 NAND

# com_asr's output pin
$11521973612539* 11521973612539 Result

# com_maker_word_8's input pin
$18747558269936* 18747558269936 Word 7

# com_static_value's name
$17192199509688* 17192199509688 Static Value

# com_splitter_bit_8's output pin
$10491931394044* 10491931394044 Bit 3

# com_lsr's input pin
$16105779236896* 16105779236896 Value

# com_and_word's input pin
$11977039914327* 11977039914327 Input 0

# com_level_output_8_pin's input pin
$64999131838438* 64999131838438 Output 4

# com_delay_line_bit's description
$18206009264853* 18206009264853 Stores the input for 1 cycle

# com_level_input_3_pin's output pin
$65765566466116* 65765566466116 Input 0

# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* 14422565604875 Multi

# com_concatenator_8's input pin
$12341255296823* 12341255296823 Word 1

# com_concatenator_8's input pin
$11115698874478* 11115698874478 Word 0

# com_verilog_output's input pin
$19276197821142* 19276197821142 Input

# com_delay_line_word_config's name
$19421095581293* 19421095581293 Auto Delay Line

# com_decoder_3's output pin
$16637198920534* 16637198920534 Bit 1

# com_maker_bit_8's input pin
$10716205698752* 10716205698752 Bit 5

# com_delay_line_word's name
$17407828844862* 17407828844862 Delay Line

# com_level_output_counter's input pin
$89669851602178* 89669851602178 Output 2

# com_probe_wire_word's description
$15969687819995* 15969687819995 Display a value on your custom component or in the program editor

# com_less_s's description
$12765625016236* 12765625016236 Checks if the first input is less than the second one

# com_maker_bit_4's description
$18837875001662* 18837875001662 Merges 4 bits into one 4-bit value

# com_xnor_word's name
$12087865653212* 12087865653212 XNOR

# com_cc_level_output's description
$12051024347384* 12051024347384 A word output that will be converted to IO pin if level solution is saved as a component

# com_constant's description
$12424468899005* 12424468899005 Constant value

# com_decoder_2's name
$11727998752868* 11727998752868 2 Bit Decoder

# com_asr's name
$11034107377099* 11034107377099 Arithmetic Shift Right

# com_full_adder's output pin
$10918445419498* 10918445419498 Result

# com_splitter_word_4's input pin
$12938882109013* 12938882109013 Input

# com_splitter_bit_8's output pin
$18437214963047* 18437214963047 Bit 7

# com_neg's input pin
$11637742665554* 11637742665554 Input

# com_counter's output pin
$10629272823895* 10629272823895 Count

# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* 82535571951563 Misc

# com_mod's input pin
$17244932190980* 17244932190980 Divisor

# com_register_bit's output pin
$14834136969633* 14834136969633 Result

# com_delay_line_word_config's late input pin
$11320392055125* 11320392055125 Input

# com_cc_output's name
$10557704838301* 10557704838301 Output Pin

# com_level_output_3_pin's name
$16269858195218* 16269858195218 Output

# com_maker_bit_4's name
$11119510732154* 11119510732154 Maker

# com_static_indexer_config's output pin
$11132082500971* 11132082500971 Result

# com_concatenator_8's input pin
$12384635971036* 12384635971036 Word 5

# com_level_output_switched's description
$18319747827404* 18319747827404 Switched output

# com_decoder_3's input pin
$10755367544042* 10755367544042 Input

# com_keyboard's input pin
$18168295822085* 18168295822085 Read next

# com_push_button's name
$20020953885936* 20020953885936 Push Button

# com_splitter_bit_2's input pin
$12046095993506* 12046095993506 Input

# com_register_bit's description
$17670626909848* 17670626909848 1 bit of memory

# com_switch_bit's description
$16917313833836* 16917313833836 Toggles a bit

# com_segment_display's input pin
$14849689592952* 14849689592952 Value

# com_verilog_input's output pin
$13351141217116* 13351141217116 Input

# com_level_output_counter's name
$12247325526438* 12247325526438 Counter

# com_probe_wire_word's input pin
$14914933156268* 14914933156268 Value

# com_nand_bit's description
$12903183841172* 12903183841172 [T] unless both inputs are [T]

# com_maker_word_4's description
$15410415450178* 15410415450178 Merges 4 (n/4)-bit values into one n-bit value

# com_static_indexer_config's description
$85065774878853* 85065774878853 Advanced version of "static indexer". Shift and output size is inferred from the size of wires connected to input pins

# com_maker_word_4's input pin
$13236424504117* 13236424504117 Word 2

# com_lsr's input pin
$10335381544532* 10335381544532 Shift by

# com_level_input_2_pin's description
$14340334686746* 14340334686746 Two bit input

# com_div's output pin
$19403575811053* 19403575811053 Result

# com_screen's name
$12046117430308* 12046117430308 Screen

# com_decoder_2's output pin
$11297026031742* 11297026031742 Bit 2

# com_xnor_word's description
$15789912406647* 15789912406647 Bitwise XNOR two values

# com_static_indexer_config's name
$10289043699917* 10289043699917 Auto Static Indexer

# com_store_port's input pin
$18001316449428* 18001316449428 Address

# com_maker_bit_8's input pin
$13104890311933* 13104890311933 Bit 1

# com_mod's description
$10934212906097* 10934212906097 Modulo 2 numbers

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

# com_static_eval's description
$16874064281189* 16874064281189 Calculates a value before simulation (it becomes a constant during simulation)

# com_level_output_word's name
$11300749636961* 11300749636961 Output

# com_asr's description
$15194709458499* 15194709458499 Shifts bits to the right, while maintaining the sign of the number

# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* 19451948914812 Math

# com_level_input_switched's output pin
$69212597107829* 69212597107829 Input

# com_verilog_output's name
$12353364840899* 12353364840899 Verilog Output

# com_counter's description
$12736827510023* 12736827510023 Increments each cycle, unless overwritten

# com_maker_word_8's input pin
$12592072659210* 12592072659210 Word 1

# com_level_input_1_pin's name
$12746117288689* 12746117288689 Input

# com_level_gate's name
$11417416554850* 11417416554850 Level Component

# com_maker_bit_8's input pin
$14944669923906* 14944669923906 Bit 7

# com_level_output_4_pin's description
$18308856504509* 18308856504509 Four bit output

# com_decoder_1's name
$18250587600120* 18250587600120 1 Bit Decoder

# com_maker_word_4's input pin
$15232070727738* 15232070727738 Word 1

# com_level_output_3_pin's description
$13174121812559* 13174121812559 Three bit output

# com_xnor_word's input pin
$19329533997829* 19329533997829 Input 0

# com_add's output pin
$16559516323162* 16559516323162 Result

# com_maker_bit_8's input pin
$11634467729625* 11634467729625 Bit 4

# com_less_u's output pin
$15024221028085* 15024221028085 Result

# com_and_bit's name
$18912167455465* 18912167455465 AND

# com_level_input_3_pin's name
$10689623552857* 10689623552857 Input

# com_splitter_word_2's description
$15417695246232* 15417695246232 Splits a (2n)-bit value into two n-bit values

# com_splitter_word_2's input pin
$19630801846451* 19630801846451 Input

# com_concatenator_8's name
$16974631589430* 16974631589430 Concatenator

# com_static_value's output pin
$10920459933396* 10920459933396 Value

# com_and_word's name
$12926911335769* 12926911335769 AND

# com_switch_word's output pin
$11625195403324* 11625195403324 Output

# com_div's name
$14959426271423* 14959426271423 Divide

# com_less_s's output pin
$11019209691112* 11019209691112 Result

# com_ror's name
$12093087039542* 12093087039542 Rotate Right

# com_decoder_3's output pin
$18208851966397* 18208851966397 Bit 3

# com_nor_word's input pin
$10770218762282* 10770218762282 Input 0

# com_less_u's name
$13502755965496* 13502755965496 Low < (unsigned)

# com_concatenator_4's output pin
$16450922709110* 16450922709110 Result

# com_and_bit's description
$12719674432950* 12719674432950 [T] when both inputs are [T]
$87754378235471* 87754378235471 Output

# com_register_word's description
$13576980017857* 13576980017857 Small memory component

# com_concatenator_4's input pin
$13331778821779* 13331778821779 Word 0

# com_cc_level_output's name
$15625973306519* 15625973306519 Output

# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* 16656763610465 Outputs

# com_xor_word's input pin
$16674052164634* 16674052164634 Input 0

# com_level_input_4_pin's name
$11447837612693* 11447837612693 Input

# com_cc_input's description
$13263310288543* 13263310288543 Input pin

# com_level_output_word's description
$16148744080822* 16148744080822 Word output that will be converted to IO pin if level solution is saved as a component

# com_maker_word_8's name
$17581447274882* 17581447274882 Word Maker

# com_concatenator_8's description
$12443053648819* 12443053648819 Concatenates 8 values, the output width is the sum of all input widths

# com_xor_word's name
$16843812162355* 16843812162355 XOR

# com_register_word_config's input pin
$11057152094224* 11057152094224 Size

# com_cc_output's description
$10781578424003* 10781578424003 Output pin

# com_nor_word's description
$14517798310461* 14517798310461 Bitwise Nor two values

# com_store_port's name
$13159020985209* 13159020985209 Store port

# com_level_input_1_pin's output pin
$12465938629713* 12465938629713 Input

# com_not_bit's description
$10844421681709* 10844421681709 Inverts the input

# com_splitter_word_8's output pin
$19903808503639* 19903808503639 Word 1

# com_splitter_word_2's name
$12723870092766* 12723870092766 Splitter

# com_verilog_input's name
$19796166910463* 19796166910463 Verilog Input

# com_nand_word's output pin
$18604301487974* 18604301487974 Result

# com_level_gate's description
$13259215761047* 13259215761047 Used for creating level maps

# com_register_word_config's name
$17630501850089* 17630501850089 Auto Register

# com_rol's input pin
$13135722015590* 13135722015590 Rotate by

# com_splitter_word_8's name
$18008204445107* 18008204445107 Splitter

# com_switch_word's input pin
$12550214308917* 12550214308917 Value

# com_probe_memory_word's description
$12492235992906* 12492235992906 Display a value on your custom component or in the program editor

# com_not_word's input pin
$18100827224098* 18100827224098 Input

# com_concatenator_2's input pin
$12329350771997* 12329350771997 Wire 2

# com_verilog_input's description
$14408471620057* 14408471620057 Verilog input

# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* 10078663735607 Inputs

# com_or_word's output pin
$18599325743999* 18599325743999 Result

# com_xor_bit's description
$16856280609387* 16856280609387 [T] when inputs are different

# com_inc's name
$14456039381703* 14456039381703 Increment

# com_maker_word_2's output pin
$11293966912554* 11293966912554 Result

# com_ctz's description
$10231593934948* 10231593934948 Count 0s from the least significant digit until the first 1

# com_keyboard's output pin
$14338437722935* 14338437722935 Key down

# com_decoder_3's output pin
$12390018918095* 12390018918095 Bit 7

# com_splitter_word_4's output pin
$16099286786157* 16099286786157 Word 3

# com_add's name
$13973952772642* 13973952772642 Add

# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* 12972244522540 Displays

# com_level_output_4_pin's input pin
$16259545926196* 16259545926196 Output 0

# com_mul's description
$18631919890554* 18631919890554 Multiplies two inputs

# com_static_indexer_config's input pin
$12633414511976* 12633414511976 Size

# com_splitter_bit_4's name
$10524104374521* 10524104374521 Splitter

# com_concatenator_4's input pin
$18970466583796* 18970466583796 Word 2

# com_splitter_bit_8's output pin
$17163920171569* 17163920171569 Bit 6

# com_on's name
$15896157427528* 15896157427528 ON

# com_and_3_bit's name
$19664974941910* 19664974941910 3 Pin AND

# com_switch_word's description
$17345192339084* 17345192339084 Toggles a value

# com_splitter_bit_8's output pin
$13666042416530* 13666042416530 Bit 2

# com_cc_level_input's name
$16810631435170* 16810631435170 Input

# com_maker_bit_8's input pin
$14770992007366* 14770992007366 Bit 6

# com_concatenator_4's name
$15908922745328* 15908922745328 Concatenator

# com_level_output_switched's input pin
$11520072088720* 11520072088720 Enable

# com_splitter_word_4's description
$12370556827575* 12370556827575 Splits a (4n)-bit value into four n-bit values

# com_splitter_bit_8's output pin
$17664445405251* 17664445405251 Bit 5

# com_delay_line_bit's name
$12121899638400* 12121899638400 Delay Line

# com_decoder_3's output pin
$14688114733776* 14688114733776 Bit 5

# com_screen's input pin
$55023356915123* 55023356915123 Setting index

# com_counter's late input pin
$17764401720104* 17764401720104 Overwrite value

# com_decoder_2's description
$86848277190736* 86848277190736 Toggles between four outputs based on a 2 bit input pin

# com_probe_wire_bit's description
$15206117280094* 15206117280094 Display a value on your custom component or in the program editor

# com_mul's input pin
$14896244080868* 14896244080868 Input 0

# com_register_word's name
$16007777261800* 16007777261800 Register

# com_level_input_4_pin's output pin
$81933801309767* 81933801309767 Input 0

# com_level_output_4_pin's name
$10190739202646* 10190739202646 Output

# com_maker_bit_8's input pin
$17515061804367* 17515061804367 Bit 0

# com_splitter_word_8's output pin
$18425501753807* 18425501753807 Word 0

# com_decoder_3's name
$14375716460090* 14375716460090 3 Bit Decoder

# com_splitter_bit_4's output pin
$10111764008386* 10111764008386 Bit 2

# com_concatenator_2's output pin
$17758165407719* 17758165407719 Result

# com_level_output_8_pin's name
$13087193858087* 13087193858087 Output

# com_and_word's description
$11791872137683* 11791872137683 Bitwise AND two values

# com_level_output_counter's description
$19047791955795* 19047791955795 Three bit output

# com_ctz's output pin
$19883191600386* 19883191600386 Result

# com_mux's input pin
$15091015683874* 15091015683874 Select 0 / 1

# com_level_output_3_pin's input pin
$39908016538045* 39908016538045 Output 0

# com_ror's description
$10802217509530* 10802217509530 Rotates the bits of an input right

# com_div's description
$19251828025705* 19251828025705 Divide 2 numbers

# com_switch_word's name
$10611658692685* 10611658692685 Switch

# com_delay_line_word's description
$53901484249817* 53901484249817 Stores the input for 1 cycle

# com_maker_bit_4's input pin
$13826250945595* 13826250945595 Bit 3

# com_maker_word_2's description
$11048127331082* 11048127331082 Merges 2 (n/2)-bit values into one n-bit value

# com_or_word's description
$19406015796751* 19406015796751 Bitwise OR two values

# com_less_u's input pin
$16307028951926* 16307028951926 Input 1

# com_store_port's input pin
$18196820862263* 18196820862263 Enable

# com_register_word_config's late input pin
$19717901345023* 19717901345023 Save enable

# com_splitter_bit_8's output pin
$10688845521356* 10688845521356 Bit 1

# com_register_word_config's description
$19209488297941* 19209488297941 Automatically resizable version of the register

# com_level_output_word's input pin
$27680966493404* 27680966493404 Output

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

# com_level_output_switched's name
$19513138880387* 19513138880387 Switched Output

# com_probe_wire_asm's late input pin
$12365938365321* 12365938365321 Input

# com_ctz's name
$19218324472471* 19218324472471 Count trailing zero

# com_full_adder's output pin
$18410639135888* 18410639135888 Carry out

# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* 16684378975952 Custom

# com_load_port's output pin
$17988237627670* 17988237627670 Output

# com_time's name
$16011300295966* 16011300295966 Time

# com_level_input_3_pin's output pin
$79311371309532* 79311371309532 Input 1

# com_not_bit's name
$14453052824732* 14453052824732 NOT

# com_xor_bit's name
$14832952840086* 14832952840086 XOR

# com_lsr's description
$19394421220436* 19394421220436 Shifts the bits of an input right

# com_level_input_3_pin's description
$16604606953092* 16604606953092 Three bit input

# com_splitter_bit_8's output pin
$17053062486634* 17053062486634 Bit 4

# com_maker_bit_2's input pin
$11752209410617* 11752209410617 Bit 1

# com_maker_word_8's input pin
$19779691531031* 19779691531031 Word 5

# com_maker_bit_4's input pin
$17897455882076* 17897455882076 Bit 1

# com_splitter_word_4's output pin
$15360783001914* 15360783001914 Word 2

# com_load_port's input pin
$19069820293504* 19069820293504 Address

# com_asr's input pin
$12408847893200* 12408847893200 Shift by

# com_register_word_config's output pin
$84598344098990* 84598344098990 value

# com_screen's description
$19974317694842* 19974317694842 Configurable screen

# com_lsl's input pin
$19120200575252* 19120200575252 Shift by

# com_static_value's output pin
$15833633678405* 15833633678405 Bit size

# com_level_output_4_pin's input pin
$87954408093587* 87954408093587 Output 2

# com_level_output_8_pin's input pin
$38015555977208* 38015555977208 Output 3

# com_maker_word_8's input pin
$19740232065347* 19740232065347 Word 0

# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* 10495775939951 IO

# com_or_word's input pin
$11335506036805* 11335506036805 Input 1

# com_level_input_2_pin's name
$16870364449392* 16870364449392 Input

# com_level_output_counter's input pin
$86331851878040* 86331851878040 Output 1

# com_level_input_switched's input pin
$14935676453720* 14935676453720 Enable

# com_cc_input's name
$17814826739168* 17814826739168 Input Pin

# com_store_port's description
$17240636780043* 17240636780043 Add a store pin to a memory component

# com_level_input_3_pin's output pin
$42291627335021* 42291627335021 Input 2

# com_concatenator_4's input pin
$19277763516215* 19277763516215 Word 3

# com_asr's input pin
$18563543025377* 18563543025377 Value

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

# com_splitter_word_8's description
$15228522216068* 15228522216068 Splits an (8n)-bit value into eight n-bit values

# com_or_word's input pin
$15962339721851* 15962339721851 Input 0

# com_xor_word's input pin
$19719622211817* 19719622211817 Input 1

# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* 16316545288606 Logic

# com_ror's input pin
$13521735131997* 13521735131997 Rotate by

# com_splitter_bit_2's description
$18566798809283* 18566798809283 Splits a 2-bit value into 2 bits

# com_level_input_4_pin's output pin
$45891070331034* 45891070331034 Input 1

# com_level_input_2_pin's output pin
$55925432534232* 55925432534232 Input 1

# com_decoder_1's description
$16685462633615* 16685462633615 Toggles between two outputs

# com_static_value's description
$17781742628050* 17781742628050 Easily set values or width on individual custom components

# com_level_output_2_pin's name
$13255344581755* 13255344581755 Output

# com_xnor_word's input pin
$19579585753615* 19579585753615 Input 1

# com_load_port's input pin
$18399493738021* 18399493738021 Enable

# com_counter's late input pin
$16380665909610* 16380665909610 Overwrite

# com_maker_bit_2's description
$14531866237078* 14531866237078 Merges 2 bits into one 2-bit value

# com_delay_line_bit's late input pin
$43397945955203* 43397945955203 Input

# com_inc's input pin
$19579388993928* 19579388993928 Input

# com_inc's output pin
$15310910823919* 15310910823919 Result

# com_splitter_bit_8's input pin
$16196769003341* 16196769003341 Input

# com_splitter_bit_4's output pin
$15744234453408* 15744234453408 Bit 3

# com_cc_level_output's input pin
$17030391013189* 17030391013189 Output

# com_keyboard's output pin
$13705122401876* 13705122401876 Event waiting

# com_level_input_2_pin's output pin
$24473197268827* 24473197268827 Input 0

# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* 10507478984775 Dev

# com_probe_wire_bit's input pin
$10499689720024* 10499689720024 Value

# com_less_u's description
$18645721548287* 18645721548287 Checks if the first input is less than the second one

# com_level_output_switched's input pin
$17979647868788* 17979647868788 Output

# com_decoder_3's output pin
$15527856774069* 15527856774069 Bit 2

# com_splitter_word_4's name
$16563671560208* 16563671560208 Splitter

# com_mod's input pin
$11352468367638* 11352468367638 Dividend

# com_decoder_3's output pin
$17090003684860* 17090003684860 Bit 4

# com_switch_bit's name
$11574334638147* 11574334638147 Switch

# com_equal's output pin
$17864898529357* 17864898529357 Result

# com_probe_wire_bit's name
$19521764791439* 19521764791439 Wire Probe (bit)

# com_equal's name
$19369982838671* 19369982838671 Equal

# com_maker_word_8's input pin
$13378739117488* 13378739117488 Word 6

# com_register_word's output pin
$58518173140953* 58518173140953 Value

# com_concatenator_8's input pin
$11366501215506* 11366501215506 Word 2

# com_decoder_3's input pin
$16773243310913* 16773243310913 Disable

# com_decoder_2's output pin
$19275565166747* 19275565166747 Bit 0

# com_mux's input pin
$12520768681157* 12520768681157 Value 1

# com_full_adder's input pin
$11312161634667* 11312161634667 Input 1

# com_less_s's input pin
$15432695156488* 15432695156488 Input 0

# com_concatenator_8's output pin
$12478474747295* 12478474747295 Result

# com_maker_bit_2's output pin
$18060429242565* 18060429242565 Result

# com_concatenator_2's description
$10776829749898* 10776829749898 Concatenates 2 values, the output width is the sum of all input widths

# com_add's output pin
$10815269647822* 10815269647822 Carry out

# com_splitter_bit_2's output pin
$17293853955838* 17293853955838 Bit 1

# com_and_word's output pin
$16806711173957* 16806711173957 Result

# com_decoder_3's output pin
$13138546420646* 13138546420646 Bit 6

# com_splitter_word_8's output pin
$17425893786880* 17425893786880 Word 6

# com_concatenator_4's input pin
$12371272172145* 12371272172145 Word 1

# com_splitter_bit_8's description
$10488114435022* 10488114435022 Splits a byte into 8 bits

# com_maker_bit_8's description
$14338505460996* 14338505460996 Merges 8 bits into one byte

# com_register_word_config's late input pin
$18592599175225* 18592599175225 Save value

# com_splitter_word_8's output pin
$11465347976002* 11465347976002 Word 3

# com_splitter_bit_4's description
$16428357982878* 16428357982878 Splits a 4-bit value into 4 bits

# com_maker_word_2's input pin
$18365137610205* 18365137610205 Word 0

# com_level_output_4_pin's input pin
$29217965518477* 29217965518477 Output 1

# com_level_output_1_pin's input pin
$50802766489958* 50802766489958 Output

# com_splitter_word_4's output pin
$15566912320742* 15566912320742 Word 1

# com_or_bit's description
$13013154620359* 13013154620359 [T] when either input is [T]

# com_probe_wire_word's name
$14427436420428* 14427436420428 Wire Probe

# com_and_3_bit's description
$16839706221116* 16839706221116 3-input AND gate

# com_concatenator_8's input pin
$10080083255838* 10080083255838 Word 3

# com_level_output_counter's input pin
$84023157447564* 84023157447564 Output 0

# com_mul's name
$16549841656852* 16549841656852 Multiply

# com_level_output_8_pin's input pin
$39299381405096* 39299381405096 Output 0

# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* 16744990871521 Levels

# com_splitter_bit_2's name
$13766521376720* 13766521376720 Splitter

# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* 14686892562446 Memory

# com_or_word's name
$17053670145576* 17053670145576 OR

# com_level_input_word's output pin
$21448308897245* 21448308897245 Input

# com_keyboard's description
$16766452660421* 16766452660421 Records keypresses from your physical keyboard

# com_halt's description
$12990744955549* 12990744955549 Stops execution with a custom message

# com_neg's name
$18379907297327* 18379907297327 Negate

# com_clz's name
$11678932883790* 11678932883790 Count leading zero

# com_clz's description
$18865460617183* 18865460617183 Count 0s from the most significant digit until the first 1

# com_probe_wire_asm's late input pin
$18082830776248* 18082830776248 Address

# com_static_eval's output pin
$29937009351190* 29937009351190 Result as size

# com_concatenator_8's input pin
$19112189486457* 19112189486457 Word 6

# com_store_port's input pin
$17908666907710* 17908666907710 Store value

# com_level_output_8_pin's description
$41781588125341* 41781588125341 Four bit output

# com_equal's description
$15668435514829* 15668435514829 Checks if the two inputs are equal

# com_maker_word_8's input pin
$19068496076705* 19068496076705 Word 2

# com_level_output_8_pin's input pin
$72375982885383* 72375982885383 Output 1

# com_not_word's name
$11286216680410* 11286216680410 NOT

# com_concatenator_4's description
$15492861320167* 15492861320167 Concatenates 4 values, the output width is the sum of all input widths

# com_mod's name
$16223673009720* 16223673009720 Modulo

# com_full_adder's name
$17669928463861* 17669928463861 Full Adder

# com_maker_bit_2's input pin
$14834270613682* 14834270613682 Bit 0

# com_delay_line_word's late input pin
$12644592179746* 12644592179746 Input

# com_level_output_8_pin's input pin
$88250281919265* 88250281919265 Output 5

# com_cc_level_input's output pin
$59388037506003* 59388037506003 Input

# com_level_input_switched's description
$16797889673362* 16797889673362 Loads the input from levels

# com_xnor_bit's description
$10614106399129* 10614106399129 [T] when inputs are the same

# com_delay_line_word_config's input pin
$13271299225650* 13271299225650 Size

# com_switch_word's input pin
$12784430582183* 12784430582183 Enable

# com_nor_word's input pin
$19354802063529* 19354802063529 Input 1

# com_off's description
$12749460799924* 12749460799924 Always [F]

# com_add's description
$18429814030509* 18429814030509 Adds two inputs

# com_decoder_3's description
$61176454433312* 61176454433312 Toggles between eight outputs based on a 3 bit input pin

# com_counter's name
$18007194288764* 18007194288764 Counter

# com_screen's input pin
$88137790657923* 88137790657923 Value

# com_register_bit's name
$12678278048629* 12678278048629 Register

# com_maker_word_8's description
$15845204308823* 15845204308823 Merges 8 (n/8)-bit values into one n-bit value

# com_register_bit's late input pin
$17744526831576* 17744526831576 Enable

# com_maker_bit_2's name
$12602955212919* 12602955212919 Maker

# com_halt's name
$10351143139905* 10351143139905 Halt

# com_level_output_1_pin's name
$12242923444593* 12242923444593 Output

# com_on's description
$16212935718484* 16212935718484 Always [T]

# com_level_input_switched's name
$11278573510238* 11278573510238 Switched Input

# com_splitter_word_8's output pin
$19229992367375* 19229992367375 Word 5

# com_equal's input pin
$13859686951415* 13859686951415 Input 0

# com_ram's description
$19814732518166* 19814732518166 Large memory component

# com_or_3_bit's description
$17576327690867* 17576327690867 3-input OR gate

# com_level_output_8_pin's input pin
$90233476470983* 90233476470983 Output 7

# com_static_indexer's name
$19804933576629* 19804933576629 Static Indexer

# com_level_input_word's description
$11342065742485* 11342065742485 Word input

# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* 12778241216484 Bit

# com_or_bit's name
$17247779246257* 17247779246257 OR

# com_add's input pin
$17802619460312* 17802619460312 Carry in

# com_maker_bit_4's output pin
$18538545767544* 18538545767544 Result

# com_decoder_2's output pin
$15898724303882* 15898724303882 Bit 3

# com_inc's description
$11449663590476* 11449663590476 Increments the input by 1

# com_rol's name
$16755142829250* 16755142829250 Rotate Left

# com_level_input_4_pin's output pin
$36196915566111* 36196915566111 Input 3

# com_xnor_bit's name
$14079327237795* 14079327237795 XNOR

# com_rol's output pin
$19903955254861* 19903955254861 Result

# com_maker_bit_4's input pin
$14237744302250* 14237744302250 Bit 0

# com_delay_line_bit's output pin
$11945697622944* 11945697622944 Result

# com_mux's name
$15422378975821* 15422378975821 Mux

# com_static_eval's name
$16294314784377* 16294314784377 Static Evaluator

# com_concatenator_2's name
$17495243848605* 17495243848605 Concatenator

# com_not_word's output pin
$15635980858172* 15635980858172 Result

# com_div's input pin
$11611913368782* 11611913368782 Divisor

# com_load_port's description
$16440979564796* 16440979564796 Add a load pin to a memory component

# com_rol's input pin
$10762061266647* 10762061266647 Value

# com_level_output_3_pin's input pin
$17644027370563* 17644027370563 Output 2

# com_and_word's input pin
$18149321315676* 18149321315676 Input 1

# com_level_output_8_pin's input pin
$15649241608462* 15649241608462 Output 6

# com_lsr's output pin
$19748092068880* 19748092068880 Result

# com_or_3_bit's name
$19630419947500* 19630419947500 3 Pin OR

# com_level_output_2_pin's input pin
$18282543476901* 18282543476901 Output 0

# com_maker_word_4's name
$16610055905190* 16610055905190 Word Maker

# com_segment_display's description
$16761198694928* 16761198694928 Good for displaying numbers

# com_decoder_3's output pin
$19041825668970* 19041825668970 Bit 0

# com_full_adder's description
$17559382166174* 17559382166174 Adds 3 bits and outputs the sum and the carry

# com_not_word's description
$10624873506476* 10624873506476 Bitwise flip bits

# com_nand_word's input pin
$10425218359878* 10425218359878 Input 0

# com_maker_bit_4's input pin
$14852108377004* 14852108377004 Bit 2

# com_time's output pin
$18510923212418* 18510923212418 Nano seconds since Jan 1st 1970

# com_segment_display's name
$10582128204153* 10582128204153 7 Segment Display

# com_mul's input pin
$14913258317738* 14913258317738 Input 1

# com_maker_bit_8's input pin
$19209724501083* 19209724501083 Bit 2

# com_level_input_4_pin's output pin
$70142958857584* 70142958857584 Input 2

# com_keyboard's name
$10965596602414* 10965596602414 Keyboard

# com_lsr's name
$12931148241340* 12931148241340 Shift Right

# com_less_s's name
$15403981009644* 15403981009644 Less < (signed)

# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* 19169839564869 Probes

# com_off's name
$11860786587357* 11860786587357 OFF

# com_equal's input pin
$17767800149691* 17767800149691 Input 1

# com_level_input_word's name
$10943344093513* 10943344093513 Input

# com_neg's output pin
$12196354295621* 12196354295621 Result

# com_maker_word_4's output pin
$12262460678043* 12262460678043 Result

# com_add's input pin
$18009367936916* 18009367936916 Input 1

# com_splitter_bit_8's name
$11904470559153* 11904470559153 Splitter

# com_splitter_word_2's output pin
$13510688527850* 13510688527850 Word 1

# com_splitter_bit_4's input pin
$12060097589370* 12060097589370 Input

# com_maker_word_4's input pin
$15693531522415* 15693531522415 Word 0

# com_level_output_2_pin's description
$14875690243444* 14875690243444 Two bit output

# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* 16900787805858 Word

# com_level_output_2_pin's input pin
$44555908976270* 44555908976270 Output 1

# com_maker_word_4's input pin
$17742753106024* 17742753106024 Word 3

# com_concatenator_8's input pin
$15759275278695* 15759275278695 Word 4

# com_static_indexer's description
$16103423834548* 16103423834548 Shift the values on a wire by fixed amount at no delay or gate cost. Positive values shift right, negative shift left

# com_ror's output pin
$16261916666444* 16261916666444 Result

# com_nor_bit's name
$13375115196253* 13375115196253 NOR

# com_decoder_2's output pin
$10762093809413* 10762093809413 Bit 1

# com_mux's description
$11168613697835* 11168613697835 Toggles between two values

# com_probe_memory_bit's description
$16875362121056* 16875362121056 Display a value on your custom component or in the program editor

# com_static_indexer_config's input pin
$11349557191063* 11349557191063 Input

# com_delay_line_word's output pin
$40182352594863* 40182352594863 Result

# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* 75263091584586 Auto

# com_ram's name
$11710093917097* 11710093917097 RAM

# com_lsl's description
$16482114876737* 16482114876737 Shifts the bits of an input left

# com_maker_word_8's output pin
$11351867388170* 11351867388170 Result

# com_maker_word_2's input pin
$16178897760565* 16178897760565 Word 1

# com_nor_word's name
$12175906806727* 12175906806727 NOR

# com_less_s's input pin
$16118461327893* 16118461327893 Input 1

# com_level_input_1_pin's description
$13272198916233* 13272198916233 One bit input

# com_add's input pin
$17820183531095* 17820183531095 Input 0

# com_splitter_bit_4's output pin
$14645527447275* 14645527447275 Bit 0

# com_delay_line_word_config's output pin
$10757852071445* 10757852071445 Result

# com_verilog_output's description
$14973155280765* 14973155280765 Verilog output

# com_maker_word_8's input pin
$19579002124406* 19579002124406 Word 4

# com_static_indexer_config's input pin
$12869119410565* 12869119410565 Shift

# com_rol's description
$15557725551789* 15557725551789 Rotates the bits of an input left

# com_div's input pin
$18043895181775* 18043895181775 Dividend

# com_mod's output pin
$11329013865174* 11329013865174 Result

# com_splitter_word_8's output pin
$16120663256468* 16120663256468 Word 4

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

# com_lsl's name
$15268915597774* 15268915597774 Shift Left

# com_less_u's input pin
$14201184715010* 14201184715010 Input 0

# com_level_output_3_pin's input pin
$21084166025569* 21084166025569 Output 1

# com_level_output_1_pin's description
$18342586404936* 18342586404936 One bit output

# com_constant's name
$15858905835416* 15858905835416 Constant

# com_ror's input pin
$15762072154176* 15762072154176 Value

# com_splitter_bit_4's output pin
$17862413256378* 17862413256378 Bit 1

# com_level_input_4_pin's description
$19187328896214* 19187328896214 Four bit input

# com_register_word's late input pin
$12420839132846* 12420839132846 Save value

# com_splitter_bit_8's output pin
$11548514728473* 11548514728473 Bit 0


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

$63693638857058* 63693638857058 It contains {folders} folder(s).
$86093358515620* 86093358515620 It is an empty folder.
$66107456188362* 66107456188362 It contains {folders} folder(s) and {asm} .asm file(s).
$93027749509988* 93027749509988 It contains {asm} .asm file(s).


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

$62678678871254* 62678678871254 Add a program to the circuit


=== campaign/odd_ticks/ui.txt ===



=== campaign/and_gate/ui.txt ===



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

$31400969059429* 31400969059429 {register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}
$29909286517152* 29909286517152 The 'zr' register should always be zero (address 0 in the 'Register File').
$18975134592059* 18975134592059 Output should have been enabled.
$42960087865089* 42960087865089 Screen setting {i} is supposed to be {expected_value}, not {value}
$78917660933958* 78917660933958 Main Memory address {i} is supposed to have value {address}, not {value}
$46474751521062* 46474751521062 Link the screen to the "Main Memory" component (use the little red button in the corner of the screen).
$26871980917450* 26871980917450 Persistent Memory address {i} is supposed to have value {address}, not {value}
$41024505081324* 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.
$30816527015736* 30816527015736 Output should have been {expected_output}, not {output_value}.
$29202969341865* 29202969341865 Wrong time output (did you remember to cache the time on the time_0 instruction?)


=== campaign/byte_xor/label.txt ===



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

$69804974830322* 69804974830322 Connect the carry-in and carry-out of the level to complete the circuit
$36646953278480* 36646953278480 Carry-out of the last bit is the carry-in of the next


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

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


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

$64907157003500* 64907157003500 Negative numbers


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

$25715726162519* 25715726162519 Endianness


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

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


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

$13320201556243* 13320201556243 Create the ISA spec for the new instructions


=== campaign/symphony_2_io/ui.txt ===

$76620689360899* 76620689360899 Add IO mode to Symphony


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

$78963222298606* 78963222298606 And don't forget another switch to only output when LOAD is [T]
$51243843817679* 51243843817679 Using the [T] output of the decoder, we can enable the corresponding cell to load from


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

$17817215316423*
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.

$12296593054599* 12296593054599 One hot encoding


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

$78449227663032*
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).
$46697878992908* 46697878992908 Double the Number


=== presenter/markup/markup.nim ===

$66207112287034* 66207112287034 TIP


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

$15352671410916* 15352671410916 with 8 being the number of bits and log2 the position of the first [T] bit.
$75683304945175* 75683304945175 Except for when Input is 0, this is the same as finding 8 - 1 - log2(Input),
$83745112465243* 83745112465243 Finding log2 of binary numbers is very well-trodden ground in computer science


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

$78090021698706* 78090021698706 Settings


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

$27583144414493* 27583144414493 Instructions


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

$85147529532131* 85147529532131 Multi select (Hotkey: SHIFT & drag)
$78287906849040* 78287906849040 Wire color
$68617247634978* 68617247634978 Bit size (right click: change size)
$84434122873489* 84434122873489 Zoom out
$42454393978813* 42454393978813 Click this button to run tests
$80451578314373* 80451578314373 Zoom in
$36396661222670* 36396661222670 Right-click here to increase cycle speed
$66405942066048* 66405942066048 Prev
$39440928972984* 39440928972984 Reset ({key})
$53448014080434* 53448014080434 Delete (Hotkey: Right click)
$80746616574054* 80746616574054 Next ({key}) (Right click for go to cycle)
$69987793052607* 69987793052607 Wire comment (Click on wire)
$54853798559740* 54853798559740 Run fast ({key}) (right click: change speed)


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

$17025412277453* 17025412277453 Input 1
$84782011304318* 84782011304318 The truth table tells us that the output is [T] if and only if
$62308032073140* 62308032073140 either the input 0 is [T] AND input 1 is [F] OR the input 0 is [F] AND input 1 is [T]
$15534865654723* 15534865654723 Input 0
$59092390409834* 59092390409834 Desired output


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

$27417572090527* 27417572090527 Output not enabled.
$45837083894306* 45837083894306 Expected output: {value}.
$67011612338355* 67011612338355 Register {reg_i} should have value {value}.
$84026509534190* 84026509534190 Output should not be enabled.


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

$57024194971618*
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


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

$82564442776805* 82564442776805 Output not enabled.
$17793323757435* 17793323757435 Expected output: {value}.
$63497936956369* 63497936956369 Output should not be enabled.
$73489311755739* 73489311755739 Register {reg_i} should have value {value}.


=== presenter/console.nim ===

$63321577947087* 63321577947087 Press Enter to see manual


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

$39788606928520* 39788606928520 The circuitry for the 2's bit is what you did in "Double Detection", except when all 4 are on
$20653200546136* 20653200546136 The circuitry for the 1's bit is the same as what you did in the level "Odd Number of Signals"


=== campaign/bit_switch/label.txt ===



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

$82367602514282* 82367602514282 Delay


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

$41663630841312* 41663630841312 Saving Bytes
$87293777622656*
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/and_gate_3/hint_0.txt ===

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


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

$18258110894478* 18258110894478 This level unlocks your first manual page. This one is important, make sure you pay attention to it.
$61066799501731* 61066799501731 Always On
$85978749941194* 85978749941194 Create a circuit that is always [T].


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

$68182570848466* 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* 69806637130600 Fast Symphony


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

$79125097012724*
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]


$53539145017840* 53539145017840 ASR


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

$28574225028041* 28574225028041 Select A or B


=== campaign/symphony_cmp/label.txt ===



=== campaign/logic_gate_racer/label.txt ===



=== campaign/overture_5_conditionals/default.isa ===



=== campaign/saving_gracefully/test.si ===



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

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


=== campaign/double_number/label.txt ===



=== campaign/symphony_condition_test/ui.txt ===



=== presenter/utilities.nim ===

$56798729463813* 56798729463813 Level code broken.
$18997072674417* 18997072674417 <Component> is not unlocked in this level.
$32087108522443* 32087108522443 Size pins may only connect to other size pins.
$14665712485657* 14665712485657 This custom component can not be used as it has no area.
$47880883686501* 47880883686501 Circular dependency - The output of a component leads back to its own input. See 'Circular dependency' in the manual.
$45678915971282* 45678915971282 Short circuit inside <this> custom component.
$45545544521085* 45545544521085 A <component> is in an invalid position.
$48909199348313* 48909199348313 Tests passed, but your solution uses more than {max_delay} delay
$73948669941805* 73948669941805 Tests passed, but your solution uses more than {max_gates} gates
$29718660090112* 29718660090112 Wrong answer
$27322222841583* 27322222841583 Short circuit between <> and <>
$25337574230078* 25337574230078 Two pins are on the same square.

# Switched Input is the name under 11278573510238
$95056157627313* 95056157627313 You cannot solve this level without adding a 'Switched Input' component
$44947135063289* 44947135063289 Circular dependency - The output of a component leads back to its own input.
$51730362111148* 51730362111148 <This custom component> uses a {name} component not unlocked in this level.
$15549447390000* 15549447390000 2 input/output components are in the same square. The custom component will be unusable since 2 pins can't overlap.
$12256736989028* 12256736989028 You have more than one probe in the same square.
$51332486391182* 51332486391182 The critical path is inside this <custom component>.

# Switched Output is the name under 19513138880387
$12249248261034* 12249248261034 You cannot solve this level without adding a 'Switched Output' component
$42649958199625* 42649958199625 The level map was updated and your progress is out of order. Complete this <level> to fix it.


=== campaign/bit_inverter/label.txt ===



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

$39788153942181* 39788153942181 Truth tables


=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* 54982025748137 Infer size from input
$70256730895162* 70256730895162 Static value
$61685569269160* 61685569269160 Automatic


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

$34375498293137* 34375498293137 This level introduces efficiency scoring, which is based on time and energy.
$70169388789757*
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.
$59781832788691*
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.
$85893273691863* 85893273691863 Objective beauty
$40775045205647*
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.
$72877144436007*
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.
$38383835706006*
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.
$78375324732864*
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.


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

$24129473753872* 24129473753872 Read the input
$47357954866257* 47357954866257 *Assuming π ≈ 3


=== presenter/board_ui/bottom_panel/nand_gate.nim ===

$43078933051174* 43078933051174 Click any of the gray buttons in the last row of the table.
$71204033550134* 71204033550134 What does the NAND gate do?
$61241226128494* 61241226128494 Try again!
$32982011047799* 32982011047799 Check


=== campaign/symphony/label.txt ===



