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

$48843089545173* XThe new grey wires implement the interaction with the IO devicesX


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

$31456617450268* XMoves a value to %a from %b.X


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

$24291443495513* XUniversal gatesX


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

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


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

$28070798445412* XConstruct a circuit that outputs the same as the input, just delayed by 2 cycles.X
$81657957055974* XDelayed LinesX
$66914768639545* XThis level introduces the Delay Line component. It takes its input and outputs it 1 cycle later.X


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

$24866509692444* XSetX


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

$36654581830314* XLSRX
$57629598331916*
XTo 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]
X
$26791208073532*
XThe task in this level is to shift the first input to the right by the value given in the second input.
X
$83781539475221* XIn addition to giving you a shift right component, you also get a shift left component.X


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

$42755701050268* XComputer conceptsX


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

$35820332981557* XImplement the stack operations for SymphonyX


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

$61501859914469*
XThe 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.X
$39874917169400* XSaving GracefullyX
$13114757255411*
XIn 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.

X


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

$18136442036625* XWhat is 2π × {radius}?X


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



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

$51036929729507* XImplement the Symphony decoderX


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

$90664310835282*
XIn 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.
X
$18488351703350* XDo you know how we deterministic robots can be creative and produce original thoughts? The answer is random number generators.X
$83969937380086* XRandom Number GeneratorX


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

$81732613304305* XInstruction DecoderX
$62355105651643*
XTo 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.X
$44644153822563* XThe 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.X


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

$62779271315005* XCreate a circuit that XORs two bytes bitwise.X


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

$38755675398147* XUse WORX
$15827374884671* XTo parent folderX
$84344684205464* XPathX
$87138477300432* XBBCode, with [image] & [link] disabledX
$34084132835354* XVisible in menuX
$32645745463577* XUsed in componentsX
$19184997172542* XUsed in architecturesX
$54460367152653* XShareX
$62604042376934* XExportX
$87579936985765* XAgree to use [link=`CC0`]CC0[/link] licenseX
$95386916091656* XDescriptionX
$36200352866864* XLast editX
$23950941073542* XNameX
$74184088067843* XSelectX
$32598300339944* X<Share as new schematic>X


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



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

$12944436882589* XAdd registerX


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

$10919459809145* XSo we place a Multiplexer to decide which value to write to the Delay LineX


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

$21808795465233* XCircumferenceX
$46884494321384*
XIn 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.X


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

$90023711394112* XAdd immediate values to SymphonyX


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

$90057665917240* XOnce you have the level requirements as a table, it should be a lot easier to solve.X
$83682732712729* XMake a truth table for what should go into the Delay LineX
$90652401745526* XIn total you have 3 'inputs' to for this table which gives you 8 combinationsX
$61760299843073* XConsider the input to the Delay Line as the output for your table.X
$14624167685294* XIn this level you need to use 1 Delay LineX
$52905927349424* XThe inputs are the 2 level inputs AND the output of the Delay Line, as the output plays a role in its inputX


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

$53936374688885* XOpcodeX


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

$83123268362253*
XThe 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]
X
$14499217305520* XCounting SignalsX


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

$62556352127349* XWire SpaghettiX
$70083014183793* XFinally it is time for you to start building the [color=#e49f44]Symphony[/color] architecture!X
$36086882016175*
X
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.X
$83483553172261*
XWith 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]
X
$88649654188267*
XThese 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".X


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

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

[tip]Don't overthink this level.[/tip]X
$81647833476822* XDouble DetectionX


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

$25959617344671* XFlagsX
$13327132168076* XResultX
$17010689474441* XConditionX


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



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

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


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



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

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

X


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

$65261628219716* XEdit the assembly on the RAMX


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



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

$76398546711745* XALUX
$17602708328746*
XTime 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]X


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

$73973243772156* XExpected a signed number literalX
$25983481845150* XExpected '{symbol}', got EOFX
$11064758781325* XExpected '"', ''', or '`' at the start of UI table cell contentX
$43326454052643* XExpected an U for unsigned or S for signed hereX
$22452670489981* XExpected a number literalX
$33400766069212* XExpected an opening parantheses (one of '(', '[' or '{{'), got '{open}'X
$19807940646400* XExpected one of {expected}, got {actual}X
$49180229055343* XExpected a valueX
$66187706284192* XExpected ':' after the keyX
$12492443144951* XExpected a ',' or end of tableX
$56457570130031* XInvalid escape character '{nc}'X
$64926004981217* XInvalid int literalX
$71666516845083* XExpected an unsigned number literalX
$73113688099439* XExpected one of {expected}X
$22378976352410* XLine {num}: X
$51855228989260* XInvalid unsigned int literalX
$13040813748160* XExpected a keyX
$44942745729831* XInvalid hex escape sequenceX
$75565287060042* XUnexpected EOF while parsing a stringX
$64743950507593* XExpected a list valueX
$10198498286711* XUnfinished escape sequenceX
$29112746104375* XExpected a bool here.X
$33551107641907* XInt literal too bigX
$77089554485217* XExpected a size declaration hereX
$82386938622647* XExpected some character after the escape character '\\'X
$36313699368590* XInvalid octal escape sequenceX
$72110029133381* XExpected {prefix}X
$27682737127628* XExpected an opening quote (one of ", ' or `)X


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

$57534334907443* XAdd another 7 Full Adder components, one for each bitX


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

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


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

$13921098180953* Xschematic hubX
$49251062339706* XoptionsX
$32835651830157* XprofileX
$16857608955464* XsandboxX
$15234594767991* XcreditsX
$66967233942803* Xplay campaignX
$12639868461113* XexitX


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

$88550064597726* XAdd jumps to SymphonyX


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



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

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


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

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


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



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

$10949534274977* XThe busX
$25369396405852*
XThis 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.X


=== campaign/byte_asr/ui.txt ===



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

$52048822283735*
XThis 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.X
$71902120982324* XSymphony ALUX


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

$18497022543669* XThis solution is by no means the most elegant or optimalX
$13880107359455* XThat, though, is left as an exercise to the player!X


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



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



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

$26325060783055* XArgument AX
$40584554497383* XImmediate ValueX
$67128656777473* XDestinationX
$48212238534381* XInstructionX
$48506758479060* XModeX
$16402377924132* XIs ImmediateX
$26207217884026* XOpcodeX
$24747841106265* XArgument BX


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

$15140861344476* XSelect {select}X


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

$16394937100308* XNOT GateX
$64052600264884*
XUsing 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]
X
$56423993638708* XIn the last level you made the truth table that described the circuit. In this level you build the circuit that matches truth table.X
$80163590000700* XNow that you unlocked the NAND gate, it is time for you to build a circuit yourself.X


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

$51514522389782* XObserve how function calls workX


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



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

$58374689721038* XBYTESX
$74796974148718* XOutputX
$10463931654475* XInput 0X
$14057674753878* XInput 1X
$73841752788709* XInputX


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

$82755888644217* XIf the sign bits of the inputs differ, we can just compare themX


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

$55176290924321* XCreate a circuit that always outputs the number 164.X
$55259569122850* XByte ConstantX


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



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

$80507287196650* XNEVERX
$74974087807935* XALWAYSX


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



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

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


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

$75524550463342* XADD r1 and r2 and store the result in r3.X
$43876958520450* XJump to r0 if r3 is not 0.X
$64808551937719* XJump to r0 if r3 is greater or equal to 0.X
$18505654344513* XJump to r0.X
$71072332861445* XDo nothing.X
$42577908074742* XMove %a to r0.X
$75067212691206* XNOR r1 and r2 and store the result in r3.X
$88048573834702* XJump to r0 if r3 is greater than 0.X
$21095867785396* XAND r1 and r2 and store the result in r3.X
$26704206992933* XNAND r1 and r2 and store the result in r3.X
$33850592701591* XSUB r1 and r2 and store the result in r3.X
$24147817394058* XJump to r0 if r3 is less than 0.X
$58823897430160* XOR r1 and r2 and store the result in r3.X
$48758564562305* XJump to r0 if r3 is less or equal to 0.X
$45432635426071* XMove a value to %a from %b.X
$46599288949396* XJump to r0 if r3 is 0.X


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

$15039285047182* XOutput should be {expected}.X
$46433606967015* XAdd 1 to {cycle}X


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

$46932595269557* XHub PreviewX


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

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


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

$32183772878666* XHistoryX


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

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


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

$75138288162938* XYou read the input {read_count} times, not {output}.X
$39953782121467* XThe last input was not 37!X


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

$15378963142694* XInput 2X


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

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


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

$52976618691411* XOutput should have been {char}, not {output}X
$37137490280093* XYou did not read character {character} from the string yetX


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



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

$73980120059844* XWe just make the byte version out of the "Saving Gracefully" levelX


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



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

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


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

$76653207214085* XReturns the remainder after dividing the two inputs.X


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

$22037524510182*
X
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.
X


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

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


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

$20456965663323* XInstruction AliasesX
$41535895646297*
XLike 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.
X


=== campaign/symphony_2_io/label.txt ===



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

$36308361121667* XOutput not enabled.X
$17521915837347* XOutput should not be enabled.X
$33411257451562* XExpected output: {value}.X


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

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


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

$71118235828147* XThe circular dependency can be complex, involving many different wires and componentsX
$13967626449720* XSome even deceptive like this example, which may make sense in pure logic formX


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

$36850349097673*
XThe 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.X
$22440157378882* XCapitalizeX


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



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

$73447955210779* XBinaryX


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

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

X


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



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

$67744627518982* XcoinX
$64851396075477* X2 * instruction size = 8X
$55263046326109* Xhit wall -> cancel movementX
$75937352730902* X0.5 second = 500_000_000 nano second = 0x0000_0000_1DCD_6500X
$50501450979711* Xrobot upX
$45301848117435* Xghost downX
$16841324702501* XRobotX
$29369794309677* XTODO: handle coin and empty differentlyX
$38695844571056* XoverflowX
$35647670060017* XemptyX
$10169473219025* X1 second = 1_000_000_000 nano second = 0x0000_0000_3B9A_CA00X
$25474902303790* Xincrement directionX
$26430777268618* Xrobot downX
$40959483784712* Xrobot rightX
$37647180126584* Xdraw robot on new positionX
$23344524651761* Xupdate next cycleX
$55673115734516* Xpadding to preserve 32 bits alignmentX
$25470599373421* Xdraw ghost on new positionX
$28230914387367* XcoinX
$33450896282702* XplaceholderX
$22405816552972* XdirectionX
$50069163371185* Xghost leftX
$31647601023268* XSprite addresses jump tableX
$72366220861688* Xghost upX
$11549850182703* Xy coordX
$62236058044269* X[padding]X
$73803385159414* Xso the first value is 0X
$61792431057747* Xx coordX
$34042928458359* Xmodulo 3X
$33327526977497* XGhostX
$37230877526029* Xghost rightX
$36791496238134* X2 * instruction length = 8X
$69893421560125* Xrobot leftX


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

$57603105454008* XNow do we have a component that mimics this behavior?X
$49444546097133* Xodd number + odd number = even numberX
$59534613718377* Xodd number + even number = odd numberX
$28104365880572* Xeven number + even number = even numberX


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

$53456282160464* XSandbox modeX
$72245209470436* XFPSX
$41662660252584* XCursorX
$99534264629442* XTestX
$18403698792036* XLevel typeX
$74564675939961* XSim speedX


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

$15531830527231* Xr3X
$78214997465973* XCounterX
$47858891143005* Xr2X
$42538649427331* XProgramX
$17025449350330* Xr5X
$76878335565401* Xr4X
$59383212597903* Xr0X
$89909032864119* Xr1X
$57877356797542* XDoneCountX


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

$10776402819741* XWe measure the universe with numbers. So our machine must know how to count.X
$19285770105090*
XTreat 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].X
$64470174232265* XHalf AdderX


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



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

$78613176066303* XIntegrating ALUX
$13069282666558*
XAdd 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]
X


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

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


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

$64992550674018* XIt is, in fact, just an XOR gateX


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

$16026817441460* Xcycles/secX


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

$21345632528660* XBuild the foundation of the Symphony architectureX


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



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

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


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

$63394282539727* XAdd IO instructions to SymphonyX


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

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


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

$33181499064044* XResult should never be Z stateX
$73051402798264* XThe correct output is {U1 result}X


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

$69427874681706* XImplement the Symphony ALUX


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

$14374127314134* XLittle BoxX
$76851096880864* XCan you fit 4 bytes of memory in this limited space?X
$68663841862704*
XIn 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]
X


=== 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* XDivideX
$15513439442399* XDivide 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.X


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

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


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



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

$66258723258123* XWe are experimenting with how backgrounds influence cognitive function in Earthlings.X
$38198768813364* XBit InverterX
$76209391067704* XThis 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.X
$53559965601096* XCreate 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.X


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

$47348572622406* XPunchcard ProgrammingX
$23659479615536* XNow that you have built your first computer it is time to learn how to program it.X
$12002017150690* XClick 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.X
$35877580485177*
XSince 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.X


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



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



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

$15872341864658*
XSincere 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}X
$21717110565858* XCreditsX


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

$49063245216494* XThis level makes use of the previously implemented LSL (Left Shift) componentX


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

$85571962806085* XAssemblyX


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

$30888506574129* XThe orange wires implement the JUMP modeX


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

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


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



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

$84654787309709* X{register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}X
$74043498193765* XOutput should have been {expected_output}, not {output_value}.X
$40674051088628* XScreen setting 3 is supposed to be {expected_value}, not {value}X
$68153781027719* XPersistent Memory address {i} is supposed to have value {expected_value}, not {value}X
$81124009043205* XThe 'zr' register should always be zero (address 0 in the 'Register File').X
$55420494010123* XMain Memory address {i} is supposed to have value {expected_value}, not {value}X
$56149980430079* XOutput should have been enabled.X
$34545926188340* XYou should have read address {expected_value} from the Main Memory, not {actual_counter}. You must have not updated the counter correctly last cycle.X
$35453700742253* XThe time component shouldn't have been enabled since the last time_0 instruction's execution.X


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


# Placeholder on the name input field of the file explorer
$18871898542185* XNew folderX

# Placeholder on the name input field of the file explorer
$84870575118100* XNew fileX
$69090690657232* XCloneX
$56429258960561* XRenameX

# Load a schematic
$70369485875359* XLoadX
$91861509153454* XDeleteX


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

$98772447663910* XLink componentsX
$80005228759908* XValue here: X
$38481453712356* XEdit assemblyX
$64854367750357* XOpen hex editorX
$22780831606716* XLoad fileX
$26085882338208* XEdit punch cardX
$10186190492148* XALT click to move wire headX


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

$71000564779980*
XThe 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.X
$46388374967041*
XIn 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.
X
$76392666043520* XAnyway 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.X
$78836302049950* XMod 4X


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

$11486015900582* XThe keyboardX


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



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



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

$40553112323959* XYou may not use more than 3 components in this levelX
$36609687959808* X{count} of 3X


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

$24027424800887* XNext levelX
$80966247197959* XClick the Input button in the upper left to enable the input.X
$70403032472607* XWell done! Let's go to the next level.X


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

$81792554779622* XBuild a 32 bit counter which increments by 4 each cycleX


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

$80662783536910* XShort circuitX


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

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


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



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

$73023200204536* XCounter should have value {expected_value}.X
$50052313044113* XOutput not enabled.X
$88140381331491* XExpected output: {value}.X
$19443898128380* XOutput should not be enabled.X
$49097812105667* XRegister {reg_i} should have value {value}.X


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

$85471608475185*
XSometimes 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]
X
$74993560224545*
XUpdate the architecture to look like this diagram:

[image="symphony_diagram_2.png"]X
$46968415562883* XImmediatesX


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



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

$67225915898937* XPrefixX
$77741358519166* XCountX
$67275059688693* XSizeX
$37885763626223* XLink RAMX
$51331074553774* XHow many registersX
$77103446544344* XExample: reg_X


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

$41138026161536*
XUse 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.X
$13883461694525* XInstruction DecoderX
$71911284169222*
X
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]
  X


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

$62535209440079* XThat, though, is left as an exercise to the player!X
$81301599100070* XThe simplest way is to single out the 0 caseX
$27675083487752* XThis solution is by no means the most elegant or optimalX


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

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


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

$62210202128540* XNotice how the input doesn't matter?X


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

$75719044675256* XASCII encodingX


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

$22122562689406* XOutputX
$45326245069696* XInputX


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

$68865507501612* XThis 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.X
$36846418389807* XAll the animal species of Earth are going through the same test, to see if you have the intelligence to learn to build a computer.X
$65167079914703* XThe 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.X
$39082333495604* XNAND GateX
$50880631203389* XCorrect! You have unlocked the NAND gate. Out of this fundamental building block, you will construct everything else in your computer.X


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



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

$65712025748767*
XIf 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]
  X
$40525671378957*
XThe 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.
X
$47703565240245* XConditional JumpsX
$38613585637577*
XGood 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.X
$38150072401115*
XTo finish this level, read the input until you see the number 37. 

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


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

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


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

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


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

$38271404408184* XCurrent outputX


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

$19817843844200* XNimX
$47072576894526* XAlso, 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.X
$53912339443439*
XIn 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.X


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

$43603044118584* X3 Bit DecoderX
$28695849165746* XWith 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].X


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

$52492743864774* XOtherwise, we can compare 2 7-bit unsigned numbersX


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

$37988524800638* XBinary RacerX
$17561499905402* XThis level is my favorite pastime. Converting decimal into binary under time pressure.X
$78267067157141*
XToggle the bits in the level panel so they add up to the decimal number in the question.

You must beat level 3 to pass.
X


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

$66359790889628* XDe Morgan's lawsX


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



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

$22306447815263* XOptimize OvertureX


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

$27941792707668* XAdd 5 to the input using assembly programmingX


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

$77523753173621* XA negative of a binary number can be obtainedX
$59964726775903* Xby flipping its bits (byte NOT) and then adding oneX


=== presenter/board_ui.nim ===

$36331525379247* XSave this schematicX


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

$37729390402296* XComparison FlagsX
$64818361855764*
XIn 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.X


=== campaign/symphony_2_io/hint_solution.txt ===

$34652721020070* XThe grey wires implement the IO modeX


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

$50044461577278* XThe last AND result is unused, so we can safely delete itX


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



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

$81974422302188* XManualX


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

$51887730294248* XWire that up and the only thing left is to enable the right memory cellX
$65959445914539* XThe value to save to a cell comes from one inputX


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

$74290091312759* XThis level is just a tweak away from saving with overwrite capabilityX


=== presenter/update_state_stream.nim ===


# Text on keyboard component
$73297471730751* XNot recordingX
$12823129240050* XClick the upper-left button to link the screenX

# Text on keyboard component
$61909856780806* XRecordingX

# Text on keyboard component
$41639816417947* XRecord when runningX


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



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

$57911760722636* XMoves a value to %a from %b.X


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

$13755587162128* XInput 2X
$41149959264274* XInput 1X
$12555311310864* XInput 0X
$50183740481245* XSumX
$34717193596171* XCarryX


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

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


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



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

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


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

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


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

$49706182840588* XIntegrate the ALU into the circuitX


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

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


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

$56387381898532* XSymphony CounterX
$76860406179468*
XTo 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.X
$77897142643435*
XBuild 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.X


=== campaign/symphony_1_nand/label.txt ===



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



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

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


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

$79554853897000* XSwitch schematicX
$50924073287410* XToggle number formatX
$71951682957395* XLevel mapX
$85430022417382* XShow delayX
$98930461722118* XBackX
$85248932172256* XExit hintsX
$91515053618360* XManualX
$38557550573896* XLevel objectivesX
$33761197388580* XView hintsX
$56916384895438* XMain menuX
$30516879701896* XSandboxX
$11731996208080* XFoundryX


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

$70994998239232* XClick on the NAND gate to selectX


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

$54301125260332* XMemory is supposed to be {expected_memory}, not {memory_value}X
$70376380014778* XOutput should never be Z stateX
$84451713761977* XOutput should be {expected_memory}X


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



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

$41472172986798* XByte XORX
$70973830134418* XCreate a circuit that XORs two bytes bitwise.X


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



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

$83185064398279* XThe foundryX


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

$67313804184537* XA bigger OR is but multiple ORs in successionX


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



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

$63242509760527* XUsing a maximum of 3 components, output [T] only when an odd number of inputs are [T]X
$44190469254011* XOdd Number of SignalsX


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

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


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



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

$88124920557040* XTuring completeX


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



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



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

$21618236951146* XView solutionX
$65770257567603* XIf you are sure you want to see the solution, press the button below.X


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

$45433710484419* XExpected a size before the number, like: U64 {number}X
$18981788561705* XExpected whitespace hereX
$15585581119466* XInstruction '{instruction_name}' is missing the bit field definitionX
$71714150108621* XError evaluating operand %{operand_name}: {err}X
$57794055991905* XError evaluating assert {assertion}: {err}X
$82512572175623* XUnexpected end of instruction after {partial_instruction}X
$60515742509356* XExpected a number after a size declarationX
$48895355188042* XExpect a number literal after '@'X
$59248806788382* XCannot reference private label {name}X
$62050046600010* XThe file name {name} cannot be used as referencable alias, declare another alias using the keyword 'as', e.g. 'include .A as A'X
$90294506138532* XDefinition value must be either a number or a fieldX
$60631582636278* XUndefined label {name}X
$15728875852508* XFail to parse {file}X
$86607635528717* XUndefined constant {field_string}X
$19581803133960* XExpected '{syntax}' after '{partial_instruction}'X
$58979769991732* XExpected a new line after 'include'X
$83649060120708* XSigned numbers are not supportedX
$66273157704409* XMissing a '{field_type}' operand hereX
$53378617686677* XValue {num} outside of range for {field}X
$69537550553443* XExpected at least one whitespace character after '{partial_instruction}'X
$84557608492963* XUnknown code found after instruction: X
$87525828760679* XFailed to resolve pattern ({err}): {resolved_pattern}X
$47300717145684* XMissing '=' after 'const'X
$33085034295813* XExpected either a number or a symbolX
$83023561541280* XWas expecting a label name hereX
$67922577781529* XOnly positive multiples of 8 bits are supported for nowX
$66575346967082* XFile does not exist: X
$35210741057769* XCan't understand this lineX
$30066682696902* XAssert {source} did not matchX
$68530592279217* XExpected a valid operand name, got '{operand_name}' among {all_operand_names}X
$51466436379956* XCan only pad forward, current address is at: {address}X
$51460031660101* XCould not assemble instruction on resolving label {name}: {err}X
$21828993759952* XUnknown instructionX
$79977943868423* X'{field_string}' is not a '{field_type}'X
$39195841380612* XLabel {name} is already declaredX
$19131785861372* XRecursive inclusion of: X
$37770431994640* XInvalid instructionX
$35071857261934* XExpected some whitespace after 'as'X
$76017808702292* XThe width of instruction '{instruction_name}' is {width} bits, but only multiples of 8 are supportedX
$12097260550100* XValue {num} outside of range for {field}X
$42442531119863* X{constant_name} is already declaredX
$23413102374088* XInvalid instructionX
$80097289956044* XExpected some whitespace between the size and the number, like U{size} {number}X


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

$55730459238598* XExpected output: {a}{b}{c}.X


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

$53593011909329* XDelicious orderX
$23043475637417* XIn 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.X
$79528307974753* XWe 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.X


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

$42735906141201* XFull AdderX
$34381936755276*
XIn 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].X


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

$34521278233301* XThat, though, is left as an exercise to the player!X
$43216513907358* XThis solution is by no means the most elegant or optimalX


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

$13079267765950*
XThe 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.X


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

$21043147057012* XOperatorsX


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

$41856942338650* XConditionX
$67613074322431* XMoveX
$71705253055197* XImmediateX
$23393810721136* XALUX


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

$86131527203527* XThis is where a decoder comes in handyX
$73686127519870* XThen we need to decide on which memory cell to load from/save toX


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



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

$74552564780850* XComponents spentX


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

$84617036256734* XCurrent SumX
$49855734765642* XDesired CarryX
$40317306745068* XDesired SumX
$51965136043073* XCurrent CarryX


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

$50002893048555* XLast 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.X
$30005674935190*
XThis 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]X
$21287008524643* XXOR GateX


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

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


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

$23829497228009* XTypeX
$70134513915163* XNewly addedX
$87115430626073* XMy uploadsX
$56045953383535* XArchitecturesX
$77788981567936* XLevelsX
$25536941657464* XComponentsX
$83319579232915* XOrder byX
$43488408276984* XPopularX


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

$79378464416004* XUse the arrow keys to pick cardsX


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

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


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

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


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

$58149108600515* XThe 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.X
$10102035559374* XProgramX


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

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


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



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

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


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

$76898193108851* XThe enabled switch can then be found using a decoderX


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

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


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

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


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

$36265530817755* XJump to addressX
$40263691211335* Xoffset in bytes (16, 0xF, ...)X

# OK button on popups
$26766209496460* XOkX


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

$85502688597126* XUse the arrow keys to take cardsX
$64085588225039* XHit enter to see what the oponent doesX
$90440029783715* XYou took the last cardX
$42147812867053* XYou won!X
$49299754864790* XHit enter to take {card_count} cardsX
$27262056315410* XYou lost!X
$29769682738867* XYou may only take 1, 2 or 3 cardsX


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

$76027454955517* XA switch is very similar to an AND gate so let's replace themX
$45466715038362* XNow we just need to eliminate the OR gate to stay within budgetX


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

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


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

$10655955073336* XLoadX
$46688176903674* XAddressX


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

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


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

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


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

$54328660964287* XWindow modeX
$12034378482152* XConfirm reset?X
$55047615798435* XAccessibility modeX
$70994568832660* XDelete allX
$93981778736076* XMusic volumeX
$49806848871093* XColor blind modeX
$61172959716558* XSave locationX
$95307230990123* XVerilog modeX
$13442839894535* XWire animation speedX
$67420270098223* XFactory resetX
$21908594290225* XGeneralX
$15557473522933* XResetX
$71208664264770*
XThis 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.X
$23270083417453* XCancelX
$24145565754506* XEffects volumeX
$30910326565868* XLanguageX
$29594613477534* XYou must restart the game for the language change to take effect.X


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

$71744044447857* XTo check all bits are [F], we split the value into bits and apply a big NOR gateX
$78036114842982* XNext, for value < 0, we check if a binary number is negativeX


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

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


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

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


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

$79162322081640* XkeyboardX
$28246040923235* XRegister FileX
$18099138932731* XPersistent MemoryX
$80985404567327* XscreenX
$41903613959902* XMain MemoryX
$35059654572638* XtimeX


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

$66937784075495* XWe then use decoders find the enabled source & destinationX


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

$77115196290575* XBuild the register circuitX


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

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


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

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

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


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

$40303102766749* XOutput 0X
$56552908891774* XOutput 1X


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

$13186595896308* XAn XOR of 2 equal numbers is very beautifulX


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

$81327009436542* XBut using an Add component here is an overkill!X
$22938387275450* XJust add 1 to loop wire of the Delay LineX


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

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


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

$11101940160071* XWhen the Action pin is [T], or Save, we want to overwrite it with ValueX
$19959785727663* XBut doing that will cause a short circuitX


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

$30858693828450* XSo let's hook those up together with the busX
$41615813866999* XThe Never and Always are the easier partsX
$73479968135998* XNow, to check value = 0, we need to check all bits are [F]X


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

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


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

$30671593085518* XThis solution is by no means the most elegant or optimalX
$16623524168613* XThat, though, is left as an exercise to the player!X


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

$16679981460998* XOutput [T] when both inputs are the same.X
$44220989927736* XEqualityX


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



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

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


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



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

$17566441654249* XShiftX


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

$78759770178685* XThe purple wires implement the interaction with the main memoryX


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

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

X


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

$43585926436336* XNote 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.X
$65386575947998*
XIn 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.X
$69462908463194*
XIn 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.X
$41276257356528* XRAMX
$73426457129430*
XOnce 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]X


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

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


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

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


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

$19139933016995* XWe don't have a subtraction component, only addition and negationX
$15205448412655* Xi.e. Input 0 ADD (NEG Input 1)X
$56709208304109* XSo we transform, for example, 1100 - 1001 to 1100 + (-1001)X


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

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


=== presenter/level_tree_ui.nim ===

$95146987030704* XLockedX
$26276191141664* XUse keyboard to panX
$75049509201775* XBOOLEAN LOGICX
$55841332003989* XDECREASE DELAY TO PASSX
$19508086025944* XPROGRAMMING 2X
$38100016313511* XCPU ARCHITECTURE 2X
$65362728703588* XMEMORYX
$44937904689376* XPROGRAMMINGX
$95559333192525* XCPU ARCHITECTUREX
$35696974632265* XLevel map colorsX
$81337533438394* XCompleteX
$38843517090942* XWORKING COMPUTERX
$51337598329530* XARITHMETICX
$81707212583931* XAvailableX
$87420015169370* XOPTIONAL COMPONENT LEVELSX


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



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

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


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



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

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


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

$62793095496458* XAdding BytesX
$53076615315445* XAlso, this level has a lot of tests. Right click on the run button to increase the testing speed.X
$45061087867940*
XIf 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].X
$31490345812891* XAdd 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.X


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

$25477689162292* XOutput selectX
$25535487507842* XAX
$43474590938240* XYX
$47236089523392* XXX
$43340511034957* XInput selectX
$65041743851294* XBX


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

$39134024311972*
XAdd addition and subtraction to your circuit.

Instructions:

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


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

$24718289227251*
XWelcome 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.X
$88436914545275* XComponents can be added, renamed or deleted using the schematics menu.X
$62612312608874* XSince this level is a tool and not a challenge, you can go to the level map and continue on when you want.X
$72171231322685* XThe FoundryX


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

$86840165316981* XRight click to deselect the gateX
$79416009887091* XClick anywhere on the board to place the gateX
$55369640789869*
XClick anywhere on the board to start a wire
Connect the red components to the NAND gateX


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

$11603603520594* XMoves a value to %a from %b.X


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

$37690209655811* XYou only need 8 full addersX


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

$81923869207578* XAssembly programmingX


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



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

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

To succeed you must learn to think logically, while not destroying things.X
$72918877035793* XNOR GateX
$56653221050913* XCreate the circuit that matches the table.X


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

$88850298427736* XTo that end, we note the additive property of shift,X
$12195819154781* Xi.e, shift of 3 is equivalent to shift of 1 + shift of 2X
$28136552692253* XWe can implement a version of this shift called barrel shifterX


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

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


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

$12922292218235* XBit SwitchX
$77268807700313* XUsing 2 NOT gates and 2 Switches, build an XOR gate.X
$88100823584262*
XIf 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.X
$25663924496537*
X
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.
X


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

$67457044658869*
XFor 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".
X
$78454657849319* XIO DevicesX
$29247683714165*
XSo 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]
X


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

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


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

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


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



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

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


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

$11980470862173* XByte NANDX
$66454601163361* XDon'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.X
$52274910421610*
XNAND 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]
X


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



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

$58396790216558* XMove a value to %a from %b.X


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

$10529708471093* XInputX


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

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


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



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

$17745932940157* XYou should have read address {expected_value} from the Main Memory, not {actual_counter}. You must have not updated the counter correctly last cycle.X
$22469925230320* XPersistent Memory address {i} is supposed to have value {expected_value}, not {value}X
$74663212299349* XMain Memory address {i} is supposed to have value {expected_value}, not {value}X
$85916420035294* XOutput should have been enabled.X
$70740757119887* X{register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}X
$21000091589999* XOutput should have been {expected_output}, not {output_value}.X
$29078414770160* XThe 'zr' register should always be zero (address 0 in the 'Register File').X
$60841927788704* XThe time component shouldn't have been enabled since the last time_0 instruction's execution.X


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



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

$16562043259074* XArithmetic Logic Unit (ALU) 1X
$31234606133949*
XCreate 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]X


=== campaign/the_bus/hint_0.txt ===

$42863588667057* XUse switches to put the inputs on the same wireX


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

$85765173996083* XIncrement the input by 1X


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

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


X


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

$82513296271559* XApply the same steps to reduce the problem from 8 bits to 4 bitsX
$12591714876491* XThe only thing missing is the case when Input is 0X


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

$18890527031365* XCount leading zeroesX
$30557055303267*
XCreate 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]
X


=== campaign/byte_asr/label.txt ===



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



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

$16764912826624* XCode BreakerX
$20948899837760*
XIn 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.X


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

$19099025738142* XStartX
$13872783467999* XWhat is {number} in signed binary?X
$56999237564848* X{x} seconds leftX
$92057009138253* XWhat is {number} in hex?X
$23959994711260* XReady to race?X
$11176073682097* XWhat is {number} in binary?X
$45532697833519* XYou made it to level {level}!X
$41793938939207* XTime outX
$37093663674348* XLevel {x}X


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

$68315222097089*
XThe 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.
X
$29798404581087* XStackX
$90806029597852*
XSince 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.X


=== campaign/binary_programming/label.txt ===



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

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


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

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


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

$76244671092409* XCarry outX
$45190053242926* XCarry inX


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

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


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

$76705374584193* XPersistent MemoryX
$23620554597332*
XIn 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]X


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

$20911185106374*
XIn 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].
X
$90224867995967* XCondition MatchX


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



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



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

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

X


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

$68850421394935* XCounterX
$51274378991709* XCounting 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.X
$42949183679479*
XBuild 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.X


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

$73562005049347* XMoves input to reg 2X
$41299869859669* XThis is a commentX
$80524429403045* XClick the spec.isa tab in the top left to see all instructionsX
$36228934755685* XMoves 15 to reg 0X


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


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

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

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

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

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

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

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

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


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

$86286155471986* XThe purple wire in the middle is the BUSX
$55189990966587* XTweak the Multiplexer to share its input, instead of output, for the selective outputX


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


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

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


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

$69085851994491* Xwith the results of NAND, OR, AND and NOR replace Input A/BX
$17808301775724* XThis level is similar to "Multiplexer"X


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

$58382627590046* XThe SandboxX


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

$31942264008156* XArg B should be {b}.X
$31544476297744* XDestination should be {dest}.X
$82638458430252* XArg A should be {a}.X
$63089562267538* X'Is immediate' should be {immediate}.X
$45701446129480* XImmediate value should be {immediate_value}.X
$15174125339458* XOpcode should be {opcode}, not {actual_opcode}.X
$64926808682290* XMode should be {mode}.X


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

$84590049728141* XNote 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.X
$35331465118106* XOvertureX
$59818810946218* XBy 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".X
$59797408403606*
XThe 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.
  X


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

$75667038547709* XThe information comes from the cycle count, this is where the Delay Line shinesX
$69947751578736* XThe input is merely a distractionX


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



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



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

$43384041502940* XValueX
$11886599003881* XvalueX
$81487261104241* XConditionX
$38979555213581* XDescriptionX


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

$44716420394020* XHumble BeginningsX
$76679675871478* XThis 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.X
$26182817405385*
XCongratulations, you have been abducted.

We are testing you on our spaceship.

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


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

$61996387838431* XThe purple wires implement the immediate modeX


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

$16305942415014* XActionX
$57018164959250* XNext desired outputX


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

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


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

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


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



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

$67371980949119* XLanguage creationX


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

$36195388998735* XGeneralX


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

$17052191264122* XLower the delay of SymphonyX


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

$64947954189801* XCreate a component that can switch a signal between 2 pins.X
$55345008240214* X1 Bit DecoderX


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

$88766421259023* XByte NAND of 2 binary numbers is just the NAND gate applied bitwise between themX


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

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


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

$42610024611500* XCircuitsX


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

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


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


# The hub author
$71812400203030* XBy:X
$90731554079332* XNo schematics foundX
$22639280459994* XDownloading list...X
$76770986264566* XSearchX

# To download hub schematics
$55983490912314* XLoadX

# The hub schematic size
$15762392983604* XSize:X

# To confirm deleting hub schematics
$66333328482057* XAre you sure?X
$61693098943939* XContinueX
$84668607423763* XDownloading 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.X

# To delete hub schematics
$62589392744014* XDeleteX
$44524092309946* XLoading...X
$76747661573536* XYesX


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

$24524168624111* XCounter memory should be {expected_value}.X
$45858569181521* XYour have read {.input_index} inputs, but you were supposed to have read {.emulator_input_index}.X
$35224907301551* XRegister {reg_i} should have value {value}.X


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

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


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

$65145204616501* XAdd conditions to the circuitX


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

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


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

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


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



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

$41513122622358* XFunctionsX
$28617596738571*
XSometimes 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.
X
$64240772623662*
XIn 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.X
$56028205797304* XAs 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.X
$42088257134737* XThis 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.X


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

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


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

$60698949860454* XALUX
$15645900189277* XMoveX
$90597971391617* XImmediateX


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



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

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


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



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

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


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


# Placeholder for the search bar in the level tree
$72813322690589* XLevel searchX
$68227209887733* XFoundryX


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

$84832818424728* XFilesX


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


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

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

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


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

$88356074900046* Xto create signal based on the cycle countX
$14188568517859* XThe Delay Line can be looped back into itselfX


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

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


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

$71972143734450* XHex valueX


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

$60812617177494* XDo not use more than 3 components.X
$74562193652628* XThe output on pin {pin} is wrong.X


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



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

$52150443679969* XContinueX
$89787506720574* XCloseX


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



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

$63172000393911* XSelectX


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

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


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

$68089739910654* XBigger OR GateX
$29275887429601* XCreate an OR gate with 3 inputs.X


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



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



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

$46804407616321* XThe lower byte of {a} * {b} is {result}X
$83214947196979* XMultiply two numbersX
$13790051293386* X{a} * {b} is {result}X


=== model/translations.nim ===


# Million
$22896492410578* XMX
$16391754618645* X{size} KBX
$98703677236827* X1 minute agoX
$18683857303458* X{size} bytesX
$95018143828198* X1 year agoX
$86244493049244* X{hours} hours agoX
$21685594109067* XJust nowX

# Trillion
$87907122406742* XTX
$98363990684104* X1 hour agoX
$84076931764831* X1 day agoX
$11567406591202* X1 byteX
$18300496139706* X1 month agoX
$17901039729248* X{months} months agoX
$0*
X
const DECIMAL_SEPARATORS* = {'_'}
const DECIMAL_DIGITS* = {'0' .. '9'}
const DIVIDER_TOKEN* = X
$42553566189409* X{minutes} minutes agoX
$70945526841433* X{years} years agoX

# Thousand
$84696693690500* XKX

# Quadrillion
$49300594926837* XQX
$14036822471924* X{days} days agoX

# Billion
$71072134093858* XBX


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

$42740851915963* XRemaining powerX
$33479507858734* XCalculate 2 to the power 5X
$27592840036827* XSecond input is 5X
$18457350783754* XFirst input is 2X
$30769341721428* XLeft hand side of the multiplyX
$63878589013500* XKeep multiplying until "remaining power" is 0X
$42717933764735* Xr1 and r2 are used for arguments, r1 is the function resultX
$27088227324511* XRemaining right hand side of the multiplyX
$21553876748933* XAccumulatorX
$70634976221207* XPush r3 so we can use it within the function but still restore it before returningX
$59000482794872* XShould output 32X
$43461252553161* XCalling convention:X
$32724600358227* XRestore outside valueX
$21707356398727* XLoad two numbers given from the levelX
$68500361393623* XGive names to registers to make things easier to readX
$11016773181609* XThe last multiply call already put the result in r1X
$14412657671278* XPush r3 and r4 so we can use them within the function but still restore them before returningX
$10902022971046* XExcept for r1 and r2, a function should return with all registers having the original valueX
$65068280556611* XRestore outside valuesX


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

$26513163439009* XThe only component we have is the NAND gateX


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

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


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

$65391114076509* XAdd 5 to the input using binary programmingX


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

$18477347795935*
XThe 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.X


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

$79928695804890* XCircular dependencyX


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

$60269032570207* XExpected output {expected_output}.X


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



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

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


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

$25938996008186* Xwith the source in place of Inputs and destination OutputsX
$87908319845833* XThis level is similar to "The Bus"X


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

$56722492138232* XGreat 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.X
$84960209408475*
XIn 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.
X
$90660848232877* XThe MazeX
$19088384441761*
XRead the input to figure out what the robot sees in front of him. It is always one of these:
0 Nothing
1 Wall

X


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

$63465863198591* XValueX
$10654649810679* XSaveX


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

$32912994842868* XBigger AND GateX
$28751026881977* XCreate an AND gate with 3 inputs.X


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

$50319416070023* XMoves 5 to r0X
$66946505646203* XYou can load its offset like thisX
$67381454058237* XThis is a labelX
$78380513477546* XClick the spec.isa tab to see the other jump instructionsX
$35642914965530* XJumps to byte 5 of the programX


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

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


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

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


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



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

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


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

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


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

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


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



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

$28460985244857* XOne of the components you need is a shiftX


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

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


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

$17985924005596* XIt contains {nr} schematic(s).X
$66392158413243* XAre you sure you want to delete "{file_name}"?X
$14436541903929* XArchitectures: {list}X
$68586106474430* XNote: all architecture levels share saves, so this will be deleted for all levels!X
$51791491383290* XThe custom component is used inX
$38011567415872* XThe folder is empty.X
$89354977462546* XNoX
$57790786178566* XCustom components: {list}X


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

$48990052180226* XValueX
$42019997838216* XOverwriteX
$41164574218692* XCountX


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



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

$16731935541997*
XThis 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.

X
$20753698232132* XNegative NumbersX
$87951492143019* XTo know the difference between things, you need subtraction. To get subtraction, first you need negative numbers.X


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

$68430971305988* XBytesX


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

$70892117360845* XAND GateX
$28388869498626* XRight now the elephant is dominating all the other test subjects from Earth. Adjusting for brain size, you are also doing well.X
$18221128000007*
XCreate the circuit that matches the table.
[tip]Most levels have a hint button (the lightbulb) you can click if you are stuck.[/tip]X


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

$81322935207536* XINPUTX
$92046368194170* XConditionX

# The text above the 3 LSBs
$39935096343723* XNeverX
$41846451178700* XMove to {to} from {from}X
$10366913897135* XClick to toggle the bitsX
$31185395052385* XOUTPUTX

# The text above the 3 LSBs
$38497477227061* XWhen [color=#e49f44]result {condition} 0[/color]X
$10141348037745* XImmediate: {nr}X
$98983752580592* XMoveX
$43723329256095* XREG {nr}X
$14831276667273* XInstructionsX

# The text above the 3 LSBs
$25145891843959* XAlwaysX
$67413863640193* XNever move [color=#DD6576][bold]REG 0[/bold][/color] to counterX

# The text below the byte
$59958585065722* XWhen [color=#e49f44]result {condition} 0[/color], move [color=#DD6576][bold]REG 0[/bold][/color] to counterX
$53665446068319* XUNUSEDX
$89294533225655* X{operation} [color=#DD6576][bold]REG 1[/bold][/color] and [color=#DD6576][bold]REG 2[/bold][/color]X
$26521666422399* XALUX
$89662716409733* XAlways move [color=#DD6576][bold]REG 0[/bold][/color] to counterX
$54909668901048* XImmediateX


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

$77234329031993* XExpected slice syntax after field/pattern reference in bit patternX
$61772889138477* XExpected a '(' before the pattern parameter listX
$68066163358870* XExpected whitespace after 'when'X
$50971737349470* XPattern operands not supported in disassembly yetX
$16564670893367* XWas expecting a pattern name hereX
$20574862674671* XExpected newline after virtual fieldX
$72620639818015* XExpected newline after section headerX
$62103010038950* XExpected newline after section headerX
$27111936748508* XExpected a closing parenthesis after the pattern typeX
$25285447732570* XExpected top bound not to be less than bottom boundX
$33504435568130* XCould not interpret virtual operand %{variable_name}: {err}X
$32763965727763* XSign extension bits do not matchX
$77851254343918* XNo operand starts with character '{c}'.X
$42160516340132* XExpected either '(' or '[' after the operand name, like: {variable_name}(immediate), {variable_name}[pattern()]X
$58295598661589* XDescription in patterns must be left emptyX
$63246722572594* XExpected slice syntax after field reference in bit patternX
$78591996283483* XWas expecting a field name or a sized immediate hereX
$26426549472884* XToo many virtual operandsX
$90809893168338* XImmediate operand must have size constraint, e.g. %a:U8(immediate).X
$43708359021513* XPattern must have a bodyX
$18304638469397* XExpected a non-empty string to start line commentsX
$33890983338825* XExpected a list of stringsX
$48321097736953* XExpected hex number not to exceed 32767 digitsX
$33645913580119* XToo many field types, at most {max_field_types} are allowedX
$18247681204565* XExpected ')' after assertionX
$72958581072457* XExpected a name for the patternX
$56352157276583* XOperand value outside of {n}-bit signed rangeX
$35053289858864* XToo many patterns, at most {max_patterns} are allowedX
$48942522553057* XExpected slice syntax after field/pattern reference in bit patternX
$59877879891546* XCould not interpret 'when'-condition expression: {err}X
$47258389995911* XExpected ',' between pattern parametersX
$45267257140327* XExpected newline after section headerX
$62712568576067* XDuplicate field type name: {name}X
$75146029145419* XExpected a name for the pattern parameterX
$55444523984237* XExpected a closing parenthesis after the field typeX
$33105996916812* XPatterns can only invoke those defined before themX
$67707174963301* XExpected an identifier after '%'X
$52261961290701* XFlipped slice syntax after base-16 number reference in bit patternX
$63072912015761* XExpected newline before pattern bodyX
$82876816015252* XToo many operand option paths for automatic disassembly, at most {num_path} are allowedX
$76494975412451* XExpected a valid operand name, got '{operand_name}' among {all_operand_names}X
$15904571494199* XExpected slice syntax after field/pattern reference in bit patternX
$20981379307111* XFixed bits in %{operand} do not matchX
$55929094649794* XExpected a table of stringsX
$45631078896174* XExpected top bound not to exceed 32767X
$64093416909416* XExpected an identifier after '%'X
$40815956642962* XExpected slice syntax after base-16 number reference in bit patternX
$73627734748417* XExpected keyword 'pattern' before the pattern nameX
$29837913233106* XExpected newline between instructionsX
$87843223218582* XThe width of the instruction is {width} bits, but only multiples of 8 are supportedX
$62334191081955* XExpected slice syntax after base-16 number reference in bit patternX
$81691406697268* XExpected top bound in slice syntax after field reference in bit patternX
$11703098452145* XUnknown setting name {name}X
$42907704133778* XExpected a ')' after the pattern parameter listX
$25249187420360* XExpected the name of an option or start of the next sectionX
$52710717731997* XWas expecting a newline here after syntax declarationX
$19678805612580* XRepeat field references do not matchX
$39427635035157* XDuplicate setting '{name}'X
$59115040206693* XExpected a non-empty string to start block commentsX
$63957561177031* XPattern '{pattern_name}' with {argument_count} parameters not definedX
$11824708197936* XExpected a valid field/pattern name, got '{operand_name}'X
$51752498682665* XField name '{field_name}' not definedX
$28197258085607* XExpected slice syntax after field/pattern reference in bit patternX
$48639756889210* XThe width of the instruction cannot be 0X
$55537815420873* XExpected ',' or ')' after pattern argumentX
$59388744207582* XWas expecting a newline at the end of the bit patternX
$77449878176461* XExpected an identifier after '%'X
$23037984432484* XExpected ':' after 'when'-conditionX
$85972591916322* XExpected newline after setting assignmentX
$68533544457789* XOperand {variable_name} on syntax line shadowed another operandX
$83804207975330* XExpected top bound not to exceed 32767X
$79195048703101* XExpected an '=' hereX
$68462760531745* XThe bit pattern of {field_name} is {actual} bits long, expected {expected}X
$57773886232356* XExpected a name for the field typeX
$61352853872444* XOnly immediates of width 0 to {max_field_size} are allowedX
$70814401439344* XExpected top bound not to be less than bottom boundX
$45247724910259* XOperand value outside of {n}-bit unsigned rangeX
$79975911393070* XExpected slice syntax after field/pattern reference in bit patternX
$35468867558322* XExpected newline after section headerX
$67219559926029* XField names can not contain whitespace charactersX
$55289908013299* XVirtual operand {variable_name} shadowed another operand on syntax lineX
$68587613470552* XExpected a field value nameX
$24713798894610* XExpected top bound not to exceed 32767X
$31223930569837* XExpected top bound not to be less than bottom boundX
$70205284263092* XExpected a non-empty string to end block commentsX
$40392382190976* XExpected a bit pattern for {field_name}X
$72400465574342* XOnly up to {max_field_width}-bit field lengths supportedX
$25123045290962* XWas expecting the [instructions] header hereX


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



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

$72990407719621* XAssembly ProgrammingX
$17226968214352* XPunchcard programming is tedious. Lets try adding 5 to the input again like in the previous level, but this time using assembly programming instead.X
$73801373825270*
XThe 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.X


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

$66692685876410* XByte XOR of 2 binary numbers is just the XOR gate applied bitwise between themX


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

$55086379351729* XLoad {text_state} from {text_add}X
$45179662026844* XOutput should have been Z.X
$52597500133853* XSave {text_value} to {text_add}X
$29258463778822* XOutput was Z, but it should have been {expected_value}.X
$48251194975794* XOutput was {actual_value}, but it should have been {expected_value}.X


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

$23707304171214* XMake sure output is always [F] when the disable bit is [T]X
$23128720321555* XDisabledX
$20191487800946* XDesired bitX


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

$11967666262990* XSpec error! Open the spec editor to fix itX
$13400106910274* XLine {nr}: {msg}X

# IDE tab name
$88520918982355* XRegistersX

# IDE tab name
$11106925604855* XFilesX


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

$49335074955899* XAdding on a bit level, we can simply use the Full Adder componentX
$56143546486508* XSimilar to other byte components, we first break down the bytes to their bitsX


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

$69913560783046* XSecond CycleX
$11961528105462* XOutput [T] on the second cycle only.X


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

$57764930098721* XAdd immediates to the circuitX


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

$32041142528569* XSubtracting from (2 - 1) = 1, there are 1 and 0 leading zero, respectivelyX
$88044062357651* XThen how about 4-bit number?X
$88309764896321* XIf the number is less than 2, log2 is 0; otherwise, it is 1X


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



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

$79041418443903* XThe output 0 is the same as the "Odd Number of Signals" levelX


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

$50803475056346* XPatternsX


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

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


=== presenter/update_state_common.nim ===

$43118901497406* XDelayX
$70170261551278* XEnergyX
$39906291838542* XCycleX
$29169064199243* XOutput {nr}X
$95192766583497* XGateX
$13327741293223* XInput {nr}X


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



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

$95509904060545* XSubmitX


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

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


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

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


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

$46518640933018* XBut we have 8-bit unsigned inputsX
$21199347421587* XTo represent them in signed form, we must work with 9-bit bytesX


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

$23614311904581* XImmediate ValuesX
$63109056149876*
XWe 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.X


=== campaign/signed_negator/meta.txt ===

$15862778001173*
XTaking 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.X
$54237470041206* XSigned NegatorX


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



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

$11293872851403* XWe can make a 9-bit custom componentX
$17291563256662* XOr we can break down NEG into NOT and ADD_1 to manipulateX


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

$16820079067437* XLevel CompleteX
$26794262854382* XDiscardX
$20801641140962*
X[b]Level map mode[/b]
[color=#cccccc]Click "[color=#e49f44]Onwards[/color]" and you will see[/color]X
$65428404547905* XStatsX
$40510295620397* XOverwriteX
$43591599177045* XEnergy (Gate x Delay)X
$44038153424304* XA save called "{save}" already existsX
$69511102367948* XTypeX
$53389567901907* XA custom component called "{comp}" already existsX
$84923734370936* XWorst testX
$32133561664335* XKeep bothX

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

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

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

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


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



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

$36027984716180* XWire commentX


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

$41540713506719* XInstructionX
$64281970848639* XDescriptionX
$20074247151096* XInstructionX
$10446152707984* XAddressX


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

$35186537961257* XThis 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.X
$57679157572023* XLogic ExamX
$39721874026332* XGreat 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.X
$39180730338379* XYou 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.X


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

$90593296729801* XSimplify the circuitX


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



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



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

$81427576809439*
XThis 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]X
$29450953142176* XTower of HanoiX
$72724057674158*
XThe 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.X
$62636370223849*
XAmazing, you finished all our tests! Look how far you have come from the NAND gate. 

Humans are truly worthy of joining the Galactic Federation.X
$23374750315066* XIn 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.X


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

$32103815380062* XFieldsX


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

$50970897346580* XThe SUM requires the same reasoning from the "Odd Number of Signals" levelX


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

$55357258069734* XToggles the bits of %b and stores it in %a.X
$72894099288447* XNegates a %b and stores it in %a.X
$28545157055801* XPushes %a on to the stack. This instruction is a synonym for:   sub sp, sp, 4   store_32 [sp], %aX
$57788320241950* XCalls %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 %aX
$48332460366102* XReturns from the last function call. Overwrites the flag register. This instruction is a synonym for:   load_32 flags, [sp]   add sp, sp, 4   jmp flagsX
$57504570243305* XNegates a value and stores it in %a.X
$40508048121543* XToggles the bits of a value and stores it in %a.X
$34859363394334* XMoves a value to %a.X
$53941960758392* XMoves a value to %a from %b.X
$54469754973269* XPops %a off the stack. This instruction is a synonym for:   load_32 %a, [sp]   add sp, sp, 4X


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

$44918705544255* XDisableX


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

$51703376131802* XAdd load and store instructions to SymphonyX


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

$89678353617146* XAdd persistent memory to SymphonyX


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

$86943286745277* XDivide the two numbers.X


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



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



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

$22413958203952* XThe truth table is just telling us to make an XOR gateX
$46480779443140* XLet's first pretend the component constraint does not existX


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

$88955803760495* XThe selective input is just a MultiplexerX


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

$19062117579269* XRun to cycle: X


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

$69821998974515* XOverwrite with {num}X
$27837193789838* XOutput should be {memory}.X
$30050502504940* XAdd 1X


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



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

$13757092116124*
X[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].X
$61875924861326*
XIn 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].X
$36376879506769* XIt 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.X
$87179643828952*
XThese 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]X
$79626649565563* XRegistersX


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

$47075416850998* XThis is true in general for modulo a power of 2, the lowest bit of a numberX
$81555476661504* XNow you just have to figure out how to get the last 2 digits of a numberX
$35037773638556* XLikewise, in decimal 4321 modulo 100 is also simpleX
$79521133202800* X(answer is 21, the higher digits are disregarded, because 100 is a power of 10)X
$40190253854900* XIn binary, taking modulo 4 of a number is the same as only using the two lower bitsX
$44666331884152* XThis is because the higher bits represent 4, 8, 16 etc, and they all divide 4 with no remainderX
$23027113131109* Xrepresents that number modulo 2 (even or odd), the lowest 3 bits modulo 8 and so onX


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

$85604588212035* XCount leading zeroesX


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



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

$18060272082456* XAuto sizeX


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

$42664577834105* XWhich means the lower circuit is subtly wrong, with both switches outputting [Z] when the inputs both are [F]X
$80836475394613* XThis allows their outputs to share wires without short-circuiting as long as at most 1 switch outputs something at any pointX
$47029050705615* XIncorrect outputX
$52307576546100* XUpper circuit/XORX
$16488212881433* XLower circuitX
$62622482229413* XUnlike an AND gate, when the 'Enable' pin is [F], the switch doesn't output [F], it outputs nothing at all.X


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

$50864238070873* XMoves a value to %a from %b.X


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

$41958293329044* XComparing 2 signed numbers is similar to comparing 2 unsigned numbersX
$19896249626650* XIf only one number has [T] for sign bit, that number is guaranteed to be lowerX
$14667194911431* XOnly, the last bit is considered separately for signed numbers, here it has the opposite effectX


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

$41975883966377* XCurrent outputX
$62797002040657* XDesired outputX
$29875779381032* XValueX
$42809920196772* XInvertX


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

$57225943470132*
XThese 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].X
$39122914366346* XJumpsX


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

$11260842500047* XWe can implement a version of this shift called barrel shifterX
$11228896363898* Xi.e, shift of 3 is equivalent to shift of 1 + shift of 2X
$55175982917102* XTo that end, we note the additive property of shift,X


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

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


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

$47175212977659* XAn XOR gate is the one to look toX


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

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


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



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

$83123414679662* Xr2 should have had hex value 0xffffedcb.X
$44683006232656* XThe first instruction should have moved hex value 0x1235 to r1.X
$67087756287234* Xr3 should have had hex value 0x1234X


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

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


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

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


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

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

You must beat level 3 to pass.
X
$11327399415058* XThis level is my second favorite pastime. Converting hexadecimal to binary under time pressure.X
$45399195121692* XHex RacerX
$65517909958697*
XWhen 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).X


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

$16336401898647* XTest 1/2X
$32314337981189* XCheckX
$13880985462901* XMake a circuit where the input of a component depends on its own outputX
$73467991035922* XNope!X
$89309211963063* XTest 2/2X
$22446480186064* XCreate a circular dependency involving at least 2 componentsX


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



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

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


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

$46223188985873* XWith 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.X
$44276233109848* X2 Bit DecoderX


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

$55162862394836* XInstructionX
$35299017249605* XDesired modeX


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

$84095392269624* XModuloX
$87605997307596* XOutput 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).X


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

$78694087261378* XHub PreviewX


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

$86940018019179* XInvalid identifier: %{operand}X
$76203559781109* XExpected ']' or ':', got '{sep}'X
$16677833364088* XUnrecognized identifier: %{operand}X
$49919016022369* XUnrecognized address: ${identifier}X
$50863314907270* XExpected ')'X
$36919792698704* XInstruction pointer not availableX
$14037712136328* XOperand {op} not foundX
$62520916869207* XExpected ','X
$18996202754936* XExpected ')'X
$17795651801484* XExpected ':'X
$15525193700799* XUnrecognized prefix operator X
$21791372106633* XExpected '('X


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

$75546240775660* XExpected output: {value}.X
$85392755740261* XOutput should not be enabled.X
$51132330915663* XOutput not enabled.X
$18540192543555* XRegister {reg_i} should have value {value}.X


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

$18968293717104* XOne way is comparing digit by digit like we do for decimal numbersX
$45223418140453* XLike 09 < 21 because 0 < 2, so 1100 > 1001 because 11XX > 10XXX


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

$74639900282369* Xunsigned {n}-bit immediateX
$18299156828551* Xsigned {n}-bit immediateX

# Assembly label
$17885987456433* XlabelX
$12246885387560* Xvariable {name}X


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

$44523532982427* XWhen the bit selector input is [F], output Byte A, otherwise output Byte B.X
$66984132947598*
XEven 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.X
$75861961518456* XMultiplexerX


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

$80031998727851* XPan upX
$52159578521318* XPasteX
$93140495547084* XPan downX
$50610605761210* XRedoX
$88238310953306* XCutX
$13231048881956* XReset cycleX
$60118970740682* XRunX
$78515694621006* XPan leftX
$88236351843942* XRotateX
$58442122157391* XColor wireX
$74309706297402* XCopyX
$55156524671891* XWire color 5X
$78777350869870* XPress new keyX
$96339976117958* XPipette wireX
$33884219481037* XPan rightX
$86574817679356* XNext cycleX
$76995246992803* XWire color 10X
$21380256293472* XSelect allX
$53266310714298* XControlX
$66251711975517* XWire color 9X
$96449970906640* XComment wireX
$87273391208106* XWire color 0X
$64529333110609* XWire color 7X
$77819900580235* XWire color 2X
$67362258372706* XColor wire clusterX
$96601731563408* XOpen consoleX
$36372993787575* XWire color 1X
$58334563411624* XUndoX
$15032124477918* XWire color 4X
$83373647697807* XWire color 3X
$78673220868687* XWire color 8X
$20313704155593* XWire color 6X


=== campaign/always_on/ui.txt ===



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

$21613887420121* XA simple circuit where the input depends on its own output is a looped NOT gateX
$57091568089512* XNote the red erroneous wireX
$64834808154176* XThis is an error in other levels, but the goal of this oneX


=== campaign/symphony_3_alu/hint_solution.txt ===

$90347458725803* XThe new orange wires feed the opcode to the ALUX
$23277299590423* XReplace the NAND gate with the ALU componentX


=== campaign/byte_less_s/label.txt ===



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

$12955769263032* XInputX
$23494294864855* XMin {unit}X
$95419083709418* XLittle endianX
$39851490511821* XLocation modeX
$12729457392140* X{size} GBX
$45584048068675* XInput 1X
$36741466396909* XInput 2X
$14913356525578* XCostX
$26116781897961* XCostX
$10792411581963* X{size} MBX
$65254105186908* XOutputX
$50488075986026* XOutputX
$76120552154698* XInput 0X
$50011261574308* XInput 1X
$85815999713437* XInput 1X
$14527438551030* XInputX
$77252050278971* XOutputX
$32492998000365* XInput 0X
$52764622766005* XOutputX
$12806857886815* XBit 0X

# com_static_eval's expression
$32721727081818* XExpressionX
$64695289448271* XThe 8 bits of the value each turn on 1 of the 8 areas of the display.X
$55717355371460* XOutputX
$40353371905977* XConstantX
$89612128414294* XLabel directionX
$88655619989708* XInput 0X
$12673774208656* XBit 1X
$31208530565026* XInput 0X
$58805963760936* XPositive shifts right, negative shifts leftX
$53201813578269* XAssemblerX
$71918065858983* XSaveX
$49848147518867* XInput 2X
$91063734228931* XLeftX
$69729205667293* XHex EditorX
$58366024847549* XInput 0X
$76125262162505* XInput 1X
$23854618911893* XSimulated delayX
$97169317610794* XUpX
$65186041856822* XOutputX
$76078010638637* XEnableX
$90286330794518* XOutputX
$34792822299047* XInput 1X
$47647445869837* XZeroesX
$82521178851608* XInput 0X
$18430168550669* XResultX
$48920514303805* XFoundryX
$10634456248075* XInput 1X
$78475032277779* XInput 0X
$10967837475411* XInput 1X
$88881918807029* XImmutableX
$81678588906692* XHalt messageX
$60193172250813* XThe setting you have chosen for this component will take up {size} of memory on your computer. Are you OK with this?X
$17231618567710* XInit dataX
$59987930153159* XOutputX
$16406822661708* XInputX
$95766090310621* XRightX
$86658255589213* XMutable dataX
$61114700325299* XInput 0X
$30447216087962* XShiftX
$75293122338496* XPipeline depthX
$27295540163510* XInput 1X
$64034551286307* XPersistentX
$24632471752785* XFileX
$13973719570693* XSizeX
$84542005958715* XLabelX
$80252365204151* XPunch CardX

# Load a level
$41294322771286* XLoadX
$70002762618597* XDownX
$65365515206856* XNote: Although the component stores many key up & key down event, it only outputs one per cycle!X
$39848783424235* XInputX
$56555605872372* XOutputX


=== campaign/symphony_cmp/ui.txt ===

$73310930628112* XImplement the Symphony flagsX


=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* XAdd the ALU to SymphonyX


=== campaign/symphony/default.isa ===



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

$53269020658041* XThe screenX


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

$25269304368822*
XIn 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).

X


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

$77112891598455* XMultiply two numbersX


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

$88637818475024* XThen we check a byte is 0 by checking all its bits are [F]X
$85034261531833* XAn XOR of 2 numbers is 0 if and only if they are equalX


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

$71466914240996*
XThis 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]X
$83283206082997* XConditionsX


=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* XThat, though, is left as an exercise to the player!X
$55687805352825* XThis solution is by no means the most elegant or optimalX


=== campaign/saving_gracefully/label.txt ===

$88860903896097* XSaveX


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


# com_clz's input pin
$15988469904002* XInputX

# com_maker_bit_8's name
$18747779812970* XMakerX

# com_lsl's output pin
$14132199132916* XResultX

# com_mux's output pin
$10003014068713* XOutputX

# com_maker_word_2's name
$14812135740513* XWord MakerX

# com_maker_bit_8's output pin
$14889574903079* XResultX

# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* XIOX

# com_probe_memory_word's name
$18495107507052* XMemory ProbeX

# com_level_output_4_pin's input pin
$39260627694444* XOutput 3X

# com_probe_wire_asm's name
$53494192640542* XDisassembling probeX

# com_ctz's input pin
$13829181406158* XInputX

# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* XVerilogX

# com_splitter_word_8's input pin
$11440186157356* XInputX

# com_nand_word's name
$17989404583269* XNANDX

# com_neg's description
$12021716182809* XNegates the inputX

# com_screen's input pin
$63216408139965* XEnableX

# com_full_adder's input pin
$11264799740288* XInput 0X

# com_splitter_word_2's output pin
$13625849577132* XWord 0X

# com_maker_bit_8's input pin
$17957417956069* XBit 3X

# com_keyboard's output pin
$12465282633818* XKey valueX

# com_maker_word_8's input pin
$12616927929524* XWord 3X

# com_nand_word's input pin
$11578787451669* XInput 1X

# com_mux's input pin
$12687047365426* XValue 0X

# com_register_word's late input pin
$13298317818150* XSave enableX

# com_level_output_8_pin's input pin
$62385154489080* XOutput 2X

# com_xor_word's output pin
$10269927015049* XResultX

# com_nor_word's output pin
$11938328576163* XResultX

# com_splitter_bit_2's output pin
$10655485270988* XBit 0X

# com_xnor_word's output pin
$17089816656649* XResultX

# com_nand_word's description
$10859914201083* XBitwise NAND two valuesX

# com_load_port's name
$16380513614754* XLoad portX

# com_lsl's input pin
$12849468178655* XValueX

# com_nor_bit's description
$17510848535619* X[T] when neither inputs are [T]X

# com_clz's output pin
$10092537578053* XResultX

# com_probe_memory_bit's name
$12318534735397* XMemory Probe (bit)X

# com_delay_line_word_config's description
$18447417990806* XStores the input for 1 cycleX

# com_splitter_word_8's output pin
$14592399073683* XWord 7X

# com_static_eval's output pin
$89594489498667* XResult as valueX

# com_full_adder's input pin
$18480011054605* XCarry inX

# com_time's description
$18774996925434* XNano seconds since January 1st 1970X

# com_register_bit's late input pin
$18405644304073* XValueX

# com_concatenator_2's input pin
$18414950181373* XWire 1X

# com_splitter_word_4's output pin
$11345730126879* XWord 0X

# com_cc_level_input's description
$19864966939331* XAn input that will be converted to custom input, if the solution is saved to the foundryX

# com_xor_word's description
$13236921580268* XBitwise XOR two valuesX

# com_splitter_word_8's output pin
$18541722201520* XWord 2X

# com_mul's output pin
$11838813794006* XResultX

# com_concatenator_8's input pin
$17908668221433* XWord 7X

# com_nand_bit's name
$11130919681688* XNANDX

# com_asr's output pin
$11521973612539* XResultX

# com_maker_word_8's input pin
$18747558269936* XWord 7X

# com_static_value's name
$17192199509688* XStatic ValueX

# com_splitter_bit_8's output pin
$10491931394044* XBit 3X

# com_lsr's input pin
$16105779236896* XValueX

# com_and_word's input pin
$11977039914327* XInput 0X

# com_level_output_8_pin's input pin
$64999131838438* XOutput 4X

# com_delay_line_bit's description
$18206009264853* XStores the input for 1 cycleX

# com_level_input_3_pin's output pin
$65765566466116* XInput 0X

# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* XMultiX

# com_concatenator_8's input pin
$12341255296823* XWord 1X

# com_concatenator_8's input pin
$11115698874478* XWord 0X

# com_verilog_output's input pin
$19276197821142* XInputX

# com_delay_line_word_config's name
$19421095581293* XAuto Delay LineX

# com_decoder_3's output pin
$16637198920534* XBit 1X

# com_maker_bit_8's input pin
$10716205698752* XBit 5X

# com_delay_line_word's name
$17407828844862* XDelay LineX

# com_level_output_counter's input pin
$89669851602178* XOutput 2X

# com_probe_wire_word's description
$15969687819995* XDisplay a value on your custom component or in the program editorX

# com_less_s's description
$12765625016236* XChecks if the first input is less than the second oneX

# com_maker_bit_4's description
$18837875001662* XMerges 4 bits into one 4-bit valueX

# com_xnor_word's name
$12087865653212* XXNORX

# com_cc_level_output's description
$12051024347384* XA word output that will be converted to IO pin if level solution is saved as a componentX

# com_constant's description
$12424468899005* XConstant valueX

# com_decoder_2's name
$11727998752868* X2 Bit DecoderX

# com_asr's name
$11034107377099* XArithmetic Shift RightX

# com_full_adder's output pin
$10918445419498* XResultX

# com_splitter_word_4's input pin
$12938882109013* XInputX

# com_splitter_bit_8's output pin
$18437214963047* XBit 7X

# com_neg's input pin
$11637742665554* XInputX

# com_counter's output pin
$10629272823895* XCountX

# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* XMiscX

# com_mod's input pin
$17244932190980* XDivisorX

# com_register_bit's output pin
$14834136969633* XResultX

# com_delay_line_word_config's late input pin
$11320392055125* XInputX

# com_cc_output's name
$10557704838301* XOutput PinX

# com_level_output_3_pin's name
$16269858195218* XOutputX

# com_maker_bit_4's name
$11119510732154* XMakerX

# com_static_indexer_config's output pin
$11132082500971* XResultX

# com_concatenator_8's input pin
$12384635971036* XWord 5X

# com_level_output_switched's description
$18319747827404* XSwitched outputX

# com_decoder_3's input pin
$10755367544042* XInputX

# com_keyboard's input pin
$18168295822085* XRead nextX

# com_push_button's name
$20020953885936* XPush ButtonX

# com_splitter_bit_2's input pin
$12046095993506* XInputX

# com_register_bit's description
$17670626909848* X1 bit of memoryX

# com_switch_bit's description
$16917313833836* XToggles a bitX

# com_segment_display's input pin
$14849689592952* XValueX

# com_verilog_input's output pin
$13351141217116* XInputX

# com_level_output_counter's name
$12247325526438* XCounterX

# com_probe_wire_word's input pin
$14914933156268* XValueX

# com_nand_bit's description
$12903183841172* X[T] unless both inputs are [T]X

# com_maker_word_4's description
$15410415450178* XMerges 4 (n/4)-bit values into one n-bit valueX

# com_static_indexer_config's description
$85065774878853* XAdvanced version of "static indexer". Shift and output size is inferred from the size of wires connected to input pinsX

# com_maker_word_4's input pin
$13236424504117* XWord 2X

# com_lsr's input pin
$10335381544532* XShift byX

# com_level_input_2_pin's description
$14340334686746* XTwo bit inputX

# com_div's output pin
$19403575811053* XResultX

# com_screen's name
$12046117430308* XScreenX

# com_decoder_2's output pin
$11297026031742* XBit 2X

# com_xnor_word's description
$15789912406647* XBitwise XNOR two valuesX

# com_static_indexer_config's name
$10289043699917* XAuto Static IndexerX

# com_store_port's input pin
$18001316449428* XAddressX

# com_maker_bit_8's input pin
$13104890311933* XBit 1X

# com_mod's description
$10934212906097* XModulo 2 numbersX

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

# com_static_eval's description
$16874064281189* XCalculates a value before simulation (it becomes a constant during simulation)X

# com_level_output_word's name
$11300749636961* XOutputX

# com_asr's description
$15194709458499* XShifts bits to the right, while maintaining the sign of the numberX

# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* XMathX

# com_level_input_switched's output pin
$69212597107829* XInputX

# com_verilog_output's name
$12353364840899* XVerilog OutputX

# com_counter's description
$12736827510023* XIncrements each cycle, unless overwrittenX

# com_maker_word_8's input pin
$12592072659210* XWord 1X

# com_level_input_1_pin's name
$12746117288689* XInputX

# com_level_gate's name
$11417416554850* XLevel ComponentX

# com_maker_bit_8's input pin
$14944669923906* XBit 7X

# com_level_output_4_pin's description
$18308856504509* XFour bit outputX

# com_decoder_1's name
$18250587600120* X1 Bit DecoderX

# com_maker_word_4's input pin
$15232070727738* XWord 1X

# com_level_output_3_pin's description
$13174121812559* XThree bit outputX

# com_xnor_word's input pin
$19329533997829* XInput 0X

# com_add's output pin
$16559516323162* XResultX

# com_maker_bit_8's input pin
$11634467729625* XBit 4X

# com_less_u's output pin
$15024221028085* XResultX

# com_and_bit's name
$18912167455465* XANDX

# com_level_input_3_pin's name
$10689623552857* XInputX

# com_splitter_word_2's description
$15417695246232* XSplits a (2n)-bit value into two n-bit valuesX

# com_splitter_word_2's input pin
$19630801846451* XInputX

# com_concatenator_8's name
$16974631589430* XConcatenatorX

# com_static_value's output pin
$10920459933396* XValueX

# com_and_word's name
$12926911335769* XANDX

# com_switch_word's output pin
$11625195403324* XOutputX

# com_div's name
$14959426271423* XDivideX

# com_less_s's output pin
$11019209691112* XResultX

# com_ror's name
$12093087039542* XRotate RightX

# com_decoder_3's output pin
$18208851966397* XBit 3X

# com_nor_word's input pin
$10770218762282* XInput 0X

# com_less_u's name
$13502755965496* XLow < (unsigned)X

# com_concatenator_4's output pin
$16450922709110* XResultX

# com_and_bit's description
$12719674432950* X[T] when both inputs are [T]X
$87754378235471* XOutputX

# com_register_word's description
$13576980017857* XSmall memory componentX

# com_concatenator_4's input pin
$13331778821779* XWord 0X

# com_cc_level_output's name
$15625973306519* XOutputX

# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* XOutputsX

# com_xor_word's input pin
$16674052164634* XInput 0X

# com_level_input_4_pin's name
$11447837612693* XInputX

# com_cc_input's description
$13263310288543* XInput pinX

# com_level_output_word's description
$16148744080822* XWord output that will be converted to IO pin if level solution is saved as a componentX

# com_maker_word_8's name
$17581447274882* XWord MakerX

# com_concatenator_8's description
$12443053648819* XConcatenates 8 values, the output width is the sum of all input widthsX

# com_xor_word's name
$16843812162355* XXORX

# com_register_word_config's input pin
$11057152094224* XSizeX

# com_cc_output's description
$10781578424003* XOutput pinX

# com_nor_word's description
$14517798310461* XBitwise Nor two valuesX

# com_store_port's name
$13159020985209* XStore portX

# com_level_input_1_pin's output pin
$12465938629713* XInputX

# com_not_bit's description
$10844421681709* XInverts the inputX

# com_splitter_word_8's output pin
$19903808503639* XWord 1X

# com_splitter_word_2's name
$12723870092766* XSplitterX

# com_verilog_input's name
$19796166910463* XVerilog InputX

# com_nand_word's output pin
$18604301487974* XResultX

# com_level_gate's description
$13259215761047* XUsed for creating level mapsX

# com_register_word_config's name
$17630501850089* XAuto RegisterX

# com_rol's input pin
$13135722015590* XRotate byX

# com_splitter_word_8's name
$18008204445107* XSplitterX

# com_switch_word's input pin
$12550214308917* XValueX

# com_probe_memory_word's description
$12492235992906* XDisplay a value on your custom component or in the program editorX

# com_not_word's input pin
$18100827224098* XInputX

# com_concatenator_2's input pin
$12329350771997* XWire 2X

# com_verilog_input's description
$14408471620057* XVerilog inputX

# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* XInputsX

# com_or_word's output pin
$18599325743999* XResultX

# com_xor_bit's description
$16856280609387* X[T] when inputs are differentX

# com_inc's name
$14456039381703* XIncrementX

# com_maker_word_2's output pin
$11293966912554* XResultX

# com_ctz's description
$10231593934948* XCount 0s from the least significant digit until the first 1X

# com_keyboard's output pin
$14338437722935* XKey downX

# com_decoder_3's output pin
$12390018918095* XBit 7X

# com_splitter_word_4's output pin
$16099286786157* XWord 3X

# com_add's name
$13973952772642* XAddX

# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* XDisplaysX

# com_level_output_4_pin's input pin
$16259545926196* XOutput 0X

# com_mul's description
$18631919890554* XMultiplies two inputsX

# com_static_indexer_config's input pin
$12633414511976* XSizeX

# com_splitter_bit_4's name
$10524104374521* XSplitterX

# com_concatenator_4's input pin
$18970466583796* XWord 2X

# com_splitter_bit_8's output pin
$17163920171569* XBit 6X

# com_on's name
$15896157427528* XONX

# com_and_3_bit's name
$19664974941910* X3 Pin ANDX

# com_switch_word's description
$17345192339084* XToggles a valueX

# com_splitter_bit_8's output pin
$13666042416530* XBit 2X

# com_cc_level_input's name
$16810631435170* XInputX

# com_maker_bit_8's input pin
$14770992007366* XBit 6X

# com_concatenator_4's name
$15908922745328* XConcatenatorX

# com_level_output_switched's input pin
$11520072088720* XEnableX

# com_splitter_word_4's description
$12370556827575* XSplits a (4n)-bit value into four n-bit valuesX

# com_splitter_bit_8's output pin
$17664445405251* XBit 5X

# com_delay_line_bit's name
$12121899638400* XDelay LineX

# com_decoder_3's output pin
$14688114733776* XBit 5X

# com_screen's input pin
$55023356915123* XSetting indexX

# com_counter's late input pin
$17764401720104* XOverwrite valueX

# com_decoder_2's description
$86848277190736* XToggles between four outputs based on a 2 bit input pinX

# com_probe_wire_bit's description
$15206117280094* XDisplay a value on your custom component or in the program editorX

# com_mul's input pin
$14896244080868* XInput 0X

# com_register_word's name
$16007777261800* XRegisterX

# com_level_input_4_pin's output pin
$81933801309767* XInput 0X

# com_level_output_4_pin's name
$10190739202646* XOutputX

# com_maker_bit_8's input pin
$17515061804367* XBit 0X

# com_splitter_word_8's output pin
$18425501753807* XWord 0X

# com_decoder_3's name
$14375716460090* X3 Bit DecoderX

# com_splitter_bit_4's output pin
$10111764008386* XBit 2X

# com_concatenator_2's output pin
$17758165407719* XResultX

# com_level_output_8_pin's name
$13087193858087* XOutputX

# com_and_word's description
$11791872137683* XBitwise AND two valuesX

# com_level_output_counter's description
$19047791955795* XThree bit outputX

# com_ctz's output pin
$19883191600386* XResultX

# com_mux's input pin
$15091015683874* XSelect 0 / 1X

# com_level_output_3_pin's input pin
$39908016538045* XOutput 0X

# com_ror's description
$10802217509530* XRotates the bits of an input rightX

# com_div's description
$19251828025705* XDivide 2 numbersX

# com_switch_word's name
$10611658692685* XSwitchX

# com_delay_line_word's description
$53901484249817* XStores the input for 1 cycleX

# com_maker_bit_4's input pin
$13826250945595* XBit 3X

# com_maker_word_2's description
$11048127331082* XMerges 2 (n/2)-bit values into one n-bit valueX

# com_or_word's description
$19406015796751* XBitwise OR two valuesX

# com_less_u's input pin
$16307028951926* XInput 1X

# com_store_port's input pin
$18196820862263* XEnableX

# com_register_word_config's late input pin
$19717901345023* XSave enableX

# com_splitter_bit_8's output pin
$10688845521356* XBit 1X

# com_register_word_config's description
$19209488297941* XAutomatically resizable version of the registerX

# com_level_output_word's input pin
$27680966493404* XOutputX

# com_push_button's description
$57617462098732* XOutput [T] while the button is pressedX

# com_level_output_switched's name
$19513138880387* XSwitched OutputX

# com_probe_wire_asm's late input pin
$12365938365321* XInputX

# com_ctz's name
$19218324472471* XCount trailing zeroX

# com_full_adder's output pin
$18410639135888* XCarry outX

# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* XCustomX

# com_load_port's output pin
$17988237627670* XOutputX

# com_time's name
$16011300295966* XTimeX

# com_level_input_3_pin's output pin
$79311371309532* XInput 1X

# com_not_bit's name
$14453052824732* XNOTX

# com_xor_bit's name
$14832952840086* XXORX

# com_lsr's description
$19394421220436* XShifts the bits of an input rightX

# com_level_input_3_pin's description
$16604606953092* XThree bit inputX

# com_splitter_bit_8's output pin
$17053062486634* XBit 4X

# com_maker_bit_2's input pin
$11752209410617* XBit 1X

# com_maker_word_8's input pin
$19779691531031* XWord 5X

# com_maker_bit_4's input pin
$17897455882076* XBit 1X

# com_splitter_word_4's output pin
$15360783001914* XWord 2X

# com_load_port's input pin
$19069820293504* XAddressX

# com_asr's input pin
$12408847893200* XShift byX

# com_register_word_config's output pin
$84598344098990* XvalueX

# com_screen's description
$19974317694842* XConfigurable screenX

# com_lsl's input pin
$19120200575252* XShift byX

# com_static_value's output pin
$15833633678405* XBit sizeX

# com_level_output_4_pin's input pin
$87954408093587* XOutput 2X

# com_level_output_8_pin's input pin
$38015555977208* XOutput 3X

# com_maker_word_8's input pin
$19740232065347* XWord 0X

# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* XIOX

# com_or_word's input pin
$11335506036805* XInput 1X

# com_level_input_2_pin's name
$16870364449392* XInputX

# com_level_output_counter's input pin
$86331851878040* XOutput 1X

# com_level_input_switched's input pin
$14935676453720* XEnableX

# com_cc_input's name
$17814826739168* XInput PinX

# com_store_port's description
$17240636780043* XAdd a store pin to a memory componentX

# com_level_input_3_pin's output pin
$42291627335021* XInput 2X

# com_concatenator_4's input pin
$19277763516215* XWord 3X

# com_asr's input pin
$18563543025377* XValueX

# com_level_delay_gate's name
$13161432526100* XLevel And Delay ComponentX

# com_splitter_word_8's description
$15228522216068* XSplits an (8n)-bit value into eight n-bit valuesX

# com_or_word's input pin
$15962339721851* XInput 0X

# com_xor_word's input pin
$19719622211817* XInput 1X

# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* XLogicX

# com_ror's input pin
$13521735131997* XRotate byX

# com_splitter_bit_2's description
$18566798809283* XSplits a 2-bit value into 2 bitsX

# com_level_input_4_pin's output pin
$45891070331034* XInput 1X

# com_level_input_2_pin's output pin
$55925432534232* XInput 1X

# com_decoder_1's description
$16685462633615* XToggles between two outputsX

# com_static_value's description
$17781742628050* XEasily set values or width on individual custom componentsX

# com_level_output_2_pin's name
$13255344581755* XOutputX

# com_xnor_word's input pin
$19579585753615* XInput 1X

# com_load_port's input pin
$18399493738021* XEnableX

# com_counter's late input pin
$16380665909610* XOverwriteX

# com_maker_bit_2's description
$14531866237078* XMerges 2 bits into one 2-bit valueX

# com_delay_line_bit's late input pin
$43397945955203* XInputX

# com_inc's input pin
$19579388993928* XInputX

# com_inc's output pin
$15310910823919* XResultX

# com_splitter_bit_8's input pin
$16196769003341* XInputX

# com_splitter_bit_4's output pin
$15744234453408* XBit 3X

# com_cc_level_output's input pin
$17030391013189* XOutputX

# com_keyboard's output pin
$13705122401876* XEvent waitingX

# com_level_input_2_pin's output pin
$24473197268827* XInput 0X

# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* XDevX

# com_probe_wire_bit's input pin
$10499689720024* XValueX

# com_less_u's description
$18645721548287* XChecks if the first input is less than the second oneX

# com_level_output_switched's input pin
$17979647868788* XOutputX

# com_decoder_3's output pin
$15527856774069* XBit 2X

# com_splitter_word_4's name
$16563671560208* XSplitterX

# com_mod's input pin
$11352468367638* XDividendX

# com_decoder_3's output pin
$17090003684860* XBit 4X

# com_switch_bit's name
$11574334638147* XSwitchX

# com_equal's output pin
$17864898529357* XResultX

# com_probe_wire_bit's name
$19521764791439* XWire Probe (bit)X

# com_equal's name
$19369982838671* XEqualX

# com_maker_word_8's input pin
$13378739117488* XWord 6X

# com_register_word's output pin
$58518173140953* XValueX

# com_concatenator_8's input pin
$11366501215506* XWord 2X

# com_decoder_3's input pin
$16773243310913* XDisableX

# com_decoder_2's output pin
$19275565166747* XBit 0X

# com_mux's input pin
$12520768681157* XValue 1X

# com_full_adder's input pin
$11312161634667* XInput 1X

# com_less_s's input pin
$15432695156488* XInput 0X

# com_concatenator_8's output pin
$12478474747295* XResultX

# com_maker_bit_2's output pin
$18060429242565* XResultX

# com_concatenator_2's description
$10776829749898* XConcatenates 2 values, the output width is the sum of all input widthsX

# com_add's output pin
$10815269647822* XCarry outX

# com_splitter_bit_2's output pin
$17293853955838* XBit 1X

# com_and_word's output pin
$16806711173957* XResultX

# com_decoder_3's output pin
$13138546420646* XBit 6X

# com_splitter_word_8's output pin
$17425893786880* XWord 6X

# com_concatenator_4's input pin
$12371272172145* XWord 1X

# com_splitter_bit_8's description
$10488114435022* XSplits a byte into 8 bitsX

# com_maker_bit_8's description
$14338505460996* XMerges 8 bits into one byteX

# com_register_word_config's late input pin
$18592599175225* XSave valueX

# com_splitter_word_8's output pin
$11465347976002* XWord 3X

# com_splitter_bit_4's description
$16428357982878* XSplits a 4-bit value into 4 bitsX

# com_maker_word_2's input pin
$18365137610205* XWord 0X

# com_level_output_4_pin's input pin
$29217965518477* XOutput 1X

# com_level_output_1_pin's input pin
$50802766489958* XOutputX

# com_splitter_word_4's output pin
$15566912320742* XWord 1X

# com_or_bit's description
$13013154620359* X[T] when either input is [T]X

# com_probe_wire_word's name
$14427436420428* XWire ProbeX

# com_and_3_bit's description
$16839706221116* X3-input AND gateX

# com_concatenator_8's input pin
$10080083255838* XWord 3X

# com_level_output_counter's input pin
$84023157447564* XOutput 0X

# com_mul's name
$16549841656852* XMultiplyX

# com_level_output_8_pin's input pin
$39299381405096* XOutput 0X

# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* XLevelsX

# com_splitter_bit_2's name
$13766521376720* XSplitterX

# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* XMemoryX

# com_or_word's name
$17053670145576* XORX

# com_level_input_word's output pin
$21448308897245* XInputX

# com_keyboard's description
$16766452660421* XRecords keypresses from your physical keyboardX

# com_halt's description
$12990744955549* XStops execution with a custom messageX

# com_neg's name
$18379907297327* XNegateX

# com_clz's name
$11678932883790* XCount leading zeroX

# com_clz's description
$18865460617183* XCount 0s from the most significant digit until the first 1X

# com_probe_wire_asm's late input pin
$18082830776248* XAddressX

# com_static_eval's output pin
$29937009351190* XResult as sizeX

# com_concatenator_8's input pin
$19112189486457* XWord 6X

# com_store_port's input pin
$17908666907710* XStore valueX

# com_level_output_8_pin's description
$41781588125341* XFour bit outputX

# com_equal's description
$15668435514829* XChecks if the two inputs are equalX

# com_maker_word_8's input pin
$19068496076705* XWord 2X

# com_level_output_8_pin's input pin
$72375982885383* XOutput 1X

# com_not_word's name
$11286216680410* XNOTX

# com_concatenator_4's description
$15492861320167* XConcatenates 4 values, the output width is the sum of all input widthsX

# com_mod's name
$16223673009720* XModuloX

# com_full_adder's name
$17669928463861* XFull AdderX

# com_maker_bit_2's input pin
$14834270613682* XBit 0X

# com_delay_line_word's late input pin
$12644592179746* XInputX

# com_level_output_8_pin's input pin
$88250281919265* XOutput 5X

# com_cc_level_input's output pin
$59388037506003* XInputX

# com_level_input_switched's description
$16797889673362* XLoads the input from levelsX

# com_xnor_bit's description
$10614106399129* X[T] when inputs are the sameX

# com_delay_line_word_config's input pin
$13271299225650* XSizeX

# com_switch_word's input pin
$12784430582183* XEnableX

# com_nor_word's input pin
$19354802063529* XInput 1X

# com_off's description
$12749460799924* XAlways [F]X

# com_add's description
$18429814030509* XAdds two inputsX

# com_decoder_3's description
$61176454433312* XToggles between eight outputs based on a 3 bit input pinX

# com_counter's name
$18007194288764* XCounterX

# com_screen's input pin
$88137790657923* XValueX

# com_register_bit's name
$12678278048629* XRegisterX

# com_maker_word_8's description
$15845204308823* XMerges 8 (n/8)-bit values into one n-bit valueX

# com_register_bit's late input pin
$17744526831576* XEnableX

# com_maker_bit_2's name
$12602955212919* XMakerX

# com_halt's name
$10351143139905* XHaltX

# com_level_output_1_pin's name
$12242923444593* XOutputX

# com_on's description
$16212935718484* XAlways [T]X

# com_level_input_switched's name
$11278573510238* XSwitched InputX

# com_splitter_word_8's output pin
$19229992367375* XWord 5X

# com_equal's input pin
$13859686951415* XInput 0X

# com_ram's description
$19814732518166* XLarge memory componentX

# com_or_3_bit's description
$17576327690867* X3-input OR gateX

# com_level_output_8_pin's input pin
$90233476470983* XOutput 7X

# com_static_indexer's name
$19804933576629* XStatic IndexerX

# com_level_input_word's description
$11342065742485* XWord inputX

# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* XBitX

# com_or_bit's name
$17247779246257* XORX

# com_add's input pin
$17802619460312* XCarry inX

# com_maker_bit_4's output pin
$18538545767544* XResultX

# com_decoder_2's output pin
$15898724303882* XBit 3X

# com_inc's description
$11449663590476* XIncrements the input by 1X

# com_rol's name
$16755142829250* XRotate LeftX

# com_level_input_4_pin's output pin
$36196915566111* XInput 3X

# com_xnor_bit's name
$14079327237795* XXNORX

# com_rol's output pin
$19903955254861* XResultX

# com_maker_bit_4's input pin
$14237744302250* XBit 0X

# com_delay_line_bit's output pin
$11945697622944* XResultX

# com_mux's name
$15422378975821* XMuxX

# com_static_eval's name
$16294314784377* XStatic EvaluatorX

# com_concatenator_2's name
$17495243848605* XConcatenatorX

# com_not_word's output pin
$15635980858172* XResultX

# com_div's input pin
$11611913368782* XDivisorX

# com_load_port's description
$16440979564796* XAdd a load pin to a memory componentX

# com_rol's input pin
$10762061266647* XValueX

# com_level_output_3_pin's input pin
$17644027370563* XOutput 2X

# com_and_word's input pin
$18149321315676* XInput 1X

# com_level_output_8_pin's input pin
$15649241608462* XOutput 6X

# com_lsr's output pin
$19748092068880* XResultX

# com_or_3_bit's name
$19630419947500* X3 Pin ORX

# com_level_output_2_pin's input pin
$18282543476901* XOutput 0X

# com_maker_word_4's name
$16610055905190* XWord MakerX

# com_segment_display's description
$16761198694928* XGood for displaying numbersX

# com_decoder_3's output pin
$19041825668970* XBit 0X

# com_full_adder's description
$17559382166174* XAdds 3 bits and outputs the sum and the carryX

# com_not_word's description
$10624873506476* XBitwise flip bitsX

# com_nand_word's input pin
$10425218359878* XInput 0X

# com_maker_bit_4's input pin
$14852108377004* XBit 2X

# com_time's output pin
$18510923212418* XNano seconds since Jan 1st 1970X

# com_segment_display's name
$10582128204153* X7 Segment DisplayX

# com_mul's input pin
$14913258317738* XInput 1X

# com_maker_bit_8's input pin
$19209724501083* XBit 2X

# com_level_input_4_pin's output pin
$70142958857584* XInput 2X

# com_keyboard's name
$10965596602414* XKeyboardX

# com_lsr's name
$12931148241340* XShift RightX

# com_less_s's name
$15403981009644* XLess < (signed)X

# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* XProbesX

# com_off's name
$11860786587357* XOFFX

# com_equal's input pin
$17767800149691* XInput 1X

# com_level_input_word's name
$10943344093513* XInputX

# com_neg's output pin
$12196354295621* XResultX

# com_maker_word_4's output pin
$12262460678043* XResultX

# com_add's input pin
$18009367936916* XInput 1X

# com_splitter_bit_8's name
$11904470559153* XSplitterX

# com_splitter_word_2's output pin
$13510688527850* XWord 1X

# com_splitter_bit_4's input pin
$12060097589370* XInputX

# com_maker_word_4's input pin
$15693531522415* XWord 0X

# com_level_output_2_pin's description
$14875690243444* XTwo bit outputX

# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* XWordX

# com_level_output_2_pin's input pin
$44555908976270* XOutput 1X

# com_maker_word_4's input pin
$17742753106024* XWord 3X

# com_concatenator_8's input pin
$15759275278695* XWord 4X

# com_static_indexer's description
$16103423834548* XShift the values on a wire by fixed amount at no delay or gate cost. Positive values shift right, negative shift leftX

# com_ror's output pin
$16261916666444* XResultX

# com_nor_bit's name
$13375115196253* XNORX

# com_decoder_2's output pin
$10762093809413* XBit 1X

# com_mux's description
$11168613697835* XToggles between two valuesX

# com_probe_memory_bit's description
$16875362121056* XDisplay a value on your custom component or in the program editorX

# com_static_indexer_config's input pin
$11349557191063* XInputX

# com_delay_line_word's output pin
$40182352594863* XResultX

# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* XAutoX

# com_ram's name
$11710093917097* XRAMX

# com_lsl's description
$16482114876737* XShifts the bits of an input leftX

# com_maker_word_8's output pin
$11351867388170* XResultX

# com_maker_word_2's input pin
$16178897760565* XWord 1X

# com_nor_word's name
$12175906806727* XNORX

# com_less_s's input pin
$16118461327893* XInput 1X

# com_level_input_1_pin's description
$13272198916233* XOne bit inputX

# com_add's input pin
$17820183531095* XInput 0X

# com_splitter_bit_4's output pin
$14645527447275* XBit 0X

# com_delay_line_word_config's output pin
$10757852071445* XResultX

# com_verilog_output's description
$14973155280765* XVerilog outputX

# com_maker_word_8's input pin
$19579002124406* XWord 4X

# com_static_indexer_config's input pin
$12869119410565* XShiftX

# com_rol's description
$15557725551789* XRotates the bits of an input leftX

# com_div's input pin
$18043895181775* XDividendX

# com_mod's output pin
$11329013865174* XResultX

# com_splitter_word_8's output pin
$16120663256468* XWord 4X

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

# com_lsl's name
$15268915597774* XShift LeftX

# com_less_u's input pin
$14201184715010* XInput 0X

# com_level_output_3_pin's input pin
$21084166025569* XOutput 1X

# com_level_output_1_pin's description
$18342586404936* XOne bit outputX

# com_constant's name
$15858905835416* XConstantX

# com_ror's input pin
$15762072154176* XValueX

# com_splitter_bit_4's output pin
$17862413256378* XBit 1X

# com_level_input_4_pin's description
$19187328896214* XFour bit inputX

# com_register_word's late input pin
$12420839132846* XSave valueX

# com_splitter_bit_8's output pin
$11548514728473* XBit 0X


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

$63693638857058* XIt contains {folders} folder(s).X
$86093358515620* XIt is an empty folder.X
$66107456188362* XIt contains {folders} folder(s) and {asm} .asm file(s).X
$93027749509988* XIt contains {asm} .asm file(s).X


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

$62678678871254* XAdd a program to the circuitX


=== campaign/odd_ticks/ui.txt ===



=== campaign/and_gate/ui.txt ===



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

$31400969059429* X{register} ('Register File' address {address}) should have hex value {expected_value}, not {actual_value}X
$29909286517152* XThe 'zr' register should always be zero (address 0 in the 'Register File').X
$18975134592059* XOutput should have been enabled.X
$42960087865089* XScreen setting {i} is supposed to be {expected_value}, not {value}X
$78917660933958* XMain Memory address {i} is supposed to have value {address}, not {value}X
$46474751521062* XLink the screen to the "Main Memory" component (use the little red button in the corner of the screen).X
$26871980917450* XPersistent Memory address {i} is supposed to have value {address}, not {value}X
$41024505081324* XYou should have read address {counter_value} from the Main Memory, not {actual_counter}. You must have not updated the counter correctly last cycle.X
$30816527015736* XOutput should have been {expected_output}, not {output_value}.X
$29202969341865* XWrong time output (did you remember to cache the time on the time_0 instruction?)X


=== campaign/byte_xor/label.txt ===



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

$69804974830322* XConnect the carry-in and carry-out of the level to complete the circuitX
$36646953278480* XCarry-out of the last bit is the carry-in of the nextX


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

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


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

$64907157003500* XNegative numbersX


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

$25715726162519* XEndiannessX


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

$26930827349244* XMoves a value to %a from %b.X


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

$13320201556243* XCreate the ISA spec for the new instructionsX


=== campaign/symphony_2_io/ui.txt ===

$76620689360899* XAdd IO mode to SymphonyX


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

$78963222298606* XAnd don't forget another switch to only output when LOAD is [T]X
$51243843817679* XUsing the [T] output of the decoder, we can enable the corresponding cell to load fromX


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

$17817215316423*
XThe 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.
X
$12296593054599* XOne hot encodingX


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

$78449227663032*
XThis 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).X
$46697878992908* XDouble the NumberX


=== presenter/markup/markup.nim ===

$66207112287034* XTIPX


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

$15352671410916* Xwith 8 being the number of bits and log2 the position of the first [T] bit.X
$75683304945175* XExcept for when Input is 0, this is the same as finding 8 - 1 - log2(Input),X
$83745112465243* XFinding log2 of binary numbers is very well-trodden ground in computer scienceX


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

$78090021698706* XSettingsX


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

$27583144414493* XInstructionsX


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

$85147529532131* XMulti select (Hotkey: SHIFT & drag)X
$78287906849040* XWire colorX
$68617247634978* XBit size (right click: change size)X
$84434122873489* XZoom outX
$42454393978813* XClick this button to run testsX
$80451578314373* XZoom inX
$36396661222670* XRight-click here to increase cycle speedX
$66405942066048* XPrevX
$39440928972984* XReset ({key})X
$53448014080434* XDelete (Hotkey: Right click)X
$80746616574054* XNext ({key}) (Right click for go to cycle)X
$69987793052607* XWire comment (Click on wire)X
$54853798559740* XRun fast ({key}) (right click: change speed)X


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

$17025412277453* XInput 1X
$84782011304318* XThe truth table tells us that the output is [T] if and only ifX
$62308032073140* Xeither the input 0 is [T] AND input 1 is [F] OR the input 0 is [F] AND input 1 is [T]X
$15534865654723* XInput 0X
$59092390409834* XDesired outputX


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

$27417572090527* XOutput not enabled.X
$45837083894306* XExpected output: {value}.X
$67011612338355* XRegister {reg_i} should have value {value}.X
$84026509534190* XOutput should not be enabled.X


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

$57024194971618*
XThe [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 valuesX


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

$82564442776805* XOutput not enabled.X
$17793323757435* XExpected output: {value}.X
$63497936956369* XOutput should not be enabled.X
$73489311755739* XRegister {reg_i} should have value {value}.X


=== presenter/console.nim ===

$63321577947087* XPress Enter to see manualX


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

$39788606928520* XThe circuitry for the 2's bit is what you did in "Double Detection", except when all 4 are onX
$20653200546136* XThe circuitry for the 1's bit is the same as what you did in the level "Odd Number of Signals"X


=== campaign/bit_switch/label.txt ===



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

$82367602514282* XDelayX


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

$41663630841312* XSaving BytesX
$87293777622656*
XCreate 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.X


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

$34539182309616* XA bigger AND is but multiple ANDs in successionX


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

$18258110894478* XThis level unlocks your first manual page. This one is important, make sure you pay attention to it.X
$61066799501731* XAlways OnX
$85978749941194* XCreate a circuit that is always [T].X


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

$68182570848466* XThe 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.X
$69806637130600* XFast SymphonyX


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

$79125097012724*
XThe 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]

X
$53539145017840* XASRX


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

$28574225028041* XSelect A or BX


=== 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* XThe new purple wires implement the interaction with the persistent memoryX


=== campaign/double_number/label.txt ===



=== campaign/symphony_condition_test/ui.txt ===



=== presenter/utilities.nim ===

$56798729463813* XLevel code broken.X
$18997072674417* X<Component> is not unlocked in this level.X
$32087108522443* XSize pins may only connect to other size pins.X
$14665712485657* XThis custom component can not be used as it has no area.X
$47880883686501* XCircular dependency - The output of a component leads back to its own input. See 'Circular dependency' in the manual.X
$45678915971282* XShort circuit inside <this> custom component.X
$45545544521085* XA <component> is in an invalid position.X
$48909199348313* XTests passed, but your solution uses more than {max_delay} delayX
$73948669941805* XTests passed, but your solution uses more than {max_gates} gatesX
$29718660090112* XWrong answerX
$27322222841583* XShort circuit between <> and <>X
$25337574230078* XTwo pins are on the same square.X

# Switched Input is the name under 11278573510238
$95056157627313* XYou cannot solve this level without adding a 'Switched Input' componentX
$44947135063289* XCircular dependency - The output of a component leads back to its own input.X
$51730362111148* X<This custom component> uses a {name} component not unlocked in this level.X
$15549447390000* X2 input/output components are in the same square. The custom component will be unusable since 2 pins can't overlap.X
$12256736989028* XYou have more than one probe in the same square.X
$51332486391182* XThe critical path is inside this <custom component>.X

# Switched Output is the name under 19513138880387
$12249248261034* XYou cannot solve this level without adding a 'Switched Output' componentX
$42649958199625* XThe level map was updated and your progress is out of order. Complete this <level> to fix it.X


=== campaign/bit_inverter/label.txt ===



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

$39788153942181* XTruth tablesX


=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* XInfer size from inputX
$70256730895162* XStatic valueX
$61685569269160* XAutomaticX


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

$34375498293137* XThis level introduces efficiency scoring, which is based on time and energy.X
$70169388789757*
XThese 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.X
$59781832788691*
XEach 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.X
$85893273691863* XObjective beautyX
$40775045205647*
XThe 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.X
$72877144436007*
XEach 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.X
$38383835706006*
XTo 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.X
$78375324732864*
XUseful 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.X


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

$24129473753872* XRead the inputX
$47357954866257* X*Assuming π ≈ 3X


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

$43078933051174* XClick any of the gray buttons in the last row of the table.X
$71204033550134* XWhat does the NAND gate do?X
$61241226128494* XTry again!X
$32982011047799* XCheckX


=== campaign/symphony/label.txt ===



