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


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

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



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

$16488212881433* Lower circuit

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

$47029050705615* Incorrect output

$52307576546100* Upper circuit/XOR



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

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



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

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

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

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



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

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



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

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



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

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



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

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

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

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



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

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



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

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

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

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



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

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

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



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

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

$88044062357651* Then how about 4-bit number?

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



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

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

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

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



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

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

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



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

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



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

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



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

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

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



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

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



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

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

$57091568089512* Note the red erroneous wire

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



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

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

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



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

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

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

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

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

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

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

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



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

$69947751578736* The input is merely a distraction

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



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

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

$88356074900046* to create signal based on the cycle count



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

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



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

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



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

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

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



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

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

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



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

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



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

$57877356797542* DoneCount



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

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

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

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



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

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



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

$17808301775724* This level is similar to "Multiplexer"

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



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

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



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

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

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



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

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

$41615813866999* The Never and Always are the easier parts

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



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

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

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



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

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

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



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

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

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

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



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

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



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

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

$86131527203527* This is where a decoder comes in handy



=== campaign/ram_component/hint_2.txt ===

$51243843817679* Using the [T] output of the decoder, we can enable the corresponding cell to load from

$78963222298606* And don't forget another switch to only output when LOAD is [T]



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

$51887730294248* Wire that up and the only thing left is to enable the right memory cell

$65959445914539* The value to save to a cell comes from one input



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

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



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

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



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

$34652721020070* The grey wires implement the IO mode



=== campaign/symphony_3_alu/hint_solution.txt ===

$23277299590423* Replace the NAND gate with the ALU component

$90347458725803* The new orange wires feed the opcode to the ALU



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

$61996387838431* The purple wires implement the immediate mode



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

$30888506574129* The orange wires implement the JUMP mode



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

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



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

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



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

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



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

$78454657849319* IO Devices



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

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



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

$88955803760495* The selective input is just a Multiplexer



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

$55189990966587* Tweak the Multiplexer to share its input, instead of output, for the selective output

$86286155471986* The purple wire in the middle is the BUS



=== model/translations.nim ===


# Quadrillion
$49300594926837* Q


# Trillion
$87907122406742* T



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

$43462148240207* Instructions per cycle


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


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

$29435797471674*
[large]Überblick[/large]
Eine Assembler-Sprache ist dafür da, um Befehlen Namen zu geben, die man als Mensch gut verstehen kann.

Unsere Assembler-Syntax folgt allgemeinen Konventionen, sodass du später in der Lage sein solltest, auch andere Assembler-Sprachen von anderen CPUs lesen zu können.

Die Befehls-Syntax beginnt mit einem abgekürztem Wort (einem "[color=#9966ff]mnemonic[/color]"), was den Befehl beschreibt.

Danach kommt eine Liste von Operanden, etwa so:
[box][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]4[/color][/box]

Assembler-Programme sind also oft nur eine Liste von Befehlen.


[large]Operanden[/large]

Es gibt verschiedene Arten von [color=#66ccff]Operanden[/color].

[b]Register[/b]
Im Beispiel oben wird [color=#66ccff]r1[/color] im generierten Maschinen-Code durch 1 ersetzt.

[b]Zahlen[/b]
Im Beispiel oben wird [color=#66ccff]4[/color] direkt in den Maschinen-Code eingefügt.

[b]Label[/b]
Für Sprunganweisungen möchte man in der Regel relative Befehls-Adressen referenzieren. Diese können automatisch durch die Verwendung von Labeln berechnet werden:
[box][color=#9966ff]jmp[/color] [color=#66ccff]mein_label[/color]
...
[color=#66ccff]mein_label:[/color][/box]
Labels werden definiert, indem man einen Namen in eine Zeile schreibt, mit einem Doppelpunkt danach.

[large]Andere Funktionen[/large]

[b]Kommentare[/b]
Alles, was in der gleichen Zeile hinter einem [highlight];[/highlight] steht, ist ein Kommentar und wird vom Assembler ignoriert:
[box][color=#eeeeee]mov r1, 123 [/color][color=#999999]; Bewege 123 nach Register 1[/color]
[/box]


[b]Roh-Daten[/b]
Du kannst Daten direkt zwischen den Assembler-Befehlen einfügen. Hier wird das Byte 123 eingefügt: [highlight]U8 123[/highlight].
[highlight]U8[/highlight] bedeutet "Unsigned 8 Bit Wert", der Assembler kann aber auch [highlight]U16[/highlight], [highlight]U32[/highlight] und [highlight]U64[/highlight].

Du kannst auch den Wert von ASCII-Zeichen einfügen, wie hier: [highlight]"Hallo"[/highlight]

[b]Const[/b]
Du kannst Registern und anderen Operanden einen anderen Namen haben:
[highlight]const ROTATION = r0[/highlight]
In diesm Beispiel wird [highlight]ROTATION[/highlight] zu einem alternativen Namen für r0. Wenn du deine Register immer passend benennst, kann man deinen Code besser lesen.

[b]Include[/b]
Du kannst andere Assembly-Datein einbinden, beispielsweise "std_lib.asm" vom übergeordneten Verzeichnis:
[highlight]include ../std_lib[/highlight]

Wenn du ein Assembly einbindest, wird dessen assembelter Inhalt an die Stelle eingebunden, an der du "include" geschrieben hast. Du kannst in einem Assembly aber auch Namen für öffentliche Label vergeben, die dann von außen benutzt werden können. Dafür muss man das 'pub' Prefix (für 'public') benutzen:
[highlight]pub print:[/highlight]

Um einen öffentlichen Namen oder Label zu benutzen, musst du den Dateinamen angeben, gefolgt von einem Punkt und dem Namen:
[highlight]jmp std_lib.print[/highlight]
Damit kannst du Bilbiotheken für Funktionen aufbauen, die du von überall verwenden kannst. Einfach die Bibliothek in den Ordner oberhalb des Levels legen und die Labels für jede Funktion public machen.



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

$29662258275697*
Im [highlight][patterns][/highlight] Abschnitt kannst du Muster für Textersetzungen definieren, damit du Befehle nicht doppelt definieren musst. Die Struktur der Muster ist ähnlich zu den Befehlen:

[color=#66ff99]Pattern-Signatur[/color]
[color=#66ccff]Syntax Ersetzung[/color]
[color=#9966ff]Maschinen-Code Ersetzung[/color]

Beispiel:
[box][patterns]

[color=#66ff99]pattern breite(bit_anzahl, maschinen_code)[/color]
[color=#66ccff]U{bit_anzahl}[/color]
[color=#9966ff]00{maschinen_code}[/color]

[instructions]

mov_%s\[[color=#66ff99]breite([/color][color=#66ccff]"8"[/color], [color=#9966ff]"00"[/color][color=#66ff99])[/color] | [color=#66ff99]breite([/color][color=#66ccff]"16"[/color], [color=#9966ff]"01"[/color][color=#66ff99])[/color]] %a(reg) %b(reg)
0000 [color=#9966ff]%s[/color] %a %b
\# Bewegt nach %a von %b

[/box]
Nach der Text-Ersetzung wird draus:
[box][instructions]

mov_[color=#66ccff]U8[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0000[/color] %a %b
\# Bewegt nach %a von %b

mov_[color=#66ccff]U16[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0001[/color] %a %b
\# Bewegt nach %a von %b

[/box]
Im Beispiel oben wird zuerst ein Muster deklariert. Die Deklaration beginnt mit dem Schlüsselwort [b]pattern[/b], dann der Name des Musters und schließlich die Namen der Argumente. Die zwei Zeilen unten drunter sind Text-Bausteine, die später in die Syntax und den Maschinen-Code kopiert werden.

In die Befehlszeile steht beispielsweise der Variablen-Name [highlight]%s[/highlight], gefolgt von einer Anweisung, wie diese zu ersetzen ist. Beim Auflösen wird für jede Variante, durch die [highlight]%s[/highlight] ersetzt werden kann, ein neuer Befehl angelegt. Das Muster wird ausgewertet und das Ergebnis wird an die Stelle der Variable kopiert.



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

$76434165550872*
[large]Bildschirm Modi[/large]
Der Bildschirm hat 4 Modi:
0: ASCII 8
1: ASCII 32
2: Pixel 8
3: Pixel 32

Außerdem gibt es in jedem Modus unterschiedliche Einstellungen, die während der Ausführung über die Eingangs-Pins geändert werden können.

[large]ASCII 8 Modus[/large]
Jedes Byte wird als Zeichen auf einer 96×40 Anzeige interpretiert.

[b]Einstellung:[/b]
0 Modus wechseln
1 Daten Adresse setzen
2 Vordergrundfarbe setzen
3 Hintergrundfarbe setzen
4 Schriftart setzen

[large]ASCII 32 Modus[/large]
Es werden jeweils 4 Bytes gelesen mit folgenden Bestandteilen:
Byte 1: Ein Zeichen
Byte 2: Vordergrundfarbe
Byte 3: Hintergrundfarbe
Byte 4: Ungenutzt/zum Auffüllen

8-Bit Farben haben 3 Bits für rot, 3 Bits für grün und 2 Bits für blau:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

[b]Einstellung:[/b]
0 Modus wechseln
1 Daten Adresse setzen

[large]Pixel 8[/large]
Jedes Byte wird als Farb-Pixel interpretiert mit 3 Bits für rot, 3 Bits für grün und 2 Bits für blau:
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

Die Auflösung im Pixel Modus hat ein Verhältnis von 4:3 und geht bis zu 1024×768.
Der tatsächliche Wert der Auflösung wird über den Wert bestimmt,
der während der 'Auflösung setzen'-Einstellung am zweiten Pin mitgegeben wird:
4 × (Wert + 1) : 3 × (Wert + 1)

[b]Einstellung:[/b]
0 Modus wechseln
1 Daten Adresse setzen
2 Auflösung setzen

[large]Pixel 32[/large]
Es werden jeweils 4 Bytes gelesen mit folgenden Bestandteilen:
Byte 1: Farbwert für Rot
Byte 2: Farbwert für Grün
Byte 3: Farbwert für Blau
Byte 4: Ungenutzt/zum Auffüllen

[b][color=#ff5555]RRRRRRRR[/color][color=#55ff55]GGGGGGGG[/color][color=#5555ff]BBBBBBBB[/color][/b]

Die Auflösung im Pixel Modus hat ein Verhältnis von 4:3 und geht bis zu 1024×768.
Der tatsächliche Wert der Auflösung wird über den Wert bestimmt,
der während der 'Auflösung setzen'-Einstellung am zweiten Pin mitgegeben wird:
4 × (Wert + 1) : 3 × (Wert + 1)

[b]Einstellung:[/b]
0 Modus wechseln
1 Daten Adresse setzen
2 Auflösung setzen

[large]ASCII Schriftarten[/large]
Es gibt folgende ASCII-Schriftarten:

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

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

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

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



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

$28388869498626* Aktuell liegt der Elefant vor allen anderen Versuchsobjekten der Erde. Wenn man die Hirngröße mit einberechnet, schlägst du dich auch nicht schlecht.



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

$73801373825270*
Die Idee der Assembler-Programmierung ist es den Befehlen Namen zu geben, die man als Mensch gut verstehen kann. Der Computer liest aber das zugeordnete Bit-Muster anstatt des Namens.

Konventionell beginnt ein Assembler-Befehl mit einem abgekürzten Wort (ein "[color=#9966ff]mnemonic[/color]") das beschreibt, was getan werden soll. Anschließend kommt eine Liste von [color=#66ccff]Operanden[/color] wie hier:
[highlight][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]r2[/color][/highlight]

Üblicherweise ist das Ziel immer der Operand ganz links. Im Beispiel oben bedeutet das: Es soll ein Wert [color=#9966ff]bewegt[/color] werden zum Zielort [color=#66ccff]r1[/color] und zwar aus der Quelle [color=#66ccff]r2[/color]. Wenn du diese Konventionen lernst, kannst du auch andere Assembler-Sprachen in der echten Welt verstehen.

Klicke auf den [b]Edit[/b] Button am Programm-Teil der RAM Komponente, um den Assembler-Editor zu öffnen. Im Editor kannst du oben links auf [b]ASM[/b] klicken, um von der Assembler-Ansicht zur [b]ISA[/b] Ansicht zu wechseln. ISA (Instruction Set Architecture) ist der komplette [b]Befehlssatz[/b], der alle Befehle beschreibt, die in der Overture Architektur möglich sind.



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

$73562005049347* Kopiert das Eingangssignal nach REG 2

$80524429403045* Klicke auf "ASM" oben links, um alle Befehle zu sehen



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

$35877580485177*
Der Delfin hat übrigens auch einen Computer gebaut. Also geht der Wettbewerb um den irdischen Vorsitz in der Galaktischen Föderation weiter, bis einer von euch ausscheidet.

Der nächste Meilenstein ist ein Computerprogramm, mit dem man ein Labyrinth lösen kann.



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

$40415302067949* entweder der Eingang 0 [T] UND Eingang 1 [F] sind ODER der Eingang 0 [F] UND Eingang 1 [T] sind

$61125857472821* Die Wahrheitstabelle sagt uns, dass der Ausgang [T] ist, wenn und nur wenn



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

$38198768813364* Bit Inverter

$66258723258123* Wir führen gerade Experimente durch, um herauszufinden, wie sich Hintergründe auf die kognitiven Fähigkeiten von Erdlingen auswirken.



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

$62622482229413* Anders, als beim AND: Wenn der 'Aktiv'-Pin [F] ist, dann ist der Ausgabewert des Schalters NICHT [F].

$80836475394613* Er gibt gar kein Signal aus. Dadurch können mehrere Schalter ihren Wert auf ein gemeinsames Kabel leiten, ohne einen Kurzschluss zu verursachen.



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

$25663924496537*
Wenn der Ausgang abgeschaltet ist, wird weder [T] noch [F] ausgegeben, sondern ein dritter Zustand [Z] den wir [b]Z Zustand[/b] nennen (oder kurz einfach [b]Z[/b]).

Sind zwei Signale an ein gemeinsames Kabel angeschlossen, dann ergeben sich auf dem Kabel folgende Zustände:

Eingang 0 [F][F][F][T][T][T][Z][Z][Z]
Eingang 1 [F][T][Z][T][F][Z][F][T][Z]
Ausgang   [F][E][F][T][E][T][F][T][Z]

Das[E]bedeutet [b]Kurzschluss[/b] und ist verboten.

$88100823584262*
Wenn Komponenten unterschiedliche Signale auf das selbe Kabel leiten, bekommst du einen Fehler. Es gibt aber Komponenten, die graue Ausgangs-Pins haben. Solche Komponenten liefern gar kein Signal, wenn sie ausgeschaltet sind. Der [b]Bit-Schalter[/b] ist eine dieser Komponenten.

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

Wenn der untere Pin [F] ist, dann ist der Ausgang abgeschaltet. Dadurch können viele Ausgänge fehlerfrei auf das selbe Kabel geleitet werden, solange nur eine der Komponenten aktiv ist.



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

$79125097012724*
Im letzten Level hast du das Logische Schieben nach Rechts gebaut. Jetzt bauen wir das 
"[b]Arithmetische Schieben[/b] nach [b]Rechts[/b]", oder kurz [b]asr[/b].
Du erinnerst dich vielleicht an das Level [b]Zahlen verdoppeln[/b], wo du gelernt hast, dass man durch Verschieben Zahlen verdoppeln oder halbieren kann. Jetzt brauchen wir Verdopplungs/Halbierungs-Logik aber auch für negative Zahlen. Genau dafür ist das [b]asr[/b]. Wir können nicht einfach das Vorzeichen mit wegschieben, um sie zu halbieren - dann geht alles kaputt.

Der Trick ist: Wenn das höchste Bit [T] ist, dann schieben wir keine [F] Signale rein, sondern [T].

Beispiel [b]-106 asr 3[/b]
(höchstes Bit ist [T])
          [T][F][F][T][F][T][T][F]          
[T][T][T] [b]➡[/b] [T][F][F][T][F][T][T][F]          
          [T][T][T][T][F][F][T][F] [b]➡[/b] [T][T][F]



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

$67841603404086* Die binäre Form von 164 ist 1010 0100



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

$88637818475024* Das Byte ist 0, wenn alle seine Bits 0 sind



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

$14667194911431* Zum Schluss wird das höchste Bit als Vorzeichen betrachtet und hat den gegenteiligen Effekt

$19896249626650* (Wenn dort nur eine der Zahlen [T] ist, dann ist sie garantiert die kleinere Zahl)



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

$15205448412655* Also EINGANG_1 ADD (NEG EINGANG_2)



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

$57629598331916*
Du sollst eine neue Bit-Operation implementieren:
Das "[b]Logische Schieben[/b] nach [b]Rechts[/b]", oder kurz [b]lsr[/b].
Bei dieser Operation werden alle Bits einer Zahl nach rechts verschoben, in Richtung des kleinsten Bits. Du kannst es dir so vorstellen, dass auf der Seite des höchsten Bits neue [F] Signale reingeschoben werden. Falls dadurch auf der anderen Seite [T] Signale "rausgeschoben" werden, dann fallen sie einfach weg.

Beispiel [b]180 lsr 1[/b]
(Schiebt 1 mal)
      [T][F][T][T][F][T][F][F]      
[F] [b]➡[/b] [T][F][T][T][F][T][F][F]      
      [F][T][F][T][T][F][T][F] [b]➡[/b] [F]

oder [b]180 lsr 3[/b]
(Schiebt 3 mal)
          [T][F][T][T][F][T][F][F]          
[F][F][F] [b]➡[/b] [T][F][T][T][F][T][F][F]          
          [F][F][F][T][F][T][T][F] [b]➡[/b] [T][F][F]



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

$71057700033977* A anstelle von Eingang 0 und B anstelle von NOT Eingang 0



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

$66984132947598*
Wir haben uns entschieden den Hund zu behalten, obwohl er unsere Tests nicht bestanden hat. Im Gegensatz zu den meisten Erdbewohnern ist er flauschig und befolgt einfache Anweisungen sehr gut.

Vielleicht sollten wir euch beide in einem Team zusammenarbeiten lassen, da ihr die Schwächen des anderen bestens ausgleichen könnt.



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

$52274910421610*
Verknüpfe beide Eingänge paarweise mit NAND.

Beispiel:
Eingang 1 [T][T][F][F][F][T][F][F]
Eingang 2 [F][F][F][F][T][T][F][F]
Ausgang   [T][T][T][T][T][F][T][T]



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

$65712025748767*
Die Sprungadresse des Befehls auf den wir springen wollen, sollte keine feste Zahl sein, weil wir mit jeder eingefügten Programmzeile die Adressen der Befehle verändern. Dann müssten wir beim Programmieren die feste Sprungadresse ständig aktualisieren.

Stattdessen kannst du [color=#66ccff]Label[/color] (bzw. Sprungmarken) verwenden. Ein Label gibt dir automatisch die Adresse des darauffolgenden Befehls, welche du beliebig oft im Programm referenzieren kannst.

[box][left][color=#66ccff]mein_label[/color]:    [color=#aaaaaa]; Definiert eine Sprungmarke, um die
               ; Adresse des darauf folgenden
               ; Befehls abfragen zu können[/color]

[color=#9966ff]imm[/color] [color=#66ccff]mein_label[/color] [color=#aaaaaa]; Fragt die Adresse des Labels ab
               ; und speichert sie direkt in Reg 0[/color]
[/left][/box]
Du kannst Labels auch schon oben im Programm abfragen, auch wenn die Definition erst später im Programm kommt.



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

$78380513477546* Klicke auf ASM um weitere Sprungbefehle zu sehen



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

$83123268362253*
Die Ausgangskomponente dieses Levels ist ein binärer Zähler, bei dem die 3 Pins für 1, 2 und 4 stehen.

Zähle die Anzahl der [T] Signale, und gib die Zahl binär am Ausgang aus.

[tip]Die Lösung ist nicht wirklich hübsch und braucht viele Komponenten.[/tip]



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

$24718289227251*
Willkommen in der Werkstatt! Die Schaltkreise, die du hier baust, werden zu Eigenen Komponenten, die du in deiner Architektur verwenden kannst.
Der Schaltkreis bestimmt das Verhalten der Komponente und die Position der Bestandteile bestimmt ihre Form.



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

$65517909958697*
Wenn wir mit vielen Bits arbeiten, kann man die Zahlen schwer lesen, wenn sie in binär geschrieben sind. Deswegen benutzt man oft die Hexadezimaldarstellung auf Basis 16. Dort hat man nicht nur 2 Symbole [F] und [T], sondern 16 Symbole von 0-F. Um 16 Symbole darzustellen braucht man 4 Bits:

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]

Hier ein Beispiel anhand der größten 16 Bit Zahl:

Binär:       1111111111111111
Dezimal:     65535           
Hexadezimal: FFFF            

Es ist nicht leicht zu sehen, ob bei der Binärzahl etwas fehlt. Bei der Dezimalzahl kann man schwer sagen, ob sie korrekt zur Binärzahl passt. Bei der Hexadezimalzahl hingegen ist das beides leicht zu sehen (zumindest wenn man sich mit der Darstellung angefreundet hat).



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

$26182817405385*
Herzlichen Glückwunsch, du wurdest entführt!

Wir werden deine Lernfähigkeit über mehrere Level hinweg testen.

Baue einen funktionsfähigen Computer, und deine Spezies kann vielleicht der Galaktischen Föderation beitreten.



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

$71000564779980*
Unsere Woche hat 4 Tage. Unsere Tage heißen Nulltag, Eintag, Zweitag, Dreitag. Ich habe gehört, dass einige Erdlinge den Dreitag mit F am Anfang schreiben?
	
Überrascht mich jetzt nicht wirklich.



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

$59240995307159* Zuerst den Eingang auslesen.



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

$36846418389807* Alle Tierarten der Erde werden getestet. Wir prüfen, wie gut sie lernen können einen Computer zu bauen. 



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

$16731935541997*
In diesem Level geht es um das [b]Zweierkomplement[/b]: die Darstellung für negative Zahlen, die am weitesten verbreitet ist.

Dabei verändert das höchste Bit seine Bedeutung und wird negativ. Für ein Byte bedeutet das:
Das 8. Bit ändert seinen Wert von 128 auf -128.

Um das Level abzuschließen musst du mindestens Stufe 3 schaffen.



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

$20946507323050* Wenn beide Eingänge [T] sind, ist der Ausgang [F]

$88952480145102* Wenn beide Eingänge [F] sind, ist der Ausgang [T]



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

$64052600264884*
Verwende NAND Gatter, um ein NOT Gatter zu bauen

Verwende: [b]NAND Gatter[/b]
Eingang 1: [F][T][F][T]
Eingang 2: [F][F][T][T]
Ausgang:   [T][T][T][F]

Baue: [b]NOT Gatter[/b]
Eingang: [T][F]
Ausgang: [F][T]



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

$58396790216558* (move) Bewegt einen Wert von %b nach %a.



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

$61875924861326*
Zuerst brauchen wir einen Schaltkreis, mit dem man einen Wert von einer [color=#c54d5e]Quelle[/color] zu einem [color=#e49f44]Ziel[/color] bewegen kann.

Der Befehl am Eingang bestimmt [color=#c54d5e]Quelle[/color] und [color=#e49f44]Ziel[/color].

Bit 0,1,2 ist die [color=#c54d5e]Quelle[/color].
Bit 3,4,5 ist das [color=#e49f44]Ziel[/color].  

Befehl: [color=#808080]76[/color][color=#e49f44][b]543[/b][/color][color=#c54d5e][b]210[/b][/color]

$87179643828952*
Hier sind die Bitmuster für [color=#c54d5e]Quelle[/color] und [color=#e49f44]Ziel[/color].

[color=#c54d5e]Quelle[/color]:
[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]  EINGANG  
[T] [T] [T]  UNBENUTZT

[color=#e49f44]Ziel[/color]:
[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]  AUSGANG  
[T] [T] [T]  UNBENUTZT



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

$17602708328746*
Zeit die "Arithmetisch-Logische-Einheit (ALU)" in unsere Architektur einzubauen. Die ALU wurde als Werkstatt-Schaltplan abgespeichert, deswegen kannst du sie jetzt als [b]Eigene Komponente[/b] auswählen. Falls du nicht mehr weißt, was die einzelnen Pins machen, kannst du dir den ALU Schaltplan in der Werkstatt anschauen.

Entscheide mit Hilfe des Befehlsdecoders (auch eine Eigene Komponente), ob wir Werte zwischen Registern [b]Bewegen[/b] sollen, oder ob wir mit Hilfe der ALU etwas [b]Rechnen[/b] sollen. Hier nochmal die einzelnen Modi:

[F][F][Z][Z][Z][Z][Z][Z] Direkt   
[F][T][Z][Z][Z][Z][Z][Z] Rechnen  
[T][F][Z][Z][Z][Z][Z][Z] Bewegen  
[T][T][Z][Z][Z][Z][Z][Z] Bedingung

In diesem Level musst du dich nur um [b]Bewegen[/b] und [b]Rechnen[/b] kümmern. Im [b]Rechnen[/b] Modus, nimm [color=#e49f44]REG 1[/color] und [color=#e49f44]REG 2[/color] als Eingang der ALU und speichere das Ergebnis in [color=#e49f44]REG 3[/color].

[tip]Der 3-Bit Decoder hat einen Pin zum Deaktivieren[/tip]



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

$89085328104477*
Wir müssen zum Schluss einen Mechanismus bauen, um den Programm-[b]Zähler[/b] zu verändern, wenn durch Befehle bestimmte [b]Bedingungen[/b] erfüllt sind.

Dazu benutzen wir den letzten Modus [b]Bedingung[/b], wenn die zwei höchsten Bits des Befehls [T][T] sind. In diesem Modus soll der aktuelle Wert in [color=#e49f44]REG 3[/color] auf die Bedingung geprüft werden, die durch die 3 niedrigsten Bits des Befehls vorgegeben wird. Dafür hast du schon eine Eigene Komponente gebaut. Falls die Bedingung [T] ausgibt, soll der aktuelle Wert aus [color=#DD6576]Reg 0[/color] den Programm-Zählerwert überschreiben (der ja die aktuelle Position des Programms angibt) - dadurch können wir im Programm springen und später Programm-Schleifen programmieren.

Bedingungen:
[F][F][F]  Niemals  
[F][F][T]  Immer    
[F][T][F]  [color=#e49f44]REG 3[/color] = 0
[F][T][T]  [color=#e49f44]REG 3[/color] ≠ 0
[T][F][F]  [color=#e49f44]REG 3[/color] < 0
[T][F][T]  [color=#e49f44]REG 3[/color] ≥ 0
[T][T][F]  [color=#e49f44]REG 3[/color] ≤ 0
[T][T][T]  [color=#e49f44]REG 3[/color] > 0

Das sind die Bedingungen, die du auch in deiner Eigenen Komponente hast.



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

$42577908074742* (immediate) Bewege direkt %a nach r0.

$45432635426071* Bewegt einen Wert nach %a von %b.

$71072332861445* (no operation) Tue nichts.



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

$35331465118106* Schnelle Overture



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

$71466914240996*
Dieses Level hat einen Eingangswert und 3 Bits, die angeben, auf welche Bedingung der Eingangswert überprüft werden soll.

Bit-Code, der die Bedingung angibt:
[F][F][F]  Niemals 
[F][F][T]  Immer   
[F][T][F]  Wert = 0
[F][T][T]  Wert ≠ 0
[T][F][F]  Wert < 0
[T][F][T]  Wert ≥ 0
[T][T][F]  Wert ≤ 0
[T][T][T]  Wert > 0

Gib [T] aus, falls der Eingangswert die angegebene Bedingung erfüllt, sonst [F].



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

$62355105651643*
Um zwischen den 4 Arten von Befehlen zu unterscheiden, verwenden wir die zwei höchsten Bits um zu entscheiden in welchen MODUS wir sind:

[F][F][Z][Z][Z][Z][Z][Z] Direkt   
[F][T][Z][Z][Z][Z][Z][Z] Rechnen  
[T][F][Z][Z][Z][Z][Z][Z] Bewegen  
[T][T][Z][Z][Z][Z][Z][Z] Bedingung

[Z] ist ein beliebiger Wert.

Entscheide anhand des Eingangs in welchem MODUS wir sind, und gebe [T] am passenden Ausgang aus.



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

$90664310835282*
Wir möchten gerne [b]Pseudo-Zufallszahlen[/b] generieren. In der Hardware würde man das mit einem [b]Linear Rückgekoppelten Schieberegister[/b] machen. Aber es geht ja gerade um das Programmieren, deswegen lösen wir das mit einem Assembler-Programm.

Am Eingang bekommst du einen [b]Seed[/b]. Das ist die Zahl, die unsere Zufallszahlenfolge in Gang setzt und bestimmt, welche "zufälligen" Zahlen ausgegeben werden. Ausgehend von diesem Seed führen wir folgende Berechnungsschritte durch:

[b]32 Bit XOR-Shift Random Number Generator (RNG):[/b]
[box][left]temp1    = seed  xor (seed  lsr 13)
temp2    = temp1 xor (temp1 lsl 17)
ergebnis = temp2 xor (temp2 lsr 5)[/left][/box]

Am Ende sendest du das [b]Ergebnis[/b] zum Ausgang.
Das Ergebnis wird zum Seed für den nächsten Durchgang und du sollte quasi eine Endlosschleife bauen, die permanent Zufallszahlen ausgibt, wenn wir sie einmal in Gang gesetzt haben. Der Eingang wird also nur einmal ganz am Anfang gelesen.



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

$75346310834154* Das AN Signal ist konstant, also können wir dort den Schaltkreis vereinfachen



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

$68315222097089*
Zeit, dass du mal etwas programmierst! Du sollst ein Programm schreiben, was einen [b]Stack[/b] imitiert. Ein Stack (Stapel) ist eine Datenstruktur, die super nützlich ist (nach diesem Level bekommst du die passenden Befehle). Einen Stapel kannst du dir vorstellen, wie einen Stapel Papier auf den du neue Zettel drauflegen kannst, aber auch nur von oben wieder Zettel wegnehmen kannst (LIFO Prinzip: Last-In, First-Out). Im Computer machen wir das natürlich mit Zahlen anstatt Zetteln.

Es gibt in einem Stack 2 Funktionen:
[color=#66ccff]PUSH[/color]  Legt einen Wert oben auf den Stapel   
[color=#66ccff]POP[/color]   Nimmt den obersten Wert vom Stapel weg

Zum Ablegen der Werte können wir unseren [b]Arbeitsspeicher[/b] benutzen - du musst dir nur irgendwie merken wo "oben" ist. Durch die mehreren Speicher- und Lade-Ports und unsere [b]load[/b] und [b]store[/b] Operationen können wir mit dem RAM arbeiten, ohne den Programm-Zähler zu stören.

Am [b]Eingang[/b] bekommst du verschiedene Zahlen. Wenn du eine Zahl [b]ungleich 0[/b] bekommst, dann imitiere [color=#66ccff]PUSH[/color] d.h. du legst die Zahl oben auf den Stack. Wenn die Zahl [b]gleich 0[/b] ist, dann imitiere [color=#66ccff]POP[/color]. Also die oberste Zahl vom Stack wegnehmen und zum [b]Ausgang[/b] schicken.

[tip]Die bedingten Sprung-Operationen wie [b]jne[/b] schauen immer auf das [b]flags[/b] Register, was durch die [b]cmp[/b] Operation geschrieben wird[/tip]

$90806029597852*
Wie versprochen bekommst du jetzt die [b]push[/b] und [b]pop[/b] Befehle, die du im nächsten Level verwenden kannst. Beide Befehe sind in Wirklichkeit 2 Befehle nacheinander, und beide benutzen das [b]sp[/b] Register (Stack Pointer), um sich zu merken, wo der oberste Eintrag des Stack steht.

[b]push[/b] ist ein Synonym für
[box][left]sub sp, sp, 4
store_32 [sp], %value[/left][/box]
[b]pop[/b] ist ein Synonym für
[box][left]load_32 %destination, [sp]
add sp, sp, 4[/left][/box]

Dir fällt vielleicht auf, dass [b]push[/b] vom Stack Pointer subtrahiert und [b]pop[/b] addiert. Der Stack wächst also nach unten! Das ist genau entgegengesetzt, wie man es vielleicht erwartet, aber das hat einen Grund: [b]sp[/b] ist mit 0 initialisiert und wächst nach unten. Das bedeutet es gibt sofort einen Adress-Überlauf und der erste Eintrag wird an die [b]höchst mögliche[/b] Adresse geschrieben, und wächst dann weiter nach unten. Damit kann der Stack ungestört wachsen.



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

$83483553172261*
Deine Aufgabe ist es den NAND Befehl zu bauen.

Hier der Befehlsaufbau:
[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]

[color=#ff9800]M[/color] = Modus           [color=#66ff99]A[/color] = Argument A  
[color=#ff6680]O[/color] = Operation       [color=#66ccff]B[/color] = Argument B  
[color=#ffe666]D[/color] = Zielregister    [color=#bbbbbb]0[/color] = Unbenutzt   

Benutze den [b]Befehlsdecoder[/b], um die Argument-Register vom Zielregister zu trennen. Achte darauf, dass die Lade- und Speicher-Ports Byte-Adressen erwarten und keine tatsächlichen Werte. Außerdem belegt jedes Register 4 Bytes (also auch 4 Adressen, weil die Ports Bit-Breite 32 haben). Wenn du beispielsweise [color=#87a8c8][b]r2[/b][/color] laden möchtest, darfst du nicht einfach aus Adresse 2 lesen, sondern aus Adresse 8, weil Byte 0-3 von [color=#87a8c8][b]zr[/b][/color] eingenommen werden, und Byte 4-7 von [color=#87a8c8][b]r1[/b][/color].

[tip]Schieben um einen statischen Wert funktioniert super mit dem Statischen Indexer[/tip]

Übrigens ist in diesem Level der [color=#ff9800]Modus[/color] immer 1, und die [color=#ff6680]Operation[/color] ist immer 0. Das bedeutet wir berechnen immer NAND auf [color=#66ff99]Argument A[/color] und [color=#66ccff]Argument B[/color] und speichern das Ergebnis ins [color=#ffe666]Zielregister[/color]. Dafür musst du jetzt noch keine komplette ALU einbauen, sondern kannst erst einmal ein normales NAND Gatter verwenden.

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



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

$34545926188340* Die nächste Adresse im Arbeitsspeicher sollte {expected_value} sein, nicht {actual_counter}. Der Zähler stimmt nicht. 



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

$66929200224494*
Jetzt kümmern wir uns darum, wie wir einen Eingang und einen Ausgang ansteuern können.

Befehlsaufbau:
[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]

[color=#ff9800]M[/color] = Modus           [color=#66ff99]A[/color] = Argument A  
[color=#ff6680]O[/color] = Operation       [color=#66ccff]B[/color] = Argument B  
[color=#ffe666]D[/color] = Zielregister    [color=#bbbbbb]0[/color] = Unbenutzt   

Ähnlich wie in [color=#e49f44]Overture[/color] gibt es auch hier 4 Modi:

[color=#ff9800]0[/color]  [b]EA[/b]    
[color=#ff9800]1[/color]  [b]ALU[/b]   
[color=#ff9800]2[/color]  [color=#bbbbbb]SPRUNG[/color]
[color=#ff9800]3[/color]  [color=#bbbbbb]RAM[/color]   

In diesem Level geht es aber erst einmal nur um den [color=#ff9800]Modus[/color] [b]EA[/b] (Eingang/Ausgang) und [b]ALU[/b] (Rechnen). Wenn wir im ALU Modus sind, dann führe einfach die NAND Operation aus, so wie im letzten Level. Wenn wir im EA Modus sind, dann musst du die [color=#ff6680]Operation[/color] auswerten. Die Operation ist ein Code, der sagt welche der folgenden Dinge ausgeführt werden sollen:

[color=#ff6680]0[/color] nop  Tue nichts                    
[color=#ff6680]1[/color] in   Sende Eingang zum [color=#ffe666]Zielregister[/color]
[color=#ff6680]2[/color] out  Sende [color=#66ccff]Argument B[/color] zum Ausgang  



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

$13069282666558*
Füge die neue [b]ALU[/b] hinzu, die du gebaut hast. Die [color=#ff6680]Operation[/color] sagt dir, was berechnet werden soll.

Befehlsaufbau:
[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]

[color=#ff9800]M[/color] = Modus           [color=#66ff99]A[/color] = Argument A  
[color=#ff6680]O[/color] = Operation       [color=#66ccff]B[/color] = Argument B  
[color=#ffe666]D[/color] = Zielregister    [color=#bbbbbb]0[/color] = Unbenutzt   



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

$85471608475185*
Wie bei [color=#e49f44]Overture[/color] brauchen wir auch in [color=#e49f44]Symphony[/color] die Möglichkeit Werte [b]direkt[/b] aus dem Befehl in ein Register schreiben zu können. Dafür können wir das [color=#9966ff][b]Direkt-Bit[/b][/color] des Befehls nutzen. Wenn das Direkt-Bit [T] ist, dann wird [color=#66ccff]Argument B[/color] als [b]Direkter Wert[/b] interpretiert.

[color=#9966ff]Direkt-Bit[/color] [F]: [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=#9966ff]Direkt-Bit[/color] [T]: [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]

[color=#ff9800]M[/color]   = Modus          [color=#ffe666]D[/color] = Zielregister    
[color=#ff6680]O[/color]   = Operation      [color=#66ff99]A[/color] = Argument A      
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Direkt-Bit     [color=#66ccff]B[/color] = Argument B      
[color=#bbbbbb]0[/color]   = Unbenutzt      (oder [b]Direkter Wert[/b])



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

$57225943470132*
Jetzt kümmern wir uns um den [b]SPRUNG[/b] [color=#ff9800]Modus[/color]

[color=#ff9800]0[/color]  [color=#bbbbbb]EA[/color]    
[color=#ff9800]1[/color]  [color=#bbbbbb]ALU[/color]   
[color=#ff9800]2[/color]  [b]SPRUNG[/b]
[color=#ff9800]3[/color]  [color=#bbbbbb]RAM[/color]   

Befehlsaufbau:
Direkt-Bit [F]: [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]
Direkt-Bit [T]: [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]

[color=#ff9800]M[/color]   = Modus          [color=#ffe666]D[/color] = Zielregister    
[color=#ff6680]O[/color]   = Operation      [color=#66ff99]A[/color] = Argument A      
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Direkt-Bit     [color=#66ccff]B[/color] = Argument B      
[color=#bbbbbb]0[/color]   = Unbenutzt      (oder Direkter Wert)

Im [b]SPRUNG[/b] [color=#ff9800]Modus[/color] gibt [color=#66ff99]Argument A[/color] das Register vor aus dem ein Wert ausgelesen werden soll. Dieser Wert wird als [b]Flag[/b] interpretiert. Dieses Flag soll gegen die Bedingung geprüft werden, die von der [color=#ff6680]Operation[/color] vorgegeben wird. Dafür kannst du deine Eigene Komponente verwenden, die du gebaut hast.

Falls die Bedingung erfüllt ist, überschreibe den [b]Zähler[/b] mit [color=#66ccff]Argument B[/color]. Ist das [color=#9966ff]Direkt-Bit[/color] [F], dann ist damit der Wert des Registers gemeint, den Argument B anspricht, sonst der Direkte Wert.



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

$65386575947998*
Im [b]RAM[/b] [color=#ff9800]Modus[/color] gibt es 6 [color=#ff6680]Operationen[/color],
 die mit passenden Befehlen ausgelöst werden:

[color=#ff6680]0[/color] load_8   ( 8 Bit laden)    
[color=#ff6680]1[/color] load_16  (16 Bit laden)    
[color=#ff6680]2[/color] load_32  (32 Bit laden)    
[color=#ff6680]3[/color] [color=#bbbbbb]reserviert[/color]                 
[color=#ff6680]4[/color] store_8  ( 8 Bit speichern)
[color=#ff6680]5[/color] store_16 (16 Bit speichern)
[color=#ff6680]6[/color] store_32 (32 Bit speichern)
[color=#ff6680]7[/color] [color=#bbbbbb]reserviert[/color]                 

Bei [b]load[/b] Befehlen soll der Wert aus dem Arbeitsspeicher-Register [color=#66ccff]Argument B[/color] geladen werden und ins [color=#ffe666]Zielregister[/color] in der Registerbank geschrieben werden.

Bei [b]store[/b] Befehlen soll ein Wert in das Arbeitsspeicher-Register [color=#66ccff]Argument B[/color] gespeichert werden, und zwar der Wert aus Registerbank [color=#66ff99]Argument A[/color].

Die Zahl am Befehl gibt an, wie viele Bits geladen oder gespeichert werden sollen.

$73426457129430*
Diesmal geht es um den [b]RAM[/b] [color=#ff9800]Modus[/color]
[color=#ff9800]0[/color]  [color=#bbbbbb]EA[/color]    
[color=#ff9800]1[/color]  [color=#bbbbbb]ALU[/color]   
[color=#ff9800]2[/color]  [color=#bbbbbb]SPRUNG[/color]
[color=#ff9800]3[/color]  [b]RAM[/b]   

Befehlsaufbau:
Direkt-Bit [F]: [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]
Direkt-Bit [T]: [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]

[color=#ff9800]M[/color]   = Modus          [color=#ffe666]D[/color] = Zielregister    
[color=#ff6680]O[/color]   = Operation      [color=#66ff99]A[/color] = Argument A      
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Direkt-Bit     [color=#66ccff]B[/color] = Argument B      
[color=#bbbbbb]0[/color]   = Unbenutzt      (oder Direkter Wert)



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

$23620554597332*
Es wäre praktisch, wenn unser Computer auch Daten persistent bzw. dauerhaft speichern könnte, sodass wir sie nach einem Neustart wieder abrufen können.

Um so einen [b]Dauerspeicher[/b] zu bauen brauchen wir zuerst eine weitere RAM Komponente. Diese RAM Komponente bekommt 2 neue Befehle [b]pload[/b] (persistentes Laden) und [b]pstore[/b] (persistentes Speichern). Beide Befehle sollen mit 32 Bit arbeiten und funktionieren genauso wie die anderen [b]load[/b] und [b]store[/b] Befehle aus dem letzten Level - nur eben auf der neuen [b]Dauerspeicher[/b] RAM Komponente.

Hier die vollständige Liste der [color=#ff6680]Operationen[/color]:
[color=#ff6680]0[/color] load_8   ( 8 Bit laden)        
[color=#ff6680]1[/color] load_16  (16 Bit laden)        
[color=#ff6680]2[/color] load_32  (32 Bit laden)        
[color=#ff6680]3[/color] [b]pload[/b]    (persistent laden)    
[color=#ff6680]4[/color] store_8  ( 8 Bit speichern)    
[color=#ff6680]5[/color] store_16 (16 Bit speichern)    
[color=#ff6680]6[/color] store_32 (32 Bit speichern)    
[color=#ff6680]7[/color] [b]pstore[/b]   (persistent speichern)



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

$29247683714165*
Bis jetzt hat der [b]EA[/b] [color=#ff9800]Modus[/color] nur 3 [color=#ff6680]Operationen[/color], aber jetzt werden wir ein paar hinzufügen. Hier ist die vollständige Liste der EA Operationen:

[color=#ff6680]0[/color] nop       Tue nichts                               
[color=#ff6680]1[/color] in        Sende Eingang zum [color=#ffe666]Zielregister[/color]           
[color=#ff6680]2[/color] out       Sende [color=#66ccff]Argument B[/color] zum Ausgang             
[color=#ff6680]3[/color] keyboard  Sende Tastaturwert zum [color=#ffe666]Zielregister[/color]      
[color=#ff6680]4[/color] screen    Setze Bildschirmwerte (siehe unten)      
[color=#ff6680]5[/color] time_0    Sende untere 32 Zeitbits zum [color=#ffe666]Zielregister[/color]
[color=#ff6680]6[/color] time_1    Sende obere 32 Zeitbits zum [color=#ffe666]Zielregister[/color] 
[color=#ff6680]7[/color] counter   Sende Zählerwert zum [color=#ffe666]Zielregister[/color]        

Der [b]Bildschirm[/b] kann die Bytes des verknüpften RAMs auf verschiedene Arten interpretieren (siehe Handbuch). Der Bildschirm hat verschiedene Einstellungen, die man über die Pins [b]Einstellung[/b] und [b]Wert[/b] setzen kann. Pro Taktzyklus kann man also am Pin [b]Einstellung[/b] auswählen, welche Einstellung verändert werden soll, und der Pin [b]Wert[/b] sagt, auf welchen Wert die Einstellung gesetzt werden soll. Man braucht also mehrere Taktzyklen, bis man alles richtig eingestellt hat. Die genauen Einstellungen kommen über das Programm. Für uns ist nur wichtig: Bei [color=#ff6680]screen[/color] soll die Einstellung aus [color=#66ff99]Argument A[/color] auf den Wert von [color=#66ccff]Argument B[/color] gesetzt werden.

Die [b]Zeit[/b] Komponente gibt uns die Anzahl der Nanosekunden seit dem 01.01.1970 als 64-Bit Zahl. Weil unsere Architektur aber mit 32-Bit arbeitet, müssen wir den Wert aufteilen in 2 32-Bit Zahlen. Pro Taktzyklus können wir auch nur einen der beiden Teile verarbeiten, deswegen gibt es die zwei Operationen time_0 und time_1. Bei [color=#ff6680]time_0[/color] soll die [b]Zeit[/b] ausgelesen und der untere Teil zum [color=#ffe666]Zielregister[/color] gesendet werden. Der obere Teil wird gleichzeitig in einem neuen Zwischenregister festgehalten, sodass er in einem späteren Taktzyklus mit [color=#ff6680]time_1[/color] ausgelesen und ebenfalls zum [color=#ffe666]Zielregister[/color] gesendet werden kann. Die tatsächliche Zeit wird also nur bei time_0 gelesen.

Bei [color=#ff6680]counter[/color] soll der Zählerwert, der die aktuelle Adresse des [b]Arbeitsspeichers[/b] bestimmt, ans [color=#ffe666]Zielregister[/color] gesendet werden.

Die [b]Tastatur[/b] Komponente kann Tastenanschläge aufzeichen und speichert diese als [b]Events[/b] in einer Warteschlange (zum Aufzeichen auf den roten Kreis links oben in der Komponente klicken). Über den Pin [b]Event ausgeben[/b] wird das nächste Event der Warteschlage ausgegeben. Solange Events in der Warteschlange sind, ist der [b]Event in Warteschlage[/b] Pin [T]. Pro Tastenanschlag gibt es 2 Events: einmal für [b]Taste gedrückt[/b] und einmal für [b]Taste losgelassen[/b]. Um welches Event es sich handelt, erfährt man über den [b]Taste gedrückt[/b] Pin. Über den Pin [b]Tastenwert[/b] bekommt man den Code für die Taste, die gedrückt wurde (siehe Handbuch). 

Der Wert, der bei [color=#ff6680]keyboard[/color] an das [color=#ffe666]Zielregister[/color] gesendet werden soll, setzt sich aus 2 Teilen zusammen:
[color=#bbbbbb]0000000[/color][color=#e49f44]E[/color] [color=#87a8c8]TTTTTTTT[/color]

[color=#e49f44]E[/color] = Event (losgelassen/gedrückt)
[color=#87a8c8]T[/color] = Tastenwert                  



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

$41535895646297*
Es gibt mal wieder neue Befehle. Aber anders als in den Leveln zuvor, sollst du diesmal nicht deine Architektur erweitern, sondern wir möchten schwierige Assembler-Befehle vereinfachen, sodass wir sie einfacher benutzen können. 

Beispielsweise gibt es keinen [b]NOT[/b] Befehl, aber man kann stattdessen [b]NAND[/b] mit 2 mal dem gleichen Register machen (so wie wir ganz am Anfang auch das NOT Gatter aus NAND zusammengebaut haben). Genau für sowas wollen wir jetzt neue Befehle bauen, die einen eigenen Namen bekommen (einen Alias), aber die eigentlich einen schwierigen Befehl ausführen.

Öffne mit [b]Edit[/b] das Progamm im [b]Arbeitsspeicher[/b] und klicke oben links auf [b]ASM[/b], um zur [b]ISA[/b] Ansicht zu wechseln. Erinnerung: ISA (Instruction Set Architecture) ist der komplette [b]Befehlssatz[/b], der alle Befehle beschreibt, die in der Architektur möglich sind.

Finde mit Hilfe der bestehenden Befehle in der ISA heraus, wie man eigene Befehle/Aliase definieren kann. 

Du sollst folgende Aliase definieren:
[box][left][b]mov [color=#5b8e9e]%a[/color]([color=#cd904c]register[/color]), [color=#657AC3]%b[/color]([color=#cd904c]immediate[/color])
[color=#888888]# Bewegt den Direkten Wert %b nach Register %a.[/color]

neg [color=#5b8e9e]%a[/color]([color=#cd904c]register[/color]), [color=#657AC3]%b[/color]([color=#cd904c]register[/color])
[color=#888888]# Negiert Register %b und speichert das Ergebnis in Register %a.[/color]

not [color=#5b8e9e]%a[/color]([color=#cd904c]register[/color]), [color=#657AC3]%b[/color]([color=#cd904c]register[/color])
[color=#888888]# Bitweises NOT auf Register %b und speichert das Ergebnis in Register %a.[/color][/b][/left][/box]

Sobald die Befehle definiert sind, kann das Assembler-Programm fehlerfrei ausgeführt werden und das Level ist geschafft.



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

$71911284169222*
Die Symphony Architektur hat einen neuen Befehlssatz mit komplexeren Befehlen. Baue einen Schaltkreis, der die Befehle in ihre Einzelteile aufteilt.

Es gibt 2 verschiedene Befehlstypen, abhängig davon, ob wir mit direkten Werten arbeiten oder nicht:

Direkt-Bit [F]: [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]
Direkt-Bit [T]: [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]

[color=#ff9800]M[/color]   = Modus          [color=#ffe666]D[/color] = Zielregister    
[color=#ff6680]O[/color]   = Operation      [color=#66ff99]A[/color] = Argument A      
[color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Direkt-Bit     [color=#66ccff]B[/color] = Argument B      
[color=#bbbbbb]0[/color]   = Unbenutzt      (oder Direkter Wert)



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

$72724057674158*
Mit den ersten 4 Eingangswerten bekommst du den Start:
scheibe_nr  Höhe des Turms bzw. höchste Scheibennummer
quelle      Stabnummer, auf welcher der Turm steht    
ziel        Stabnummer, wo der Turm hin soll          
ablage      Stabnummer, für die Zwischenablage        

Du kannst die Scheiben mit einem Magneten bewegen, der über den Stäben schwebt und auf folgende Ausgangssignale hört:
0  Bewege Magnet zu Stab 0
1  Bewege Magnet zu Stab 1
2  Bewege Magnet zu Stab 2
5  Magent ein-/ausschalten

Mit den Pfeiltasten ← → und ENTER kannst du den Magnet per Hand steuern.

$81427576809439*
Dieses Level ist schwer. Es ist allerdings [b]auch[/b] eine gute Gelegenheit, um [b]Funktionen[/b] auszuprobieren. Tatsächlich ist die folgende [b]rekursive Funktion[/b] (das ist eine Funktion, die sich selbst nochmal aufruft) eine mögliche Lösung:

[b]Türme von Hanoi Algorithmus:[/b]
[box][left]funktion bewege(scheibe_nr, quelle, ziel, ablage) {
    falls scheibe_nr = 0 {
        verschiebe oberste Scheibe von quelle nach ziel
    } sonst {
        bewege(scheibe_nr - 1, quelle, ablage, ziel)
        verschiebe oberste Scheibe von quelle nach ziel
        bewege(scheibe_nr - 1, ablage, ziel, quelle)
    }
}[/left][/box]

[tip]Denke daran alle wichtigen Registerwerte auf den Stack abzuspeichern, bevor du eine Funktion aufrufst, die sie überschreiben könnten.[/tip]



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

$85674599929809* Als wir das letzte mal hier waren, waren die meisten Erdlinge riesige Reptilien. Keiner von denen war intelligent oder höflich genug, um der Galaktischen Föderation beizutreten.



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

$68462760531745* Bitmuster von {field_name} ist nur {actual} Bits breit, erwarte {expected}



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

$81974422302188* Handbuch



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

$39851490511821* Physikalische Position



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

$80966247197959* Sorge dafür, dass ein [T] Signal vom Eingang zum Ausgang fließt 



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


# The text above the 3 LSBs
$38497477227061* Falls [color=#e49f44]Wert {condition}[/color]


# The text below the byte
$59958585065722* {condition} bewege [color=#DD6576][bold]REG 0[/bold][/color] nach Zähler



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

$29594613477534* Du musst neustarten, damit die Sprache geladen wird.


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


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

$81923869207578* Assembler Programmierung



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

$57024194971618*
Der [highlight]\[fields][/highlight] Abschnitt definiert verschiedene Arten von Feldern und welche Werte sie haben können.

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

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

Felder sind durch Freizeilen voneinander getrennt. Jedes Feld startet mit einem Feldnamen in der ersten Zeile und darunter kommen dann ein oder mehrere erlaubte Feldwerte. Die Werte sind Bitmuster, die innerhalb des Feldes alle die gleiche Bit-Breite haben müssen.

Felder werden in Befehlen wie folgt benutzt:
[box]mov r1, r3[/box]

[b]Anführungszeichen[/b]
Manche Architekturen, wie aarch64, erlauben ein optionales "#" vor direkten Werten (also "#" oder eben gar nichts), was beides im Befehl zu 0 ausgewertet werden soll. Das kann man mit Feldern abbilden. Weil man "gar nichts" nicht als Feldnamen angeben kann, ist es in diesem Fall auch möglich Anführungszeichen " um die Feldnamen zu schreiben:
[box]raute
"#" 0
"" 0[/box]

[b]Reservierte Feldnamen[/b]
Es gibt 2 reservierte Feldnamen:
* [highlight]label[/highlight] referenziert Label im Assembler (eg: [highlight]meinlabel:[/highlight]).
* [highlight]immediate[/highlight] referenziert Direkte Werte



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

$32103815380062* Felder



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

$20029422748716*

[b]Operatoren für Ausdrücke[/b]
Es gibt eine begrenzte Menge von Operatoren, für die Konstruktion virtueller Operaden:
[box]
[b]Operator[/b]    [b]Beschreibung[/b]                         [b]Beispiel[/b]      [b]Ergebnis mit %a = -30000[/b]
       !    boolesches not                       !%a           0
      &&    boolesches and                       %a && 7       1
      ||    boolesches or                        %a || 7       1
      \==    gleich                               %a == 7       0
      !=    ungleich                             %a != 7       1
      <u    unsigned kleiner als                 %a <u 7       0
       <    signed kleiner als                   %a < 7        1
     >=u    unsigned größer gleich               %a >=u 7      1
      >=    signed größer gleich                 %a >= 7       0
     <=u    unsigned kleiner gleich              %a <=u 7      0
      <=    signed kleiner gleich                %a <= 7       1
      >u    unsigned größer als                  %a >u 7       1
       >    signed größer als                    %a > 7        0
       ~    bitweises not                        ~%a           29999
       &    bitweises and                        %a & 7        0
       |    bitweises or                         %a | 7        -29993
       ^    bitweises xor                        %a ^ 7        -29993
       +    addition                             %a + 7        -29993
       -    subtraktion                          %a - 7        -30007
       *    multiplikation                       %a * 7        -210000
      /u    unsigned division                    %a /u 7       2635249153387074516
       /    signed division                      %a / 7        -4285
       %    modulo (rest nach division)          %a % 7        -5
      <<    logisches schieben links (LSL)       %a << 7       -3840000
      >>    logisches schieben rechts (LSR)      %a >> 7       144115188075855637
[/box]
Hinweis: Es gibt keine Negations-Operation. Wenn man allerdings ein [b]+[/b] oder [b]-[/b] mit einem leeren ersten Operanden verwendet, wird automatisch der Wert 0 angenommen. Dadurch kann man mit dem [b]-[/b] Operator auch eine Negation darstellen.



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

$21043147057012* Operatoren



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

$64897298154598*
[large]Überblick[/large]

Die Seite [link="Assembly/Language creation"]Sprache erstellen[/link] beschreibt nur grundlegende Befehlsdefinitionen. Diese Seite geht etwas tiefer.

Eine Befehlsdefinition besteht aus den folgenden Zeilen:

[color=#66ff99]Syntax[/color]
[color=#ffe666]Virtuelle Operanden[/color] (optional)
[color=#ff6680]Assertions (Behauptungen)[/color] (optional)
[color=#66ccff]Maschinen-Code[/color]
[color=#9966ff]Beschreibung[/color]

Die Erklärungen beziehen sich alle auf das folgende Beispiel.
Wir möchten einen Sprungbefehl bauen, der die Adresse des Sprungziels bekommt. Im Beispiel wird eine Architektur verwendet, bei der die Befehle 4 Byte breit sind. Deswegen ist es verboten zu Adressen zu springen, die nicht auf 00 enden.
[box][color=#66ff99]jmp %ziel(label)[/color]
[color=#ffe666]%high_bits = %ziel / 4[/color]
[color=#ff6680]assert(%ziel % 4 == 0, "Kann nur zu Adressen mit Abstand 4 springen")[/color]
[color=#66ccff]01 hhhhhh[/color]
[color=#9966ff]# Springt zu %ziel[/color][/box]

[large][color=#66ff99]Syntax[/color][/large]
Syntax ist eine Liste von [b]Literalen[/b] (Buchstaben/Zahlen) und [b]Operanden[/b], die durch [b]Leerzeichen[/b] getrennt sind.

[b]Literale[/b]
Im Beispiel oben ist das mnemonic [highlight]jmp[/highlight] ein Literal. Bei Befehlen mit mehreren Operanden werden die Operanden typischerweise durch [highlight],[/highlight] getrennt. Bei Literalen genauso. 
Falls du das Operandensymbol [highlight]%[/highlight] in einem Literal verwenden möchtest, musst du stattdessen [highlight]%%[/highlight] schreiben.

[b]Operanden[/b]
Befehlsoperanden beginnen mit dem [highlight]%[/highlight] Präfix. 
Beispiel: [highlight]%name(fields)[/highlight]
  * [highlight]name[/highlight] ein eindeutiger Kenner für den Operand. 
  * [highlight]fields[/highlight] eine Liste aus einem oder mehreren Feldern, die zuvor definiert wurden. 
    Die Liste benutzt [highlight]|[/highlight] als Trennzeichen.

[b]Leerzeichen[/b]
Leerzeichen können entweder echte Leerzeichen sein, oder Tabs. Falls nur ein einzelnes Leerzeichen verwendet wird, dann entsteht dadurch ein optionales Leerzeichen-Symbol in der Assembler-Sprache. Falls nach dem Leerzeichen ein weiteres Leerzeichen folgt, dann erwartet der Assembler, dass die Zeichen an dieser Stelle tatsächlich durch Leerzeichen getrennt sind (nicht mehr optional).

[large][color=#ffe666]Virtuelle Operanden[/color][/large]
Die Architektur aus dem jmp Beispiel von oben verwendet Befehle, die 4 Byte breit sind, also müssen die Befehls-Adressen immer auf 00 enden, weil wir nicht innerhalb eines 4 Byte breiten Befehls mit dem Lesen anfangen dürfen. Für unseren Sprung sind die zwei letzten Bits also egal und wir können sie abschneiden. Zum Abschneiden können wir einen Virtuellen Operanden verwenden:
[box]%high_bits = %ziel / 4[/box]
Wir verwenden im Maschinen-Code diesen Virtuellen Operanden [highlight]%high_bits[/highlight] anstatt [highlight]%ziel[/highlight].
Die vollständige Liste aller Operatoren findest du [link="Assembly/Language creation/Instructions/Operators"]hier[/link].

Zwei besondere Operanden werden immer automatisch definiert: [highlight]$start[/highlight] und [highlight]$end[/highlight]. $start ist die Adresse des Maschinen-Codes direkt vor dem Befehl und $end direkt danach. Damit kann man Abstände relativ zum aktuellen Befehl berechnen:
[box]%rel = %ziel - $end[/box]

[large][color=#ff6680]Assertions (Behauptungen)[/color][/large]
Mit Assertions kann man Fehlerprüfungen machen. Im Beispiel oben wird geprüft, ob die Sprungadresse auf 00 endet. Falls nicht erscheint die angegebene Fehlermeldung.


[large][color=#66ccff]Machinen-Code[/color][/large]
Das Beispiel oben verwendet folgende Maschinen-Code Syntax.
[box]01 hhhhhh[/box]
Die Bits, die sich auf Operanden beziehen, werden immer durch ihren ersten Buchstaben dargestellt. Das kleine [highlight]h[/highlight] steht also für den Virtuellen Operanden [highlight]%high_bits[/highlight].

Es gibt auch eine andere Art, um Maschinen-Code zu schreiben: [b]Bit Slicing[/b].
[box]01 %offset\[8:2][/box]
Bit Slicing verwendet Standard-Hardware-Syntax, um Teile eines Bitmusters auszuwählen. Die Syntax ist [highlight]\[von:bis][/highlight] (inklusiv).

Bit slicing kann auf mehrere Operanden angewendet werden und auch mit der anderen Syntax vermischt werden, wo für jedes Bit ein einzelner Buchstabe verwendet wird.

[large][color=#9966ff]Beschreibung[/color][/large]
Die Beschreibung hat keinen Einfluss auf den Assembler und ist nur dafür da, um den Code zu dokumentieren.



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

$27583144414493* Befehle



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

$50803475056346* Muster



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

$13660841232898*
Der [highlight]\[settings][/highlight] Abschnitt definiert verschiedene Einstellungen für deine Architektur:

[b]name[/b]
Name der Architektur.
[box]name = "Meine Architektur"[/box]

[b]variant[/b]
Zusätzliche Beschreibung der Architektur.
[box]variant = "32 Bit Version"[/box]

[b]endianness[/b]
Bestimmt die Byte-Reihenfolge der Architektur.
[box]endianness = big
endianness = little[/box]
Standard ist big endian.

Du kannst [link="Computer concepts/Endianness"]hier[/link] mehr über die Byte-Reihenfolge erfahren.

[box=info]RAM Komponenten haben ihre eigene Endian-Einstellung, die die Byte-Reihenfolge nochmal ändern kann. Das ergibt Sinn, wenn deine Befehle genauso lang sind, wie die Bit-Breite des RAMs, aber kann auch verwirren, wenn die Breiten unterschiedlich sind.[/box]

[b]line_comments[/b]
Spezifiziert die Zeichen, die ein Zeilenkommentar einleiten. Das Zeilenkommentar startet durch die angegebene Zeichenfolge und wirkt sich anschließend auf alle verbleibenden Zeichen der Zeile aus.
[box]line_comments = "#"
line_comments = \[";", "//"]
[/box]
Standard ist [highlight]\[";", "//"][/highlight].

[b]block_comments[/b]
Spezifiziert die Zeichen, die ein Blockkommentar starten und beenden. Blockkommentare wirken sich, nachdem sie gestartet wurden, auf alle folgenden Zeichen aus, inklusive Zeichenumbrücke und weitere startende Kommentarzeichen (dadurch kann man keine Kommentare innerhalb von Kommentaren starten), bis die abschließende Zeichenkette erreicht wird.
[box]block_comments = {"/*":"*/"}
[/box]
Standard ist [highlight]{"/*":"*/"}[/highlight].



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

$78090021698706* Einstellungen



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

$41184546203403*
[large]Überblick[/large]

Hier ein Beispiel für eine einfache Assembler-Definition:
[box][fields]
register
r0 000
r1 001
r2 010
r3 011

[instructions]
mov %a(register), %b(register)
00aaabbb
\# Bewegt einen Wert nach %a von %b

mov %a(register), %b:U8(immediate)
01000aaa bbbbbbbb
\# Bewegt ein Byte nach %a von %b

jmp %a(label)
10000000 aaaaaaaa
\# Springt zu %a
[/box]

Die Definition ist in die beiden Abschnitte [highlight][fields][/highlight] und [highlight][instructions][/highlight] aufgeteilt.

[large][fields] Abschnitt[/large]
Mit Feldern kannst du Bitmustern Namen geben. Normalerweise macht das man bei Registern. Mehr dazu [link="Assembly/Language creation/Fields"]hier[/link].

[large][instructions] Abschnitt[/large]
Befehlsdefinitionen bestehen einer [color=#66ff99]Syntax[/color] Zeile, einer [color=#66ccff]Maschinen-Code[/color] Zeile und einer [color=#9966ff]Beschreibung[/color]:

[box][color=#66ff99]mov %a(register), %b(register)[/color]
[color=#66ccff]00aaabbb[/color]
[color=#9966ff]# Bewegt einen Wert nach %a von %b[/color][/box]
Wenn du Assembler-Befehle programmierst, sucht der Assembler nach der ersten [color=#66ff99]Syntax[/color], die zu dem Befehl passt und erzeugt daraus den zugehörigen [color=#66ccff]Maschinen-Code[/color].

[b][color=#66ff99]Syntax Zeile[/color][/b]
Die Syntax Zeile ist eine Mischung aus hartkodierten Zeichen und Operanden. Operanden starten immer mit [highlight]%[/highlight], gefolgt von einem Namen, mit dem man den Operanden auch in anderen Zeilen referenzieren kann. Nach dem Namen kommt ein Operanden-Feld, welches aus [highlight]label[/highlight], [highlight]immediate[/highlight] oder einem eigenen [highlight]field[/highlight] (was man im [b][fields][/b] Abschnitt definiert hat) bestehen kann.

[b][color=#66ccff]Maschinen-Code Zeile[/color][/b]
Der Maschinen-Code ist ein Bit-Feld, welches aus [highlight]0[/highlight] oder [highlight]1[/highlight] besteht, sowie den Anfangsbuchstaben der Operand-Namen, die wir in der Syntax Zeile definiert haben. [highlight]0[/highlight] und [highlight]1[/highlight] werden so wie sie sind interpretiert. Die Operand-Buchstaben beziehen sich auf jeweils ein Bit des Operand-Wertes.

[b][color=#9966ff]Beschreibung[/color][/b]
Die Beschreibung hat keinen Einfluss auf den Assembler und ist nur dafür da, um den Code zu dokumentieren.

Der Assembler hat noch viel mehr Befehls-Features über die du [link="Assembly/Language creation/Instructions"]hier[/link] mehr erfahren kannst.

[large]Andere Abschnitte[/large]
Neben dem [b][fields][/b] und [b][instructions][/b] Abschnitt gibt es noch zwei weitere Abschnitte: [b][link="Assembly/Language creation/Settings"][settings][/link][/b] und [b][link="Assembly/Language creation/Patterns"][patterns][/link][/b].



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

$67371980949119* Eigene Sprache erstellen



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

$85571962806085* Assembler



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

$65852115931553*
Auto-Breite ist ein Feature, welches dir erlaubt Eigene Componenten mit variabler Bit-Breite zu bauen. Hier ist zum Beispiel ein Zähler, der mit einer beliebigen Bit-Breite funktioniert und eine konfigurierbare Schrittweite hat:
[image="example.png"]

Siehst du, dass manche der Breiten eine leicht andere Hintergrundfarbe haben? Das bedeutet, dass sie ihre Bit-Breite automatisch nach der Breite des Eingangs-Kabels richten. Dies kannst du über den [b]*[/b] Button einstellen.
[image="setting.png"]

Die Auto-Breite kann man für fast alle Komponenten aktivieren und damit ihre Breite variabel an die Bit-Breite des Eingangs anpassen. Man muss aber beachten, dass es auch mehrere Eingänge mit unterschiedlichen Bit-Breiten geben kann. Bei dem Addierer oben wird beispielsweise die größte Bit-Breite der beiden Zahlen-Eingänge verwendent - die Breite des Übertrag-Eingangs wird ignoriert.

Aus technischen Gründen funktioniert die Auto-Breite nicht für Speicher-Komponenten. Für diese gibt es nochmal eine separate Komponenten-Version, die noch einen zusätzlichen [b]blauen Pin[/b] hat. Dieser blaue Pin hat die Auto-Breite aktiviert, sodass man dort ein Kabel anschließen kann, um die Bit-Breite zu bestimmen (der Wert des Kabels ist egal, nur die Breite ist wichtig). Blaue Pins sind dafür da, um Bit-Breiten weiterzuleiten.



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

$18060272082456* Auto Breite



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

$57134685411828*
Eine Kreisabhängigkeit entsteht dann, wenn sich der Eingang einer Komponente aufgrund ihres eigenen Ausgangs ändert.

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

In diesem Simulator sind Kreisabhängigkeiten nicht erlaubt und führen zu einem Fehler.

Die einzige Ausnahme sind orange Pins, die den Ausgang nicht im gleichen Taktzyklus beeinflussen. Deshalb führen sie nicht zu Kreisabhängigkeiten.

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



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

$79928695804890* Kreisabhängigkeit



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

$25269304368822*
In echter Hardware haben alle Komponenten eine gewisse Laufzeit. Diese ist wichtig, denn sie bestimmt letztendlich wie schnell man einen Schaltkreis maximal ausführen kann.

Folgst du den Kabeln vom Eingang zu Ausgang, und addierst alle Laufzeiten, ergibt das die Gesamtlaufzeit für diesen Pfad. Der Pfades mit der höchsten Laufzeit (der kritische Pfad) bestimmt die Laufzeit des gesamten Schaltkreises.



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

$82367602514282* Verzögerung



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

$20065838867866*
In der Elektronik kommt es zu einem Kurzschluss, wenn zwei Komponenten verschiedene Signale auf das gleiche Kabel leiten.

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

Trotzdem ist es möglich mehrere Pins an das gleiche Kabel anzuschließen, sofern man Ausgänge komplett abschalten kann (das gemeinsam genutzte Kabel heißt dann "Bus"). Wichtig ist, dass in jedem Taktzyklus nur eine Komponente aktiv sein darf, ansonsten riskierst du einen Kurzschluss.

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

In diesem Simulator werden abschaltbare Pins grau dargestellt.



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

$80662783536910* Kurzschluss



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

$43200267887776*
Öffne die Werkstatt, indem du in der Symbolleiste oben links auf dieses Symbol klickst .

Die Werkstatt ermöglicht es dir, eigene Komponenten zu erstellen. Der Schaltkreis, den du baust, bestimmt das Verhalten der Komponente und die Anordnung der Bauteile bestimmt ihre Form.

Ein- und Ausgänge werden zu Pins der Komponente.

Sonden innerhalb eigener Komponenten zeigen ihre Werte an der Stelle, wo sie platziert sind, nach außen. Sonden können mit anderen eigenen Komponenten verbunden werden, sodass auch tief verschachtelte Werte angezeigt werden können. Die so angezeigten Werte können auch an eine Programm-Komponente angeschlossen werden.

Die Ordnerstruktur für eigene Komponenten entspricht der des Dateisystems. Der Dateiname bestimmt den Namen der Komponente und die Ordnerstruktur bestimmt den Ort, an der die Komponente im Menü angezeigt wird.



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

$83185064398279* Werkstatt



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

$18477347795935*
Die Tastatur Komponente nimmt Tastenanschläge der Tastatur auf.

Jeder Tastenanschlag feuert 2 Events: 
1. [b]key down[/b] (Taste gedrückt)
2. [b]key up[/b]   (Taste losgelassen)
Die Events werden in einer Warteschlange aufgezeichnet und können der Reihe nach von der Komponente ausgelesen werden (pro Taktzyklus immer nur 1 Event).

[large]Tastatur Modi[/large]
In unterschiedlichen Ländern gibt es unterschiedliche Tastaturbelegungen. Beispielsweise startet die englische Tastatur mit den Buchstaben QWERTY, anstatt wie im Deutschen mit QWERTZ.

Wenn man einen Text-Editor programmiert, dann interessiert man sich nicht dafür, wo genau ein Buchstabe auf der Tastatur vorkommt, sondern es geht um den Buchstaben, der auf der Taste abgebildet ist. In diesem Fall benutzt man den [b]Lokalisierten Modus[/b] (Standard).

Wenn man aber beispielsweise ein Spiel programmiert und man für die Steuerung WASD verwenden möchte, dann wäre das auf einer französischen Tastatur ZQSD. In diesem Fall interessiert man sich nicht für den abgebildeten Buchstaben, sondern man möchte wissen, ob eine Taste an einer bestimmten physikalischen Position auf der Tastatur gedrückt wurde. In diesem Fall nutzt man den Modus [b]Physikalische Position[/b].

[large]Lokalisierter Modus[/large]
In diesem Modus liefern die Tasten ihren jeweiligen ASCII-Wert, falls möglich. Das [highlight]z[/highlight] auf einer QUERTZ, QUERTY oder jeder anderen Tastatur liefert immer den Hex-Wert [highlight]0x7A[/highlight].

[large]Physikalischer Positions Modus[/large]
In diesem Modus werden die Tasten nach ihrer Zeile und Spalte angeordnet. Zeile und Spalte sind jeweils 4 Bits, sodass Positionen hübsch als Hex-Wert geschrieben werden können. Die Leertaste ist beispielsweise in der 5. Zeile, 3. Spalte und hat damit den Hex-Wert 0x53.

[image="coordinate_mode.png"]

Beachte, dass die Tasten auf der rechten Seite der schwarzen Linie größere Zeilennummern haben, damit alle Tasten mit der 4-Bit Schreibweise abgebildet werden können.

Falls deine Tastatur anders als im Bild aussieht, kannst du einfach ausprobieren, welche Taste welche Werte zurückgibt.



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

$11486015900582* Tastatur



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

$53269020658041* Bildschirm



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

$42610024611500*
Schaltkreise



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

$69772243733094*
ASCII ist eine Zuordnung von 7-Bit Zahlen zu Zeichen (im Spiel verwenden wir erweitertes ASCII mit 8 Bits).

[b]Code  Wert   Beschreibung[/b]
  0    NUL    Nullzeichen (Null)
  1    SOH    Anfang des Kopfes (Start of header)
  2    STX    Anfang des Textes (Start of text)
  3    ETX    Ende des Textes (End of text)
  4    EOT    Ende der Übertragung (End of transmission)
  5    ENQ    Statusabfrage (Enquiry)
  6    ACK    Positive Rückmeldung (Acknowledgment)
  7    BEL    Klingel (Bell)
  8    BS     Rückwärts/Löschen (Backspace)
  9    HT     Zeichen-Tabulator (Horizontal tab)
 10    LF     Zeilenschritt (Line feed)
 11    VT     Zeilen-Tabulator (Vertical tab)
 12    FF     Formularvorschub (Form feed)
 13    CR     Rückführen (Carriage return)
 14    SO     Dauerumschaltung (Shift out)
 15    SI     Rückschaltung (Shift in)
 16    DLE    Datenübertragungsumschaltung (Data link escape)
 17    DC1    Gerätesteuerzeichen 1 (Device control 1 (XON))
 18    DC2    Gerätesteuerzeichen 2 (Device control 2)
 19    DC3    Gerätesteuerzeichen 3 (Device control 3 (XOFF))
 20    DC4    Gerätesteuerzeichen 4 (Device control 4)
 21    NAK    Negative Rückmeldung (Negative acknowledgement)
 22    SYN    Synchronisierung (Synchronous idle)
 23    ETB    Ende des Übertragungsblocks (End of transmission block)
 24    CAN    Ungültig/Abbrechen (Cancel)
 25    EM     Ende der Aufzeichnung (End of medium)
 26    SUB    Substitution
 27    ESC    Escape
 28    FS     Hauptgruppen-Trennzeichen (File separator)
 29    GS     Gruppen-Trennzeichen (Group separator)
 30    RS     Untergruppen-Trennzeichen (Request to send/record separator)
 31    US     Teilgruppen-Trennzeichen (Unit separator)
 32    SP     Leerzeichen (Space)
 33    !      
 34    "      
 35    #      
 36    $      
 37    %      
 38    &      
 39    '      
 40    (      
 41    )      
 42    *      
 43    +      
 44    ,      
 45    -      
 46    .      
 47    /      
 48    0       
 49    1       
 50    2       
 51    3       
 52    4       
 53    5       
 54    6       
 55    7       
 56    8       
 57    9       
 58    :      
 59    ;      
 60    <      
 61    =      
 62    >      
 63    ?      
 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    \[      
 92    \\      
 93    ]      
 94    ^      
 95    _      
 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    {      
124    |      
125    }      
126    ~      
127    DEL    Entfernen (Delete)



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

$75719044675256* ASCII Kodierung



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

$39479426746559*
Die Zahlen, die du kennst, sind in Basis 10. Das bedeutet, wenn du rechts eine 0 hinzufügst, dann wird der Wert 10 mal so groß. 

Binär heißt Basis 2. Das bedeutet, wenn du rechts eine 0 hinzufügst, verdoppelt sich die Zahl nur.
Anders gesagt heißt das: Jede Ziffer repräsentiert eine Zweierpotenz.
Als Beispiel ([color=#c54d5e]Basis 2[/color] und [color=#e49f44]Basis 10[/color] farblich hervorgehoben):
[color=#c54d5e]  1[/color] = [color=#e49f44]1[/color]
[color=#c54d5e] 10[/color] = [color=#e49f44]2[/color]
[color=#c54d5e]100[/color] = [color=#e49f44]4[/color]

Um eine 6 darzustellen, können wir einfach 4 und 2 zusammenrechnen:
[color=#c54d5e]110[/color] = [color=#e49f44]6[/color]

Addition, Multiplikation und alles andere funktioniert genau so wie in Basis 10, außer dass man schon bei 2 einen Übertrag erhält, anstatt bei 10.



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

$73447955210779* Binäre Zahlen



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

$64065714320299*
In diesem Spiel geht es darum, einen 8-Bit-Computer zu bauen. In der Praxis würde dies normalerweise bedeuten, dass der Spieler an vielen Stellen 8 parallele Kabel verlegen muss.
Um die mühsame Arbeit zu erleichtern, gibt es den Begriff des Bytes, welches lediglich ein virtuelles Bündel von 8 Bits ist.

Der Wert eines Byte-Eingangs/Ausgangs bzw. eines Byte-Kabels wird durch eine Zahl, anstelle von roter und grüner Farbe dargestellt.



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

$68430971305988* Bytes



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

$13079267765950*
Die Wahrheitstabellen der vier Grundgatter sind symmetrisch. Du kannst sie inneinander überführen, indem du den [color=#6e9759][b]Eingang invertierst[/b][/color] (vertikale Pfeile) oder den [color=#596197][b]Ausgang invertierst[/b][/color] (horizontale Pfeile), wie im Bild dargestellt. Invertieren bedeutet, dass du den Wert durch ein NOT umdrehst.

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

Hinweise
1. Du kannst jedes Grundgatter in jedes andere überführen, im schlimmsten Fall musst du sowohl ein NOT vor die Ein- als auch vor die Ausgänge setzen.
2. Du kannst zwischen OR/NOR wechseln indem du den Ausgang invertierst. Gleiches gilt für AND/NAND. Tatsächlich heißt NOR eigentlich NOT OR und NAND heißt NOT AND. Deswegen sieht die Komponente von OR/NOR auch gleich aus, mit Ausnahme des kleinen Punktes am Ausgang, welcher NOT bedeutet. AND/NAND sind ebenso identisch, bis auf den Punkt.
3. Wenn du den Ausgang invertierst, kehrt das alle Bits der letzten Zeile der Wahrheitstabelle um. Wenn du die Eingänge invertierst, spiegelt das die Werte der letzten Zeile der Wahrheitstabelle in der Mitte.



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

$66359790889628* De Morgansche Gesetze



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

$78199387512682*
Üblicherweise schreiben wir Daten von links nach rechts in den Speicher mit aufsteigenden Adressen. Dadurch wird auch ASCII text von links nach rechts dargestellt.

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

Bei Zahlen ist die Konvention genau anders herum, indem man die größte Ziffer links schreibt, sodass "dreizehn" [color=#ff6680]13[/color] geschrieben wird, anstatt [color=#ff6680]31[/color].

Dadurch liegt es nahe eine Multi-Byte-Zahl wie etwa 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] wie folgt abzuspeichern:

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

Diese Speicherart heißt [b]Big Endian[/b], weil die großen Ziffern an kleineren Adressen abgespeichert werden.

Allerdings ist es aus algorithmischer Sicht umständlich, wenn Zahlen in die entgegengesetzte Richtung wie der Text wachsen. Einige Anwendungen, wie beispielsweise die Kryptografie, benötigen unbegrenzte Zahlen (BigInt), und um dies zu erreichen, muss man in der Lage sein, die Anzahl der Ziffern zu erweitern oder nachgestellte Nullen zu entfernen. Es ist naheliegend, die Ziffern so anzuordnen, dass man die Zahl vergrößern kann, ohne den Zeiger, der auf die Zahl verweist, aktualisieren zu müssen. Man könnte natürlich festlegen, dass eine Vergrößerung in die entgegengesetzte Richtung erfolgt; in diesem Fall würde man jedoch beim Anhängen an Text auf dasselbe Problem stoßen (oder zwei Arten von vergrößerbaren Arrays implementieren müssen).

Es gibt weitere Aspekte der Speicherung von Zahlen mit den niedrigstwertigen Bits an erster Stelle, die sich als vorteilhaft erweisen. Beispielsweise ist es viel häufiger der Fall, dass man nur die niedrigstwertigen Bits (Downcasting) einer Zahl benötigt, als dass man nur die höchstwertigen Bits benötigt. Die Speicherung von Zahlen mit der niedrigstwertigen Ziffer an erster Stelle bedeutet wiederum, dass dies ohne Änderung des Zeigers möglich ist.

Die aus rechnerischer Sicht naheliegende Konvention, die niedrigstwertigen Ziffern zuerst zu speichern, wird als [b]Little Endian[/b] bezeichnet. Leider wird die Darstellung von Little Endian im Allgemeinen noch verwirrender, weil die Werte in Byte-Gruppen zusammengefasst werden, die jeweils in der herkömmlichen Reihenfolge angezeigt werden. Deswegen wird 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] zu:

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

Wäre es üblich gewesen, Zahlen und Text so zu schreiben, dass sie in derselben Richtung wachsen, gäbe es keinen Bedarf für diese Handbuchseite.

Heutzutage verwenden alle modernen CPUs "Little Endian", und dies hat sich allgemein als Standard durchgesetzt – mit der Ausnahme von TCP/IP, das "Big Endian" verwendet.



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

$25715726162519* Byte-Reihenfolge



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

$22037524510182*
Die Art, wie dieses Spiel negative Zahlen darstellt, heißt "Zweierkomplement". Es ist die Standarddarstellung negativer Zahlen in modernen Computern.
Hier sind die wichtigsten Punkte zum Zweierkomplement:
 1: Um von positiv zu negativ zu wechseln, flippen wir alle Bits und addieren 1.
 2: Wenn das höchste bin [T] ist, ist der Wert immer negativ.
 3: Addierer funktionieren für Zahlen mit Vorzeichen genauso wie für Zahlen ohne Vorzeichen.
 4: Es gibt für jede Zahl eine eindeutige Darstellung.

In den Anfängen der Computertechnik war das Einerkomplement der Hauptkonkurrent des Zweierkomplements. Sein Hauptvorteil besteht darin, dass man das Vorzeichen einer Zahl einfach ändern kann, indem man einfach jedes Bit der Zahl durch NOT ändert. Es gibt dann jedoch 2 Darstellungen für 0, eine positive und eine negative, was Vergleiche erschwert.

Eine weitere interessante Darstellung, die es sich lohnt anzusehen, ist die zur Basis -2, bei der das Vorzeichen des Wertes jeder Ziffer zwischen positiv und negativ wechselt.



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

$64907157003500* Negative Zahlen



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

$16579770195459*
Die Tabellen mit Eingangs-/ und Ausgangssignalen, die überall im Spiel verwendet werden, sind als [b]Wahrheitstabellen[/b] bekannt.

[center]
Eingang 1 [F][T][F][T]
Eingang 2 [F][F][T][T]
Ausgang   [T][T][T][F]
[/center]

Eingänge und Ausgänge werden oft durch Variablen repräsentiert, wie auch in der Algebra. Und anstatt Farben [F]/[T] zu benutzen, verwendet man oft 0/1 oder Falsch/Wahr.



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

$39788153942181* Wahrheitstabellen



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

$38118080841071*
Bestimmte Computer, wie beispielsweise einfache Taschenrechner, sind in den Algorithmen, die sie ausführen können, eingeschränkt.

Sie können keine Berechnungen durchführen, die eine beliebig oft wiederholte Schleife oder Rekursion erfordern. Technisch gesehen können Maschinen ohne Schleifen oder Rekursion nur mit kombinatorischer Logik umgehen.

Turing-vollständige Maschinen hingegen sind so leistungsfähig, wie es nur möglich ist. Eine Turing-vollständige Maschine mag zwar eine langsame CPU haben, es gibt aber theoretisch keinen berechenbaren Algorithmus, den die Maschine nicht ausführen kann.



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

$88124920557040* Turing vollständig



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

$11499640163947*
Es stellte sich heraus, dass man die ganze Logik für einen Computer nur aus entweder NAND oder NOR Gattern bauen kann. Die Apollo Navigations-Computer, wurden nur aus NOR Gattern gebaut. In den sechziger Jahren entworfen, verfügten die Computer über lediglich 4 KB RAM und 32 KB Speicherplatz, navigierten die Astronauten aber dennoch zum Mond.

Moderne Computer sind nicht ausschließlich aus einem universellen Gatter gebaut, aber wenn anwendbar, werden NAND Gatter gegenüber NOR Gattern bevorzugt, weil sie eine schnellere Laufzeit haben und weniger Platz verbrauchen.



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

$24291443495513*
Universelle Gatter



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

$42755701050268*
Computer Konzepte



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

$62210202128540* Das Eingangssignal hat keinen Einfluss auf das Ausgangssignal.



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

$33906573915218* Verwende ein beliebiges Gatter, dass [T] ausgibt, ohne angeschlossen zu sein.



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

$18258110894478* Dieses Level schaltet deinen ersten [b]Handbuch[/b]  Eintrag frei. Dieser ist sogar ziemlich wichtig, also schau ihn dir gut an.

$61066799501731* Immer An

$85978749941194*
Baue einen Schaltkreis, der immer [T] ausgibt

[tip]Du kannst dich auch bewegen, indem du das Mausrad (oder die mittlere Maustaste) gedrückt hältst[/tip]



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

$68158507707802* Das NAND ist ein NOT-AND. Durch ein weiteres NOT wird es wieder zum AND.



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

$18221128000007*
Baue aus NAND und NOT Gattern einen Schaltkreis,
der zur Wahrheitstabelle passt.

Das entstehende [b]AND Gatter[/b] ist [T], 
wenn Eingang 1 [b]und[/b] Eingang 2 [T] sind.

[tip]Die meisten Level haben einen Hinweis  den du anklicken kannst, wenn du nicht weiter weißt.[/tip]

$70892117360845* AND Gatter



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

$34539182309616* Ein großes AND Gatter ist nichts anderes als mehrere ANDs hintereinander.



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

$28751026881977* Baue ein [b]AND Gatter[/b] mit 3 Eingängen.

$32912994842868* Großes AND Gatter



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

$10183449965120* Wenn ein Paar von Bits [T] ist, dann sind mindestens 2 [T]. Also prüfen wir Paare.



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

$83867604619162* Ein Paar von Bits ist genau dann [T], wenn ein AND Gatter [T] ausgibt.



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

$34521278233301* Aber du kannst gerne versuchen eine bessere Lösung zu finden!

$43216513907358* Diese Lösung ist nicht die eleganteste und auch nicht die beste.



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

$43068867747292*
Dieses Level hat 4 Eingänge.

Wenn 2 oder mehr davon [T] sind, gib [T] aus.

[tip]Die Lösung muss nicht perfekt sein[/tip]

$81647833476822* Mindestens zwei Signale



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

$11603603520594* (move) Bewegt einen Wert von %b nach %a.



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

$17226968214352*
Lochkarten-Programmierung nervt. Gleiche Aufgabe nochmal, aber diesmal mit [b]Assembler[/b]-Programmierung.

Lese den Eingang, addiere 5 und gib das Ergebnis am Ausgang aus.

$72990407719621* Assembler Programmierung



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

$36228934755685* Bewegt 15 nach reg 0

$41299869859669* Dies ist ein Kommentar



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

$38629344681843* {input_value} + 5 ist {expected_value}, nicht {actual_value}.

$47165251832545* {input_value} + 5 ist {expected_value}, nicht Z.



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

$27941792707668* Addiere 5 auf den Eingangswert mit Hilfe von Assembler-Programmierung



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

$31456617450268* (move) Bewegt einen Wert von %b nach %a.



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

$12002017150690*
Klicke auf den [b]Edit[/b] Button am Programm-Teil der RAM Komponente, um die Befehle des Programms zu editieren. Es ist zwar keine echte Lochkarte, aber auch hier musst du für jedes Bit entscheiden, ob es [T] sein soll - genau wie damals bei den Lochkarten.

Deine Aufgabe ist es den Eingang zu lesen, 5 zu addieren, und das Ergebnis zum Augang zu leiten.

$23659479615536*
Du hast deinen ersten Computer gebaut. Jetzt musst du nur noch lernen, wie man ihn programmiert.

In frühen Computern war das Programm nur ein langer Pappstreifen, in dem man für jedes [T] Bit eines Befehls ein Loch eingestanzt hat. Das gesamte Programm war also in binär programmiert. Wenn ein Bit [T] sein sollte, wurde an der passenden Position ein Loch eingestanzt. Wenn an dieser Stelle kein Loch war, wurde das als [F] interpretiert.

$47348572622406* Lochkarten Programmierung



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

$61846111928326* {input_value} + 5 ist {expected_value}, nicht {actual_value}.

$81797824381193* {input_value} + 5 ist {expected_value}, nicht Z.



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

$65391114076509* Addiere 5 auf den Eingangswert und gib das Ergebnis aus



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

$17561499905402* Dieses Level ist meine Lieblingsbeschäftigung: Umrechnen von dezimal in binär auf Zeit.

$37988524800638* Binär Rennen

$78267067157141*
Klicke auf die Bits, sodass sie zusammen die angegebene Dezimalzahl ergeben.

Sobald du Stufe 3 geschafft hast, geht es weiter.



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

$16764912826624* Binäre Suche

$20948899837760*
Pass auf: ich denke mir eine geheime Zahl, und du musst sie am Ausgang ausgeben. Du darfst gerne raten. Falsche Ausgaben sind okay.

Falls du zu hoch geraten hast, gebe ich dir danach am Eingang eine [b]1[/b] und ansonsten eine [b]0[/b]. Dadurch kannst du den Zahlenbereich einschränken und die Zahl schneller finden.



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

$32998192994042* Für die Summe brauchen wir etwas ähnliches wie aus dem Level [b]Ungerade Anzahl an Signalen[/b].

$90884846016283* Der Übertrag ist genau dann [T], wenn beide Eingänge [T] sind.



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

$10776402819741* Wir messen das Universum mit Zahlen. Also muss unserer Computer wissen wie man zählt.

$19285770105090*
Betrachte die Eingänge als [b]0[/b] oder [b]1[/b] abhängig davon ob sie [F] oder [T] sind. Addiere die Eingänge binär zusammen, sodass das Ergebnis entweder [b]0[/b] oder [b]1[/b] ist.

Falls das Ergebnis nicht in einer Ziffer passt, dann setze den [b]Übertrag[/b] auf [b]1[/b].

[tip]Zum Übertrag sagt man oft
"Eins gemerkt" oder "Eins im Sinn"[/tip]

$64470174232265* Halbaddierer



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

$53559965601096* Baue einen bedingten Wert-Invertierer. Wenn [b]Invertieren[/b] [T] ist, dann gib das Gegenteil von [b]Wert[/b] aus. Andernfalls gibt [b]Wert[/b] unverändert aus.

$76209391067704* Dieses Level ist exakt gleich zum XOR Level, welches du schon gelöst hast. Egal was wir dir erzählen - die Wahrheit steckt immer in der Wahrheitstabelle.



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

$29875779381032* Wert

$41975883966377* Aktueller Ausgang

$42809920196772* Invertieren

$62797002040657* Erwarteter Ausgang



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

$22413958203952* Die Wahrheitstabelle entspricht genau einem XOR Gatter

$46480779443140* Lass uns kurz annehmen, dass die Komponenten nicht eingeschränkt sind



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

$45466715038362* Jetzt müssen wir nur noch das OR Gatter eliminieren, um im Budget zu bleiben

$76027454955517* Ein Schalter ist einem AND-Gatter sehr ähnlich, also ersetzen wir beide AND durch Schalter



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

$12922292218235* Bit Schalter

$77268807700313* Baue ein XOR-Gatter aus 2 NOT-Gattern und 2 Bit-Schaltern



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

$37690209655811* Du brauchst nur 8 Volladdierer



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

$49335074955899* Auf Bit-Ebene können wir dann die "Volladdierer"-Komponente verwenden

$56143546486508* Wie auch bei anderen Byte-Komponenten, spalten wir die Bytes in ihre Bits auf



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

$57534334907443* Füge 7 weitere Volladdieren hinzu, einen für jedes Bit



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

$36646953278480* Der ausgehende Übertrag des letzten Bits wird zum eingehenden Übertrag des nächsten Bits

$69804974830322* Schließe die beiden Übertrag-Pins des Levels an, um die Schaltung zu vervollständigen



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

$45190053242926* Übertrag Eingang

$76244671092409* Übertrag Ausgang



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

$31490345812891* Addiere die zwei Bytes. Die Bits werden einzeln zusammengerechnet und ergeben das zugehörige Ausgangs-Bit und gegebenenfalls einen Übertrag für das nächste Bit.

$45061087867940*
Falls das Endergebnis nicht in 8 Bits passt, schalte den Übertrag-Ausgang [T]
(quasi wie ein 9. Bit)

Außerdem gibt es einen Übertrag-Eingang. Später soll man viele dieser Addierer hintereinander verketten können, um große Zahlen addieren zu können. Dieser Eingang ist sozusagen der Übertrag des davor geschalteten Addierers. Er soll im ersten Bit dazu gerechnet werden.

$53076615315445* Außerdem hat das Level sehr viele Testfälle. Mit einem [b]Rechtsklick[/b] auf [b]Ausführen[/b]  kannst du die Geschwindigkeit der Testfälle erhöhen.

$62793095496458* Bytes addieren



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

$51758065631068* [color=#E49F44][left]Übertrag       Summe[/left][/color]



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

$53539145017840* ASR



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

$55176290924321* Baue einen Schaltkreis, der immer die Zahl 164 ausgibt

$55259569122850* Byte Konstante



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

$90758832592628* Baue einen Schaltkreis, der immer die Zahl 164 ausgibt



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

$15513439442399* Teile die zwei Eingangs-Zahlen und gib das Ergebnis am Ausgang aus. Bei Division durch 0, gib 0 aus. Dieses Level ist ziemlich schwer und deswegen optional. 

$55155519654685* Division



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

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



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

$86943286745277* Teile die beiden Zahlen



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

$13186595896308* Ein XOR von zwei gleichen Zahlen ergibt einen hübschen Wert



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

$85034261531833* Ein XOR von 2 Zahlen ergibt nur dann 0, wenn sie gleich sind



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

$16679981460998* Baue einen Schaltkreis, der [T] ausgibt, wenn beide Eingänge gleich sind

$44220989927736* Gleichheit



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

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

$32432328437519* Der Wert {a} ist nicht gleich {b}

$51276780017906* Der Wert {a} ist gleich zu {b}



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

$41065065514143* Baue einen Schaltkreis, der [T] ausgibt, wenn beide Eingänge gleich sind



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

$82755888644217* Wenn die Vorzeichen-Bit der beiden Zahlen unterschiedlich sind, können wir sie einfach vergleichen



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

$52492743864774* Ansonsten müssen wir die beiden 7-bit Zahlen vergleichen



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

$12621415211383*
Baue einen Schaltkreis, der [T] ausgibt, wenn der erste Eingang kleiner ist als der zweite.

In diesem Level haben die Zahlen haben ein Vorzeichen und können negativ sein. Diese Zahlendarstellung mit Vorzeichen heißt [b][color=#dd6576]signed[/color][/b].

$57911276445846* Kleiner als (signed)



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

$18672872329218* Der Wert {a} ist nicht kleiner als {b}

$60636366241019* Der Wert {a} ist kleiner als {b}

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



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

$33907970782848* Baue einen Schaltkreis, der [T] ausgibt, wenn die Zahl A kleiner ist als die Zahl B



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

$18968293717104* Eine Möglichkeit ist Ziffer für Ziffer zu vergleichen, wie wir das auch mit Dezimalzahlen machen

$45223418140453* Zum Beispiel ist 09 < 21 weil 0 < 2, also ist 1100 > 1001 weil 11XX > 10XX



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

$23270172293605* Also brauchen wir für jedes Bit eine OR-Kette um zu prüfen, ob ein höheres Bit [T] ist

$34091176621640* Dafür können wir ein XOR verwenden (XOR wird [T], wenn die Signale unterschiedlich sind)

$38704349429368* Zuerst müssen wir prüfen, welche Bits sich in den 2 Bytes unterscheiden

$45560562333305* Aber wir dürfen wirklich nur das höchste unterschiedliche Bit betrachten

$72421677239233* Das höchste unterschiedliche Bit entscheidet, welche Zahl die größere ist



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

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

$73589178770254* Eine andere Möglichkeit ist den Unterschied der Zahlen mit 0 zu vergleichen



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

$19139933016995* Wir haben keine Komponente für die Subtraktion, nur Addition und Negierung

$56709208304109* Also wandeln wir beispielsweise 1100 - 1001 zu 1100 + (-1001)



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

$21199347421587* Wir müssen also mit 9-Bit "Bytes" arbeiten

$46518640933018* Wir haben 8-Bit als Eingang ohne Vorzeichen, brauchen für die Negierung aber ein Vorzeichen



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

$11293872851403* Wir können entweder eine eigene 9-Bit Komponente bauen 

$17291563256662* Oder wir zerlegen NEG in NOT und ADD_1 und fügen die Einzelteile hinzu



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

$90593296729801* Jetzt noch die Schaltung vereinfachen



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

$39605373706887* Kleiner als (unsigned)

$68842379350661*
Baue einen Schaltkreis, der [T] ausgibt, wenn der erste Eingang kleiner ist als der zweite.

In diesem Level haben die Zahlen haben kein Vorzeichen und sind alle positiv. Diese Zahlendarstellung ohne Vorzeichen heißt [b][color=#dd6576]unsigned[/color][/b].



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

$50702714470018* Der Wert {a} ist nicht kleiner als {b}

$54835419299907* Der Wert {a} ist kleiner als {b}

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



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

$88632565567686* Baue einen Schaltkreis, der [T] ausgibt, wenn die Zahl A kleiner ist als die Zahl B



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

$17566441654249* Schieben



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

$26791208073532* Deine Aufgabe ist es, den ersten Eingang zu verschieben, und zwar um die Anzahl der Stellen, die der [b]Schieben[/b] Eingang vorgibt.

$36654581830314* LSR

$83781539475221*
Sehr gut!

Zusätzlich zur [b]Logisch Schieben Rechts[/b] Komponente bekommst du auch das [b]Logisch Schieben Links[/b] und das [b]Rotieren[/b]. Beim Rotieren kommen die "rausgeschobenen" Bits auf der anderen Seite (beim höchsten Bit) wieder rein.



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

$84095392269624* Modulo

$87605997307596* Gib den Modulo der beiden Eingangs-Zahlen aus (der Rest, der übrig bleibt, wenn man die Zahlen teilt). Wenn die zweite Zahl 0 ist, gib die erste Zahl aus.



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

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



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

$76653207214085* Rest, nachdem die zwei Eingänge geteilt wurden.



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

$37740515704094* Dieses Level ist sehr ähnlich zum "Bit-Schalter"



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

$63172000393911* Auswahl



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

$44523532982427*
In diesem Level hast du einen [b]Auswahl[/b] Eingang, der entscheidet, ob [b]Wert A[/b] oder [/b]Wert B[b] ausgegeben werden soll. 

Wenn [b]Auswahl[/b] [F] ist, dann gib [b]Wert A[/b] aus und sonst [/b]Wert B[b].

$75861961518456* Multiplexer



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

$15140861344476* Wähle {select}



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

$28574225028041* Wähle A oder B



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

$88766421259023* Byte NAND von zwei Zahlen ist ein NAND-Gatter für jedes Bit



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

$11980470862173* Byte NAND

$66454601163361* Mach dir keine Sorgen. Wenn du keinen Computer bauen kannst, wirst du wieder ausgewildert, oder du kommst in einen Zoo mit viel Platz, in dem man sich um dich kümmert.



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

$55051011788323* Byte NOT einer Zahl ist ein NOT-Gatter für jedes Bit



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

$54090032127372* Bitte einmal "NOT" für jedes Bit des Eingangs

$60317070264440* Daher ist die Anzahl der Arme eines Lebewesens eindeutig der wichtigste Faktor für die Intelligenz. Wusstest du, dass es auf deinem Planeten Meerestiere gibt, die viermal so viele Arme wie du haben und in den Tests besser abschneiden?

$65498108564418* Byte NOT

$70777086019982* Der Schlüssel zur Intelligenz, ist das Bauen und Nutzen von Werkzeugen in frühen Evolutionsstufen.

$79214241606407* Unser früheres Modell, wonach die Gehirngröße der wichtigste Faktor für Intelligenz ist, war naiv.



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

$66692685876410* Byte XOR von zwei Zahlen ist ein XOR-Gatter für jedes Bit



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

$41472172986798* Byte XOR

$70973830134418* Baue einen Schaltkreis, der die beiden Eingänge bitweise XOR-verknüpft



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

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



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

$62779271315005* Baue einen Schaltkreis, der die beiden Eingänge bitweise XOR-verknüpft



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

$22440157378882* Großschreiben

$36850349097673*
In diesem Level bekommst du Sätze, wo du immer den ersten Buchstaben jedes Wortes groß schreiben sollst.

Wir verwenden die ASCII-Kodierung. Das bedeutet jeder Buchstabe und jedes Zeichen hat eine eindeutige Zahl, die sagt welches Zeichen es ist ([link="Computer concepts/ASCII encoding"]siehe Handbuch [/link]). Die Zahlen kommen einzeln am Eingang an.

Die Wörter sind durch Leerzeichen getrennt (ASCII-Wert 32) und du bekommst sonst nur Kleinbuchstaben von a-z. Du sollst den Satz zeichenweise am Ausgang wieder ausgeben, aber jedes Wort soll mit einem Großbuchstaben beginnen.



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

$37137490280093* Du hast den Buchstaben {character} des Satzes noch nicht ausgelesen

$52976618691411* Ausgang sollte {char} sein, nicht {output}



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

$21808795465233* Kreisumfang

$46884494321384*
In diesem Level bekommst du einen Radius und sollst einen Kreisumfang berechnen.

Hier ist die Formel: 2×π×r

Den Radius r bekommst du am Eingang.
Du kannst π als 3 annehmen.
(aber das bleibt unter uns)

Sende das Ergebnis nach der Berechnung zum Ausgang.



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

$18136442036625* Was ist 2⋅π⋅{radius}?



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

$24129473753872* Berechne den Kreisumfang für den gegebenen Radius am Eingang

$47357954866257* *Angenommen π ≈ 3



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

$38150072401115* Lies den Wert des Eingangs, solange bis du die Zahl 37 bekommst. Danach sollst du ausgeben, wie oft du den Eingang gelesen hast.

$38613585637577*
Gute Nachrichten für dich: Der Delfin ist ausgeschieden!

Mit Flossen zu programmieren ist aber auch wirklich nicht einfach.

Jedenfalls werden die Tests dennoch fortgesetzt, um zu sehen, wie weit die Menschen kommen.

$40525671378957*
In diesem Level geht es um Sprünge und Label. 

Ein Sprung ist ein Befehl, der den Zähler überschreibt und damit die Adresse des nächsten geladenen Befehls verändert. Dadurch können wir im Programm an bestimmte Stellen "springen", anstatt die Befehle der Reihe nach abzuarbeiten.

$47703565240245* Bedingte Sprünge



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

$35642914965530* Springt zu Byte 5 des Programms

$50319416070023* Bewegt 5 nach r0

$66946505646203* So kannst du seine Addresse lesen

$67381454058237* Das ist ein Label



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

$39953782121467* Der letzte Eingang war nicht 37.

$75138288162938* Du hast den Eingang {read_count} mal gelesen, nicht {output} mal.



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

$65261628219716* Gib die Anzahl der Lese-Operationen des Eingangs aus, bis du 37 bekommst



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

$27675083487752* Diese Lösung ist nicht die eleganteste und auch nicht die beste.

$62535209440079* Aber du kannst gerne versuchen eine bessere Lösung zu finden!



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

$18890527031365* Führende Signale zählen

$30557055303267*
Das höchste Bit einer Bitkette heißt 
[b]Most Significant Bit[/b] oder kurz [b]MSb[/b]. 

Baue einen Schaltkreis,
der vom MSb aus alle [F] Signale zählt.

Beispiel:
[F][F][F][T][F][T][F][T]
Hier muss der Ausgang 3 sein,
weil die 3 höchsten Bits [F] sind.



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

$10248302990519* Es gibt {count} führende [F] in {input_value} ({binary_value})

$46565705342966* Es gibt 1 führendes [F] in {input_value} ({binary_value})



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

$85604588212035* Gib die Anzahl der führenden [F] aus



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

$24866509692444* Überschreiben



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

$42949183679479*
Baue einen [b]Zähler[/b], der in jedem Taktzyklus 1 hochzählt.

Zusätzlich soll es die Möglichkeit geben, den Zähler mit einem gegebenen Wert zu überschreiben.

Du bekommst 2 Eingänge: ein Bit und ein Byte.

Das Bit dient zum Umschalten zwischen [b]Zählen[/b] und [b]Überschreiben[/b] (mit dem Wert des Bytes).

$51274378991709* Das Zählen ist so fundamental, dass es sogar Insekten tun. Ausgehend vom Zählen können sich Arten entwickeln, die vergleichen und rechnen können. Und ehe man sich versieht, hat man Computer bauende Affen.

$68850421394935* Zähler



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

$27837193789838* Ausgang sollte {memory} sein.

$30050502504940* Addiere 1

$69821998974515* Überschreibe mit {num}



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

$16305942415014* Aktion

$57018164959250* Nächster erwarteter Ausgang



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

$20653200546136* Für das  erste Bit brauchen wir die Lösung aus [b]Ungerade Anzahl an Signalen[/b].

$39788606928520* Für das zweite Bit brauchen wir die Lösung aus [b]Mindestens zwei Signale[/b].



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

$79041418443903* Ausgang 0 ist identisch zum Level [b]Ungerade Anzahl an Signalen[/b.



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

$90442785399123* Ausgang 2 ist [T], wenn alle Eingänge [T] sind.



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

$12139411441713* Ausgang 1 ist [T], wenn mindestens 2, aber nicht alle 4, Eingänge [T] sind.

$83417330967064* Den 'mindestens 2' Teil, haben wir im Level [b]Mindestens zwei Signale[/b] gebaut.



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

$14499217305520* Signale zählen



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

$55345008240214* 1 Bit Decoder

$64947954189801*
In den folgenden Leveln bauen wir verschiedene [b]Decoder[/b]. Das sind Schaltkreise, die einen bestimmten Eingangswert (dem [b]Code[/b]) genau einen bestimmten Ausgang zuordnen. Sie entschlüsseln (bzw. de-coden) den Wert und schalten den passenden Ausgang [T].

Baue einen Schaltkreis, der bei Code 0 Ausgang 0 [T] schaltet, und bei Code 1 Ausgang 1.



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

$40303102766749* Ausgang 0

$56552908891774* Ausgang 1



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

$44276233109848* 2 Bit Decoder

$46223188985873* Mit 2 Bits gibt es 4 mögliche Kombinationen. Baue einen Schaltkreis, der für jede Kombination den passenden Ausgang aktiviert.



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

$44918705544255* Deaktivieren



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

$28695849165746* Mit 3 Bits gibt es 8 mögliche Kombinationen. Baue einen Schaltkreis, der für jede Kombination den passenden Ausgang aktiviert.

$43603044118584* 3 Bit Decoder



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

$10870388349665* Ausgang {cycle} sollte [T] sein und alle anderen [F]

$18073111523064* Alle Ausgänge sollten [F] sein, weil das Deaktivieren-Bit [T] ist



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

$20191487800946* Erwartetes Bit

$23128720321555* Deaktivieren



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

$24156270270079*
Erzeuge eine [b]Kreisabhängigkeit[/b].
Das ist ein Schaltkreis, wo der Eingang einer Komponente von ihrem eigenen Ausgang abhängig ist. In einer Kreisabhängigkeit ist es nicht möglich den Ausgang der Komponente zu bestimmen, weil du zuerst den Eingang auswerten müsstest, der braucht allerdings erst den Ausgang und so weiter (deswegen "Kreis").

Dieser Zustand ist in anderen Leveln nicht erlaubt, allerdings ist es das Ziel dieses Levels genau diesen Zustand zu erzeugen, damit du ihn verstehst, bevor du weitermachst.

$25862237357880* Kreisabhängigkeit

$57043666310618* Ich bin mir nicht sicher, ob es ihnen hilft, aber die Lehrkräfte lieben es.

$60783049086609* In unserem Bildungssystem bringen wir Studierende absichtlich dazu etwas Falsches zu tun und ärgern sie dann damit.



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

$28070798445412* Baue einen Schaltkreis, der das Eingangssignal ausgibt, aber um 2 Taktzyklen verzögert

$66914768639545* In diesem Level bekommst du die Verzögerungs-Komponente. Sie bekommt ein Eingangssignal, und gibt es 1 Taktzyklus später aus.

$81657957055974* Verzögerungen



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

$13944257184132* Hier haben wir jetzt ein Byte (eine Gruppe von 8 Bits), die wir auftrennen müssen.

$16215081868720* Bis jetzt haben wir nur mit Bits gearbeitet, die die Werte [T] oder [F] haben.



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

$29000872588470* Um den Gesamtwert zu verdoppeln, leiten wir jedes Bit eine Stelle nach oben.



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

$46697878992908* Zahlen verdoppeln

$78449227663032*
In diesem Level geht es um [b]Byte[/b] Werte, die als Zahlen zwischen 0 und 255 dargestellt werden. Sie bestehen aus 8 Bits, wobei jedes Bit eine binäre Ziffer der Zahl darstellt. Du bekommst 2 Komponenten: Eine davon trennt ein Byte in seine 8 Bits auf, die andere sammelt 8 Bits zu einem Byte.

Finde mit Hilfe dieser Komponenten heraus, wie man die Byte-Zahl am Eingang verdoppeln kann (bis zu 127).



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

$62612312608874* Da dieses Level eher ein Werkzeug ist, kannst du jederzeit zur Levelübersicht zurückkehren und weitermachen.

$72171231322685* Werkstatt

$88436914545275* Eigene Komponenten können über die Symbolleiste unter [b]Schaltplan wechseln[/b] hinzugefügt, umbenannt oder gelöscht werden.



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

$50970897346580* Für die Summe brauchen wir etwas ähnliches wie aus dem Level [b]Ungerade Anzahl an Signalen[/b].



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

$54848313056941* Der Übertrag ist genau dann [T], wenn beide Eingänge [T] sind.



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

$13880107359455* Aber du kannst gerne versuchen eine bessere Lösung zu finden!

$18497022543669* Diese Lösung ist nicht die eleganteste und auch nicht die beste.



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

$12555311310864* Eingang 0

$13755587162128* Eingang 2

$34717193596171* Übertrag

$41149959264274* Eingang 1

$50183740481245* Summe



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

$34381936755276*
Im letzten Level haben wir 2 Eingänge zusammenaddiert. Diesmal addieren wir 3. Auch hier addieren wir die Eingänge in binär, sodass das Ergebnis entweder [b]0[/b] oder [b]1[/b] ist.

Falls das Ergebnis nicht in eine Ziffer passt, dann setze den [b]Übertrag[/b] auf [b]1[/b]. 

$42735906141201* Volladdierer



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

$40317306745068* Erwartete Summe

$49855734765642* Erwarteter Übertrag

$51965136043073* Aktueller Übertrag

$84617036256734* Aktuelle Summe



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

$11327399415058* Dieses Level ist meine zweite Lieblingsbeschäftigung: Umrechnen von hexadezimal in binär auf Zeit.

$45399195121692* Hex Rennen

$87098190175913*
Klicke auf die Bits, sodass sie zusammen die angegebene Hexadezimalzahl ergeben.

Sobald du Stufe 3 geschafft hast, geht es weiter.



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

$44716420394020* Bescheidene Anfänge

$76679675871478*
Dieser erste Test prüft dein Verständnis von Schaltkreisen. Es gibt einen [b]Eingang[/b] und einen [b]Ausgang[/b] mit einem Kabel dazwischen. Damit ein Signal zwischen Eingang und Ausgang fließt, musst du es links oben einschalten.

[tip]In den Optionen kannst du die Geschwindigkeit der Kabelanimation einstellen oder den Farbenblind Modus aktivieren[/tip]



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

$35186537961257* Bevor es weitergeht musst du zeigen, dass du Boolesche Algebra verstanden hast. Wenn du darin gut bist, wird dir das sehr viel helfen.

$39180730338379* Du sollst ein paar zufällig ausgewählte Schaltkreise bauen. Sobald du auf [b]Ausführen[/b]  klickst, wird dein Schaltkreis getestet. Wenn der Schaltkreis richtig ist, bekommst ein [T] Symbol als [b]Ergebnis[/b], ansonsten [F]. Wenn 4 von 5 Ergebnissen [T] sind, ist die Prüfung bestanden!

$39721874026332* Sehr gut! Mit diesem Wissen über Boolesche Algebra können wir uns an den Bau deines ersten Computers wagen. Aber zuerst musst du dich mit binärer Arithmetik und dem Speichern von Werten beschäftigen.

$57679157572023* Abschlussprüfung in Boolescher Algebra



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

$32183772878666* Ergebnis



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

$10423837492124* [left][b]Nach links drehen[/b][/left]

$18756407685566* [left][b]Nach rechts drehen, solange eine Wand vor mir ist[/b][/left]

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

$60076150664554* Wenn du immer der linken (oder rechten) Wand folgst, kommst du irgendwann zum Ausgang.

$63325960964451* [left][b]Schritt vorwärts[/b][/left]

$66501964970865* Der Pseudo-Code für so einen Algorithmus sieht so aus:



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

$19088384441761*
Am Eingang bekommst du die Zahl, was der Roboter sieht.

Es ist immer eine von denen:
0  [F][F]  Nichts
1  [F][T]  Wand  

Sobald der Roboter die Tür erreicht, hast du es geschafft. Natürlich gibt es mehr als 1 Labyrinth, sonst könntest du einfach den Weg fest einprogrammieren.

$56722492138232*
Richtig gut! Du hast das Labyrinth durchquert und die [color=#e49f44]OVERTURE[/color] Architektur gemeistert! Allerdings ist die Overture auch recht simpel. Gut zum Lernen, aber ihr fehlen viele Features.

Unser nächstes Projekt wird die [color=#e49f44]SYMPHONY[/color] Architektur. Eine viel mächtigere Architektur mit RAM, Bildschirm, Tastatur und du kannst Programm-Code wiederverwenden durch Funktionen! Auf dem Weg dort hin bauen wir mehr Komponenten und lernen neue Konzepte, wie Stapelverarbeitung und andere coole Dinge.

$84960209408475*
In diesem Level steuerst du einen Roboter durch ein Labyrinth. Schreibe ein Programm, mit dem er bis zur Tür laufen kann.

Das sind die 3 Kommandos, die du ausgeben kannst:
1  [F][T]  Nach links drehen 
2  [T][F]  Vorwärts gehen    
3  [T][T]  Nach rechts drehen

Du kannst auch mit den Pfeiltasten umherlaufen, aber am Ende muss er es allein mit deinem Programm schaffen.

$90660848232877* Labyrinth



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

$46388374967041*
Den Wochentag bekommst du durch [b]modulo 4[/b] des Datums.
Modulo 4 ist der Rest, der übrige bleibt, wenn du die Zahl durch 4 teilst. Beispiel 18 mod 4 ergibt 2, weil 18÷4=4 mit Rest 2. Und der Rest ist das Ergebnis.

Aber: Du hast nur 8 Taktzyklen dafür Zeit!

[tip]Du musst deine Hardware nicht ändern, sondern den Trick finden, wie du schnell mod 4 rechnen kannst[/tip]

$76392666043520* Aber egal, es ist bald Neujahr und wir wollen die Wochentage aller anstehender Geburtstage ausrechnen. Wir geben dir das Datum und du rechnest einfach innerhalb von 8 Taktzyklen den Wochentag aus.

$78836302049950* Modulo 4



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

$13853243145042* Das war zu langsam. Du hast nur 8 Taktzyklen Zeit.

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



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

$44500958231665* Multipliziere zwei Zahlen miteinander. Wenn das Ergebnis nicht in 8 Bits passt, brauchst du die überflüssigen Bits nicht beachten

$54529139494347* Multiplizieren



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

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

$46804407616321* Das untere Byte von {a} * {b} ist {result}

$83214947196979* Multipliziere die zwei Zahlen



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

$77112891598455* Multipliziere die zwei Zahlen



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

$39082333495604* NAND Gatter

$50880631203389* Korrekt! Du hast das [b]NAND Gatter[/b] freigeschaltet. Aus diesem fundamentalen Baustein wirst du alles andere aufbauen.

$65167079914703* Am Anfang geht es um Boolesche Logik. Boolesche Logik beschreibt die einfachste Form von Berechnungen, die ein Computer ausführen kann. Tatsächlich sind diese Berechnungen die Grundbestandteile, aus denen alle anderen Rechenoperationen im Computer aufgebaut sind.

$68865507501612* Dieser Schaltkreis enthält ein [b]NAND Gatter[/b]. Finde heraus wie es funktioniert, indem du verschiedene Kombinationen am Eingang ausprobierst, und das Ergebnis unten in der [b]Wahrheitstabelle[/b] einträgst. In der Tabelle gibt es für jede Eingangs-Kombination eine Spalte und deine Aufgabe ist es, das Ergebnis für jede Spalte herauszufinden.



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

$20753698232132* Negative Zahlen

$87951492143019* Um Dinge unterscheiden zu können, brauchen wir die Subtraktion. Um subtrahieren zu können, brauchen wir aber zuerst negative Zahlen.



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

$19817843844200* Nim

$47072576894526* Übrigens kannst du jetzt deine alten Schaltpläne über das [b]Schaltplan wechseln[/b] Menü in der Symbolleiste auswählen. Du kannst das Level also entweder mit Symphony, oder mit Overture lösen.

$53912339443439*
Lust auf ein Kartenspiel? Ich auch nicht, aber trotzdem sollst du in diesem Level die AI in einem einfachen Spiel schlagen (das Spiel heißt [b]Nim[/b]).

Es gibt 12 Karten und ihr nehmt abwechselnd entweder 1,2 oder 3 Karten davon weg. Wer die letzte Spielkarte nimmt, verliert. Du musst die AI also dazu bringen die letzte Karte zu nehmen. Du darfst anfangen.

Wenn du den Eingang liest, bekommst du die Anzahl der Karten, die auf dem Tisch liegen. Danach kannst du 1,2 oder 3 zum Ausgang senden, je nachdem wie viele Karten du nehmen möchtest. Die AI reagiert sofort, du kannst danach also sofort wieder den Eingang lesen, um zu sehen, wie viele Karten die AI weggenommen hat.



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

$27262056315410* Verloren :(

$29769682738867* Du darfst nur 1, 2 oder 3 Karten nehmen

$42147812867053* Gewonnen! :>

$49299754864790* Enter drücken, um {card_count} Karten zu nehmen

$64085588225039* Enter drücken, um zu sehen, was die AI macht

$85502688597126* Pfeiltasten ← → verwenden, um Karten zu nehmen

$90440029783715* Du hast die letzte Karte genommen :(



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

$79378464416004* Du kannst die Pfeiltasten ← → verwenden, um Karten zu nehmen



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

$18962231551900* wenn Eingang 0 und Eingang 1 NICHT [T] sind.

$68908249643417* Der Ausgang ist genau dann [T],



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

$14349743750598* Fehlt nur noch das AND. Durch ein NOT wird ein NAND wieder zum AND.



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

$37240300421781*
Die meisten Kreaturen auf der Erde sind aggressiv und können sich nicht konzentrieren.

Um zu bestehen, musst du lernen logisch zu denken, ohne dabei Schaden anzurichten.

$56653221050913*
Baue aus NAND und NOT Gattern einen Schaltkreis,
der zur Wahrheitstabelle passt.

Das entstehende [b]NOR Gatter[/b] ist [T],
wenn [b]weder[/b] Eingang 1 [b]noch[/b] Eingang 2 [T] ist.

[tip]Mit Leertaste kannst du Komponenten drehen[/tip]

$72918877035793* NOR Gatter



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

$26513163439009* Die einzige Komponente, die wir haben, ist das NAND Gatter.



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

$16394937100308* NOT Gatter

$56423993638708* Im letzten Level gab es einen Schaltkreis und du hast die Wahrheitstabelle ausgefüllt. In diesem Level machen wir es umgekehrt: Die Tabelle ist vorgegeben und du baust den passenden Schaltkreis.

$80163590000700*
Du hast jetzt ein [b]NAND Gatter[/b].
Zeit einen eigenen Schaltkreis zu bauen!



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

$17243045715726* Wir brauchen nur 1 Komponente, um herauszufinden, ob zwei Eingänge eine ungerade Anzahl an [T] haben.



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

$39747324204871* als gerade/ungerade.

$80670337048058* Wir betrachten [T] und [F]



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

$28104365880572* gerade Zahl +   gerade Zahl =   gerade Zahl

$49444546097133* ungerade Zahl + ungerade Zahl =   gerade Zahl

$57603105454008* Wir brauchen eine Komponete, die dieses Verhalten nachahmt.

$59534613718377* ungerade Zahl +   gerade Zahl = ungerade Zahl



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

$47175212977659* Das XOR Gatter können wir uns dafür genauer anschauen.



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

$44190469254011* Ungerade Anzahl an Signalen

$63242509760527*
Baue einen Schaltkreis, der [T] ausgibt, wenn die Anzahl an [T] Eingangssignalen ungerade ist.

Du darfst dafür aber nur 3 Komponenten verwenden.



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

$36609687959808* {count} von 3

$40553112323959* Du darfst in diesem Level nur 3 Komponenten verwenden



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

$74552564780850* Komponenten verwendet



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

$17699211754487* Im letzten Level hast du gelernt, dass wir keine Kreisabhängigkeiten erlauben. Jetzt lernst du die einzige Ausnahme, bei der wir sie [b]doch[/b] erlauben.

$54648226811178* Ungerade Taktzyklen

$60625429879527*
Orange Pins sind erst im nächsten Taktzyklus aktiv. Dadurch kann das aktuelle Ausgangssignal ohne Endlosschleife berechnet werden und führt dadurch nie zu einer Kreisabhängigkeit.

[image="delay_line.png"]

$75292456030647*
Die Verzögerungs-Komponente darf von ihrem eigenen Ausgang abhängig sein. Das ist erlaubt, weil sich der Eingangswert erst im nächsten Taktzyklus auswirkt.

[image="delay_line.png"]

$85913836277587* In geraden Taktzyklen soll [F] ausgegeben werden, in ungeraden [T]



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

$12296593054599* One-Hot Kodierung

$17817215316423*
Die One-Hot Kodierung: Einer der Ausgänge ist [T] ("hot"), alle anderen [F]. Der Eingang entscheidet welcher der Ausgänge [T] ist.

Beispiel: Bei Eingangswert 7, muss Ausgang 7 [T] sein, alle anderen [F].

Aber: Du darfst dafür nur [b]3 Komponenten[/b] benutzen und [b]keinen[/b] deiner gebauten Decoder.



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

$60812617177494* Du darfst nur 3 Komponenten benutzen.

$74562193652628* Ausgang {pin} ist falsch.



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

$46797361496226*
Baue aus NAND und NOT Gattern einen Schaltkreis,
der zur Wahrheitstabelle passt.

Das entstehende [b]OR Gatter[/b] ist [T],
wenn Eingang 1 [b]oder[/b] Eingang 2 [T] ist.

[tip]Wenn du eine Komponente doppelklickst, kannst du sie zusammen mit den angeschlossenen Kabeln verschieben[/tip]
  

$81822607191994* OR Gatter



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

$67313804184537* Ein großes OR Gatter ist nichts anderes als mehrere ORs hintereinander.



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

$29275887429601* Baue ein [b]OR Gatter[/b] mit 3 Eingängen.

$68089739910654* Großes OR Gatter



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

$15378963142694* Eingang 2



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

$13757092116124*
[color=#c54d5e]Quelle[/color] und [color=#e49f44]Ziel[/color] kann jeweils 1 von 6 Registern sein, die wir REG 0 bis REG 5 nennen. 

Zusätzlich gibt es in diesem Level eine Eingangs-Komponente, die ebenfalls eine [color=#c54d5e]Quelle[/color] sein kann, und eine Ausgangs-Komponente, die ebenfalls ein [color=#e49f44]Ziel[/color] sein kann.

$36376879506769* Jetzt ist es endlich an der Zeit, dass du deinen eigenen ersten Computer baust. Ich zeige dir, wie du die [color=#e49f44]Overture[/color] Architektur baust. Eine echte Turing vollständige Maschine in jeder Hinsicht.

$79626649565563* Register



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

$18540192543555* Register {reg_i} sollte Wert {value} haben.

$51132330915663* Ausgang ist nicht aktiviert.

$75546240775660* Erwarteter Ausgang: {value}.

$85392755740261* Ausgang sollte nicht aktiv sein.



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

$77115196290575* Baue einen Schaltkreis, der einen Wert von einer Quelle zu einem Ziel bewegen kann



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

$57911760722636* (move) Bewegt einen Wert von %b nach %a.



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

$76398546711745* ALU



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

$27417572090527* Ausgang ist nicht aktiviert.

$45837083894306* Erwarteter Ausgang: {value}.

$67011612338355* Register {reg_i} sollte den Wert {value} haben.

$84026509534190* Ausgang sollte nicht aktiv sein.



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

$49706182840588* Baue die ALU in deine Architektur ein



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

$50864238070873* (move) Bewegt einen Wert von %b nach %a.



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

$23614311904581* Direkte Werte

$63109056149876*
Wir brauchen eine Möglichkeit Zahlen direkt aus dem Befehl in ein Register zu bewegen. Dazu benutzen wir den [b]Direkt[/b] Modus (wenn Bit 7 und 8 [F][F] sind).

Die restlichen 6 Bits des Befehls betrachten wir als Zahl, die direkt in [color=#DD6576]REG 0[/color] bewegt werden soll. Weil die Zahl 6 Bit hat (Bit 7 und 8 sind für den Modus), können wir nur Werte zwischen 0 und 63 direkt abspeichern.



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

$17793323757435* Erwarteter Ausgang: {value}.

$63497936956369* Ausgang sollte nicht aktiv sein.

$73489311755739* Register {reg_i} sollte den Wert {value} haben.

$82564442776805* Ausgang ist nicht aktiviert.



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

$57764930098721* Werte aus dem Befehl sollen direkt in REG 0 bewegt werden können



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

$26930827349244* (move) Bewegt einen Wert von %b nach %a.



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

$10102035559374* Programm

$58149108600515*
Ich habe den Befehls-Eingang entfernt. Brauchen wir nicht mehr. Stattdessen gibt es jetzt die [b]RAM[/b] Komponente, in der eine Reihe von Befehlen abgespeichert sind (ein [b]Programm[/b]). Oben auf der RAM Komponente sitzt ein [b]Lade-Port[/b] über den du den RAM ansteuern kannst.

Wenn der [b]Aktivieren[/b] Pin des Lade-Ports [T] ist, wird eine Zahl am [b]Adresse[/b] Pin eingelesen. Die Zahl ist wie eine Adresse (oder Hausnummer), mit der der RAM einen Befehl sucht. Der abgespeicherte Befehl unter der angegebenen Adresse wird am Ausgang ausgegeben.

Du sollst das abgespeicherte Programm des RAMs Schritt für Schritt durchgehen. Das bedeutet in jedem Taktzyklus wollen wir die Adresse um 1 erhöhen und den nächsten Befehl des Programms ausgeben. Dafür kannst du den [b]Zähler[/b] benutzen.



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

$19443898128380* Ausgang sollte nicht aktiv sein.

$49097812105667* Register {reg_i} sollte Wert {value} haben.

$50052313044113* Ausgang nicht aktiviert.

$73023200204536* Zähler sollte Wert {expected_value} haben.

$88140381331491* Erwarteter Ausgang: {value}.



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

$62678678871254* Baue die Programm-Komponente in deine Architektur ein



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

$37075142107851* Reg 2

$38743609381557* Reg 1

$40362507068221* Reg 4

$57061942907076* Reg 5

$79357977314471* Reg 3

$82470056393191* Reg 0



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

$27747401844990*
Du hast es geschafft!
Ich dachte du bist nur ein seltsam aussehender haarloser Primat, aber du hast tatsächlich einen echten funktionierenden Computer gebaut!
Das crazy.

$59169726539090* Turing vollständig

$77166984247940* Bis jetzt können wir unsere Programme nur Schritt für Schritt und schön der Reihe nach ausführen. (langweilig)

$85320707451673*
Bis jetzt haben wir nur eine Richtung: Das Programm beeinflusst den Speicher. Aber was ist, wenn der Speicher auch das Programm beeinflussen kann? Wenn wir unter bestimmten [b]Bedingungen[/b] im Programm umherspringen können, können wir mit unserem Computer ALLES berechen, was je berechenbar ist (vorausgesetzt wir hätten unendlich viel Speicherplatz).

Die Eigenschaft theoretisch alles Berechenbare berechnen zu können, heißt

[color=#e49f44]TURING VOLLSTÄNDIG[/color]
(nach dem Erfinder Alan Turing)



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

$17521915837347* Ausgang sollte nicht aktiv sein.

$33411257451562* Erwarteter Ausgang: {value}.

$36308361121667* Ausgang nicht aktiviert.



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

$65145204616501* Der Programm-Zähler soll unter bestimmten Bedingungen überschrieben werden können



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

$18505654344513* (jump) Sprung zu r0.

$21095867785396* AND r1 and r2 und speichere das Ergebnis in r3.

$24147817394058* (jump less) Sprung zu r0, falls r3 kleiner als 0 ist.

$26704206992933* NAND r1 und r2, speichere Ergebnis in r3.

$33850592701591* SUB r1 und r2, speichere Ergebnis in r3.

$43876958520450* (jump non zero) Sprung zu r0, falls r3 nicht 0 ist.

$46599288949396* (jump zero) Sprung zu r0, falls r3 0 ist.

$48758564562305* (jump less equal) Sprung zu r0, falls r3 kleiner gleich 0 ist.

$58823897430160* OR r1 und r2, speichere Ergebnis in r3.

$64808551937719* (jump greater equal) Sprung zu r0, falls r3 größer gleich 0 ist.

$75067212691206* NOR r1 und r2, speichere Ergebnis in r3.

$75524550463342* ADD r1 und r2, speichere Ergebnis in r3.

$88048573834702* (jump greater) Sprung zu r0, falls r3 größer als 0 ist.



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

$15531830527231* r3

$17025449350330* r5

$42538649427331* Programm

$47858891143005* r2

$59383212597903* r0

$76878335565401* r4

$78214997465973* Zähler

$89909032864119* r1



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

$24524168624111* Zähler sollte Wert {expected_value} haben.

$35224907301551* Register {reg_i} sollte Wert {value} haben.



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

$22306447815263* Optimiere Overture



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

$16562043259074* Arithmetisch Logische Einheit[nbsp]1

$31234606133949*
Wir brauchen eine Komponente, die die logischen Grundoperationen beherrt. Später soll sie auch rechnen können, aber eins nach dem anderen.

Du bekommst eine [b]Operation[/b] und die Werte [b]A[/b] und [b]B[/b].

Baue einen Schaltkreis, der OR, NAND, NOR oder AND auf den zwei Werten ausführt. Die Operation sagt dir, was genau berechnet werden soll.

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



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

$20519420764551* Arithmetisch Logische Einheit[nbsp]2

$39134024311972*
Füge Addition und Subtraktion hinzu.
Damit wird die Komponente zu einer echten Arithmetisch-Logischen Einheit (kurz: [b]ALU[/b]).

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

[tip]Es gibt hier alle Komponenten auch in der Byte-Variante[/tip]



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

$53936374688885* Operation



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

$83283206082997* Bedingungen



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

$74974087807935* Immer

$80507287196650* Niemals



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

$11886599003881* Wert

$38979555213581* Beschreibung

$43384041502940* Wert

$81487261104241* Bedingung



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

$15645900189277* Bewegen

$60698949860454* Rechnen

$90597971391617* Direkt



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

$44644153822563*
Der Schaltkreis, den du im "Register"-Level gebaut hast, kann Werte zwischen Registern bewegen, während die "ALU" verschiedene Operationen auf 2 Werte anwenden kann. Wir brauchen aber beides im selben Schaltkreis.

In unserem bisherigen Befehl gibt es noch 2 Bits ohne Bedeutung, die wir jetzt verwenden, um den MODUS festzulegen (also ob der Computer [b]Rechnen[/b] oder Werte [b]Bewegen[/b] soll).

Wir bauen einen "Decoder", der die 2 höchsten Bits des Befehls prüft, und für den passenden Modus einen Ausgang [T] schaltet. Es gibt noch 2 weitere Modi [b]Direkt[/b] und [b]Bedingung[/b], die wir zwar mit einbauen, aber erst später benutzen.

$81732613304305* Befehlsdecoder



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

$23393810721136* Rechnen

$41856942338650* Bedingung

$67613074322431* Bewegen

$71705253055197* Direkt



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

$35299017249605* Modus

$55162862394836* Befehl



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

$46932595269557* Online Vorschau



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

$78694087261378* Online Ansicht



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

$10655955073336* Laden

$46688176903674* Adresse



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

$14374127314134* RAM

$68663841862704*
In diesem Level sollst du einen Schaltkreis bauen, der 4 verschiedene Byte-Werte [b]Speichern[/b] und [b]Laden[/b] kann.

Das [b]Laden[/b] und [b]Speichern[/b] wird jeweils über ein Bit gesteuert. Außerdem bekommst du 2 [b]Adress[/b]-Bits. Diese zwei Bits können auf 4 Arten kombiniert werden und ergeben zusammen die Zahl, welches der 4 Byte-Register zum Laden/Speichern aktiv ist.

  [b]Adresse[/b]   : Entscheidet welches Register aktiv ist
    [b]Laden[/b] [T]: Wert des Registers ausgegeben         
[b]Speichern[/b] [T]: [b]Neuer Wert[/b] im Register speichern      

[tip]Mit Leertaste kannst du Komponenten drehen[/tip]

$76851096880864* Schaffst du es, 4 Bytes in diesem begrenztem Raum abzuspeichern? Wir müssen platzsparend arbeiten, denn am Ende des Levels wird deine Lösung hochskaliert.



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

$29258463778822* Ausgang ist Z, aber sollte {expected_value} sein.

$45179662026844* Ausgang sollte Z sein.

$48251194975794* Ausgang ist {actual_value}, sollte aber {expected_value} sein.

$52597500133853* Speichere {text_value} in {text_add}

$55086379351729* Lade {text_state} von {text_add}



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

$22107475451139* [left]Speichere ??? in ??[/left]

$27304327624610* [color=#E49F44][b]Wert[/b][/color]

$27457656265551* [color=#E49F44][b]Speichere [/b][/color]

$57378010777762* [left]Lade ??? von ??[/left]

$62207646058430* [color=#E49F44][b]Lade [/b][/color]

$62589960113273* [color=#E49F44][b]Adresse[/b][/color]

$71008031461945* [color=#E49F44][b]   Wert    [/b][/color]

$85306375920893* [color=#E49F44][b]  Adresse  [/b][/color]



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

$18488351703350*
Weißt du wie wir deterministisschen Roboter in der Lage sind kreativ zu sein und originale Ideen zu erzeugen?
Ein Wort: Zufallszahlengeneratoren.

$83969937380086* Zufallszahlen Generator



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

$77825640575531* Der nächste Seed sollte {result} sein, nicht {output}



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

$58382627590046* Sandkasten



=== campaign/saving_bytes/meta.txt ===

$41663630841312* Byte Register

$87293777622656*
Baue einen Schaltkreis, der ein Byte für mehrere Taktzyklen speichern kann.

Wenn [b]Speichern[/b] [T] ist, soll der Wert des Byte-Eingangs gespeichert werden. Am Ausgang soll immer der aktuell gespeicherte Wert ausgegeben werden.



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

$60269032570207* Erwarteter Ausgangswert {expected_output}.



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

$14624167685294* In diesem Level musst du eine Verzögerung verwenden.

$52905927349424* Die Eingänge der Tabelle sind die 2 Level-Eingänge und der aktuelle Ausgang der Verzögerung.

$61760299843073* Das Signal was in die Verzögerung reingeht ist der Ausgang der Wahrheitstabelle.

$83682732712729* Mach dir eine Wahrheitstabelle für die Signale, die in die Verzögerung rein gehen.

$90057665917240* Sobald du die die Wahrheitstabelle hast, ist die Lösung leichter zu finden.

$90652401745526* Insgesamt hat die Tabelle also 3 Eingänge mit 8 Kombinationen.



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

$16548183735739* Das kann sie aber nur für 1 Taktzyklus, deswegen leiten wir den Wert direkt wieder zurück, um ihn zu behalten.

$64973475823722* Die einzige Komponente, die etwas 'speichern' kann ist die Verzögerung.



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

$11101940160071* Wenn der 'Speichern' Pin [T] ist, wollen wir den Verzögerungswert überschreiben,

$19959785727663* aber das führt direkt zu einem Kurzschluss.



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

$10919459809145* Also platzieren wir einen Multiplexer, um zu entscheiden, welcher Wert an der Verzögerung ankommt



=== campaign/saving_gracefully/label.txt ===

$88860903896097* Speichern



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

$13114757255411*
In diesem Level hast du 2 Eingänge.

Wenn [b]Speichern[/b] [T] ist, dann soll der gespeicherte Wert durch [b]Neuer Wert[/b] überschrieben werden.

Am Ausgang soll immer der gespeicherte Wert ausgegeben werden.

Der gespeicherte Wert ist der Wert, der von der Verzögerungs-Komponente gerade ausgegeben wird, und (ohne weitere Verkabelung) mit dem nächsten Taktzyklus verschwinden würde.

$39874917169400* Bit Register

$61501859914469*
Die Verzögerungs-Komponente kann einen Wert nur für 1 Taktzyklus speichern. Manchmal ist es aber sinnvoll einen Wert für eine längere Zeit zu speichern.

Du sollst eine Komponente bauen, die das kann.



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

$10654649810679* Speichern

$63465863198591* Wert



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

$50044461577278* Das letzte AND Ergebnis wird nicht benutzt, also können wir es löschen



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

$34375498293137* Es wird Zeit, dass du dir auch ein paar Gedanken über Effizienz machst. Ab sofort kannst du sehen, wie gut deine Schaltkreise sind in Bezug auf Zeit und Energie.

$38383835706006*
In diesem Level sollst du einen Schaltkreis bauen, der den Eingangswert um 1 hochzählt. Falls das Ergebnis nicht in 8 Bits passt, ist uns das egal.

Aber jetzt kommt's:
Die Gatteranzahl darf höchstens 40 sein.
Die Laufzeit darf höchstens 10 sein.

Über die Sanduhr siehst du den kritischen Pfad.

[tip]Vielleicht musst du zuerst frühere Level verbessern[/tip]

$40775045205647*
Die Energiekosten (Gatteranzahl, Laufzeit) der größeren Komponenten ergibt sich aus den Energiekosten des Levels, wo du die Komponente gebaut hast.

Wenn du also die Kosten einer großen Komponente verbessern willst, lohnt es sich die Lösungen in früheren Leveln zu verbessern, wo du die Einzelteile der großen Komponente gebaut hast. [b]Aber wichtig:[/b] Wenn du etwas Grundlegendes verbessert hast, muss du die Level nochmal ausführen, in denen das verbesserte Bauteil verwendet wird, damit auch dort die Energiekosten aktualisiert werden.

Übrigens: Die Aufgabe wird gleich etwas mit Energie zu tun haben. Um das zu schaffen, sollte dein XOR Gatter eine Gatteranzahl von 3 haben mit einer Laufzeit von 2.

$59781832788691*
Jedes der Basisgatter (NAND, NOR, AND, OR) hat eine [b]Laufzeit[/b] von 1. Das bedeutet sie brauchen 1 Zeiteinheit, um berechnet zu werden.

Wie auch bei der zweiten Gleichung
(A + B) + (C + D)
können Teile von großen Schaltkreisen gleichzeitig parallel ausgeführt werden, wenn sie nicht aufeinander warten müssen. Deshalb ergibt sich die Gesamtlaufzeit aus dem [b]Kritischen Pfad[/b] der Gatter, die am längsten brauchen.

Klicke auf das [b]Sanduhr[/b] Symbol  oben rechts, um den [b]Kritischen Pfad[/b] im Schaltkreis zu sehen.
(Also gleich. Erst einmal müssen wir etwas bauen)

$70169388789757*
Diese beiden Gleichungen liefern zwar das selbe Ergebnis, aber sie sind trotzdem nicht identisch:

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

Die Reihenfolge der Rechenschritte ist unterschiedlich. Würden wir diese Gleichung als Schaltkreis aufbauen, macht das einen Unterschied, denn wir könnten die zwei Klammern der zweiten Gleichung gleichzeitig nebeneinander berechnen und wären dadurch schneller.

$72877144436007*
Jedes Basisgatter hat also eine Laufzeit von 1. Jede Laufzeit, egal wo im Schaltkreis, verbraucht 1 [b]Energie[/b]. Das heißt die Anzahl an Basisgattern ist genauso wichtig für den Energieverbrauch, wie die Länge des Kritischen Pfades.

Der gesamte Energieverbrauch des Schaltkreises ergibt sich aus der [b]Laufzeit des Kritischen Pfades[/b] multipliziert mit der [b]Anzahl an Basisgattern[/b] im gesamten Schaltkreis.

Oben rechts siehtst du die Anzahl der [b]Gatter[/b]  und die [b]Laufzeit[/b] . Mit Laufzeit ist die Länge des Kritischen Pfades gemeint.

$78375324732864*
Nutzbare Energie nennt man auch [b]Exergie[/b]. Davon gibt es nicht unbegenzt viel, und wenn wir alles aufbrauchen, führt das zum Wärmetod des Universums. Deswegen müssen wir effizent sein.

In unserer Gesellschaft gilt Ineffizienz als hässlich und Effizienz als schön. Genau genommen messen wir Schönheit in Energie-Einheiten.

$85893273691863* Objektive Schönheit



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

$15039285047182* Ausgang sollte Wert {expected} haben.

$46433606967015* Addiere 1 zu {cycle}



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

$85765173996083* Zähle den Eingang 1 hoch



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

$81345258398584* Der Ausgang [T] ist genau dann [T],

$87387306821265* wenn Eingang 0 [T] UND Eingang 1 NICHT [T] ist.



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

$11961528105462*
Die einzelnen Testschritte heißen [b]Taktzyklen[/b]. Jeder Taktzyklus geht eine Spalte der Wahrheitstabelle durch und prüft, ob dein ausgegebenes Ergebnis richtig ist. 

Baue einen Schaltkreis, der nur im zweiten Taktzyklus [T] ausgibt.

$69913560783046* Zweiter Taktzyklus



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

$59964726775903* dreht man alle Bits (Byte NOT) und addiert dann 1

$77523753173621* Um eine Binärzahl negativ zu machen



=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* Aber du kannst gerne versuchen eine bessere Lösung zu finden!

$55687805352825* Diese Lösung ist nicht die eleganteste und auch nicht die beste.



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

$15862778001173*
Die Zahlendarstellung mit Vorzeichen, bei der das 8. Bit den Wert -128 hat, heißt [b][color=#dd6576]signed[/color][/b],
die ohne Vorzeichen heißt [b][color=#dd6576]unsigned[/color][/b].

In diesem Level bekommst eine Zahl mit Vorzeichen (signed) am Eingang. Baue einen Schaltkreis, der den Wert der Zahl negiert bzw. das Vorzeichen des Werts umdreht.

Beispiel:
 4 negiert ergibt -4.
-9 negiert ergibt  9.

$54237470041206* Vorzeichen Negation



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

$10529708471093* Eingang



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

$23043475637417* In diesem Level sollst du 16 Zahlen sortieren. Lese den Eingang 16 mal aus, sortiere die Zahlen und gebe sie von klein nach groß wieder aus.

$53593011909329* Köstliche Bestellung

$79528307974753* Wir erweitern gerade unsere galaktische Lebensmittel-Enzyklopädie um menschliches Essen. Da wir kein Alphabet haben, sind die Einträge in der Enzyklopädie nach Köstlichkeit sortiert.



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

$25018662661467* Index {index} in der sortieren Liste sollte {expected} sein, nicht {output}.



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

$17745932940157* Du hättest Adresse {expected_value} vom Arbeitsspeicher lesen sollen, nicht {actual_counter}. Im letzten Taktzyklus wurde der Zähler anscheinend falsch gesetzt.

$21000091589999* Ausgang sollte {expected_output} sein, nicht {output_value}.

$22469925230320* Dauerspeicher Adresse {i} sollte den Wert {expected_value} haben, nicht {value}.

$29078414770160* Das 'zr' Register sollte immer 0 sein (Adresse 0 in der 'Registerbank').

$60841927788704* Die Zeit Komponente sollte nicht aktiviert worden sein seit der letzten Ausführung von time_0.

$70740757119887* {register} ('Registerbank' Adresse {address}) sollte Hex Wert {expected_value} haben, nicht {actual_value}.

$74663212299349* Arbeitsspeicher Adresse {i} sollte den Wert {expected_value} haben, nicht {value}.

$85916420035294* Ausgang muss aktiv sein.



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

$29798404581087* Stack



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

$35910734851012* {expected_value} sollte oben auf dem Stack liegen, nicht {actual_value}.

$77129086767196* Wenn du pop machst, musst du den Wert auch ausgeben.



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

$35820332981557* Schreibe ein Programm, was einen Stack imitiert



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

$28617596738571*
Manchmal ist es hilfreich einzelne Programmblöcke wiederverwenden zu können. Diese wiederverwendbaren Programmblöcke heißen [b]Funktionen[/b]. Um eine Funktion zu benutzen, springen wir an den Anfang des Programmblocks und springen am Ende wieder zurück, wo wir hergekommen sind. Das Aufrufen einer Funktion heißt [b]call[/b] (wörtlich: "rufen"). Das Zurückspringen heißt [b]return[/b] (wörtlich: "zurückkehren").

Damit das Ganze funktioniert, muss man sich aber merken, wo man hergekommen ist, damit das [b]return[/b] auch weiß, an welche Code-Stelle es zurückspringen soll. Idee: Wir speichern die Rückkehr-Adresse einfach in einem Register und lesen das beim Zurückspringen aus. Problem: Was ist, wenn die Funktion selbst auch eine Funktion aufruft? Dann würde die aufgerufene Funktion unser Rückkehr-Register überschreiben, was wir aber noch brauchen. Das schlecht.

Lass uns kurz an einem Beispiel schauen, in welcher Reihenfolge die Rückkehr-Adressen abgefragt werden müssen: Sagen wir Funktion [b]A[/b] ruft Funktion [b]B[/b], die wiederum [b]C[/b] ruft. Wenn wir aus [b]C[/b] zurückkehren möchten, müssen wir nur die Adresse von [b]B[/b] kennen, denn da ist [b]C[/b] hergekommen. Und in [b]B[/b] müssen wir nur die Adresse von [b]A[/b] kennen. Generell ist die lezte Adresse, die wir hinzugefügt haben, immer die erste, die wir wieder für einen Rücksprung brauchen, egal welche Funktion wir betrachten und egal wie verschachtelt sie sind. Dies entspricht exakt dem Verhalten des Stacks!

$41513122622358* Funktionen

$42088257134737* Dieses Level ist nur dafür da, damit du dir im Detail anschauen kannst, wie Funktionen arbeiten und wie sie programmiert werden. Es gibt keine weitere Aufgabe. Funktionen werden später wichtig, also nimm dir die Zeit und analysiere das Programm, bis du sicher bist, dass du es verstanden hast.

$56028205797304*
Jetzt müssen wir uns noch um die Register-Werte kümmern. Sagen wir, wir haben einen Wert in [b]r1[/b] gespeichert und rufen eine Funktion. Diese weiß von unserem Wert aber nichts und benutzt [b]r1[/b] um irgendetwas zu berechnen. Dann ist nach dem return unser Wert überschrieben.

Das heißt: bevor eine Funktion aufgerufen wird, müssen wir alle wichtigen Werte im Stack abspeichern und uns nach dem return wiederholen.

Im Grunde ist es egal, ob das vor dem eigentlichen Funktionsaufruf passiert, oder innerhalb der Funktion. Wichtig ist nur, dass man sich auf eine Art festlegt, sodass verschiedene Funktionen kompatibel sind. Diese Festlegung nennt man auch [b]Aufrufkonvention[/b].

$64240772623662*
Ab sofort kannst du die [b]call[/b] und [b]ret[/b] Befehle benutzen. Beide führen mehrere Befehle nacheinander aus.

Funktionsaufruf: [b]call[/b]
Bevor der Sprung passiert, wird die Adresse des nächsten Befehls auf den Stack geschrieben (die aktuelle Adresse aus dem Zähler + Befehlsbreite), um später dort weitermachen zu können. Anschließend kommt der Sprung zum Beginn der Funktion.

Zurückspringen: [b]ret[/b]
Die vom [b]call[/b] abgelegte Adresse wird vom Stack genommen. Dort wird dann normal weitergemacht.



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

$10902022971046* Mit Ausnahme von r1 und r2, sollten beim Zurückkehren einer Funktion, alle Register ihre originalen Werte haben

$11016773181609* Der letzte Aufruf von multiplizieren hat das Ergebnis schon in r1 geschrieben

$14412657671278* r3 und r4 pushen, sodass wir r3 und r4 innerhalb der Funktion verwenden können, aber ihre Werte später wiederherstellen können

$18457350783754* Erster Eingangswert ist 2

$21553876748933* Akkumulator

$21707356398727* Lade 2 Zahlen, die das Level vorgibt

$27088227324511* Verbleibende rechte Seite der Multiplikation

$27592840036827* Zweiter Eingangswert ist 5

$30769341721428* Linke Seite der Multiplikation

$32724600358227* Äußeren Wert wiederherstellen

$33479507858734* Berechne 2 hoch 5

$42717933764735* r1 und r2 wird für Argumente benutzt, r1 ist das Ergebnis der Funktion

$42740851915963* Verbleibender Exponent

$43461252553161* Aufrufkonvention:

$59000482794872* Sollte 32 ausgeben

$63878589013500* Weiter multiplizieren, bis "Verbleibender Exponent" 0 ist

$65068280556611* Äußere Werte wiederherstellen

$68500361393623* Register benennen, um Lesbarkeit zu erhöhen

$70634976221207* r3 pushen, sodass wir r3 innerhalb der Funktion verwenden können, aber den Wert später wiederherstellen können



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

$51514522389782* Analysiere, wie Funktionen funktionieren



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

$68182570848466*
Im letzten Level haben wir uns mit Energiekosten beschäftigt. Damit wollen wir jetzt unsere gesamte Architektur schneller machen.

Sorge dafür, dass unsere Architektur eine [b]Laufzeit von höchstens 175[/b] hat. Dazu musst du Lösungen aus vorherigen Leveln verbessern.

Über die Sanduhr siehst du, welche Komponenten die meiste Laufzeit brauchen. Dort lohnen sich Verbesserungen.

[tip]Falls du in deiner ALU eine NEG Komponente verwendet hast, ist das der beste Ort um Laufzeit zu sparen. Und falls du dein XOR Gatter verbessert hat, gehe sicher, dass du alle relevanten Level nochmal ausgeführt hast.[/tip]

$69806637130600* Schnelle Symphony



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

$17052191264122* Verbessere die Laufzeit auf höchstens 175



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

$36086882016175*
Die meisten Befehle bekommen 2 Argumente und erzeugen 1 Ergebnis (wie ADD, OR usw).

[color=#e49f44]Symphony[/color] benutzt 4 Bytes pro Befehl und kann damit die Argumente und Ergebnis in nur einem Befehl kodieren. Die Befehle sind in einer RAM Komponente gespeichert: Dem [b]Arbeitsspeicher[/b]. Beispielsweise können mit nur einem Befehl sagen: ADD zwei beliebige Register und speichere das Ergebnis in einem beliebigen anderen Register. 

$62556352127349* Kabelsalat

$70083014183793*
Jetzt ist es endlich soweit!
Wir legen die Grundlage der [color=#e49f44]Symphony[/color] Architektur!

$88649654188267*
Hier sind die Namen der 16 Register in [color=#e49f44]Symphony[/color]:

 0 [color=#87a8c8][b]zr[/b][/color]    4 [color=#87a8c8][b]r4[/b][/color]    8  [color=#87a8c8][b]r8[/b][/color]   12 [color=#87a8c8][b]r12[/b][/color]  
 1 [color=#87a8c8][b]r1[/b][/color]    5 [color=#87a8c8][b]r5[/b][/color]    9  [color=#87a8c8][b]r9[/b][/color]   13 [color=#87a8c8][b]r13[/b][/color]  
 2 [color=#87a8c8][b]r2[/b][/color]    6 [color=#87a8c8][b]r6[/b][/color]   10 [color=#87a8c8][b]r10[/b][/color]   14 [color=#87a8c8][b]sp[/b][/color]   
 3 [color=#87a8c8][b]r3[/b][/color]    7 [color=#87a8c8][b]r7[/b][/color]   11 [color=#87a8c8][b]r11[/b][/color]   15 [color=#87a8c8][b]flags[/b][/color]

[color=#87a8c8][b]zr[/b][/color] (zero) soll frei bleiben. In diese Adresse dürfen wir weder Laden noch Speichern, aber dadurch können wir später unsere Architektur vereinfachen. [color=#87a8c8][b]sp[/b][/color] und [color=#87a8c8][b]flags[/b][/color] sind normale Register, die zwar einen besonderen Namen haben, aber um die wir uns erst später kümmern.

Anstatt alle Register einzeln anzuschließen benutzten wir eine RAM Komponente namens [b]Registerbank[/b]. Die RAM Adressen sind sozusagen unsere Register, und ein Register belegt immer direkt 4 Bytes.

Auf dem RAM sitzen diesmal mehrere Ports. Dadurch kann man in einem Taktzyklus mehrfach gleichzeitig Laden und Speichern.



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

$35453700742253* Die Zeit Komponente sollte seit dem letzten time_0 Befehl nicht mehr aktiviert werden.

$40674051088628* Bildschirm-Einstellung 3 sollte Wert {expected_value} haben, nicht {value}.

$55420494010123* Arbeitsspeicher-Adresse {i} sollte den Wert {expected_value} haben, nicht {value}.

$56149980430079* Ausgang muss aktiv sein.

$68153781027719* Dauerspeicher-Adresse {i} sollte Wert {expected_value} haben, nicht {value}.

$74043498193765* Ausgang sollte {expected_output} sein, nicht {output_value}.

$81124009043205* Das 'zr' Register darf nur den Wert 0 enthalten (Adresse 0 in der Registerbank).

$84654787309709* {register} (Registerbank Adresse {address}) sollte Hex-Wert {expected_value} haben, nicht {actual_value}



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

$21345632528660* Lege die Grundlage der Symphony Architektur



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

$85119202720349* EA



=== campaign/symphony_2_io/ui.txt ===

$76620689360899* Füge den Modus für Eingänge und Ausgänge hinzu



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

$78613176066303* Symphony Architektur ALU



=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* Baue die ALU in die Symphony Architektur ein



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

$46968415562883* Symphony Direkte Werte

$74993560224545*
Baue deine Architektur so um, dass sie so aussieht wie hier:

[image="symphony_diagram_2.png"]



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

$90023711394112* Baue deine Architektur so um, dass Direkte Werte aus dem Befehl verarbeitet werden können



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

$39122914366346* Sprünge



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

$88550064597726* Baue Sprünge ein



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

$41276257356528* Symphony Arbeitsspeicher (RAM)

$43585926436336*
Nochmal zu Lade- und Speicher-Ports: Die Abarbeitung der Ports erfolgt von oben nach unten. Das bedeutet, falls ein Lade-Port unterhalb eines Speicher-Ports platziert ist, dann wird zuerst gespeichert und dann geladen. Ist der Lade-Port über dem Speicher-Port platziert, dann wird erst geladen und dann gespeichert. Das ist wichtig, wenn in die selbe Speicher-Adresse geladen und gespeichert werden soll.

Grundsätzlich warten alle Ports, bis die Speicher-Ports oben drüber abgearbeitet sind und haben somit eine Abhängigkeit zu diesen Ports. In diesem Level müssen die Lade-Ports über den Speicher-Ports sein, denn sonst erzeugst du eine [b]Kreisabhängigkeit[/b].

$69462908463194*
Wir müssen die Daten im [b]Arbeitsspeicher[/b] (RAM) Laden und Speichern können. Und zwar wollen wir Daten in 3 unterschiedlichen Bit-Breiten verarbeiten können: 32 Bit, 16 Bit und 8 Bit. Alle im gleichen Taktzyklus. Deswegen brauchen wir 3 neue [b]Lade-Ports[/b] und 3 neue [b]Speicher-Ports[/b], die wir auf den RAM setzen.

Ich habe die neuen Ports schon vorbereitet, allerdings stimmt die Reihenfolge noch nicht. Füge die neuen Ports [b]zwischen[/b] dem Lade-Port für den [b]Befehl[/b] und dem eigentlichen [b]Arbeitsspeicher[/b] ein (mehr dazu gleich nochmal).



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

$51703376131802* Ermögliche load und store auf den Arbeitsspeicher



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

$76705374584193* Dauerspeicher



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

$89678353617146* Baue einen Dauerspeicher ein



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

$28545157055801* Legt %a auf den Stack. Synonym für:   sub sp, sp, 4   store_32 [sp], %a

$34859363394334* Bewegt einen Wert nach %a.

$40508048121543* Dreht die Bits eines Werts um und speichert das Ergebnis in %a.

$48332460366102* Rückkehr vom letzten Funktionsaufruf. Überschreibt das flag Register. Synonym für:   load_32 flags, [sp]   add sp, sp, 4   jmp flags

$53941960758392* (move) Bewegt einen Wert von %b nach %a.

$54469754973269* Nimmt obersten Wert vom Stack und speichert ihn in %a. Synonym für:   load_32 %a, [sp]   add sp, sp, 4

$55357258069734* Dreht die Bits von %b um und speichert das Ergebnis in %a.

$57504570243305* Negiert einen Wert und speichert das Ergebnis in %a.

$57788320241950* Funktionsaufruf %a. Überschreibt das flag Register. Synonym für:   counter flags   add flags, flags, 20   sub sp, sp, 4   store_32 [sp], flags   jmp %a

$72894099288447* Negiert %b und speichert das Ergebnis in %a.



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

$67457044658869*
Damit wir mit unserem Computer interagieren können, müssen wir Eingabe- und Ausgabegeräte anschließen. Diese Geräte, die von außen an den Computer angeschlossen werden, heißen [b]Peripheriegeräte[/b]. Es gibt auch [b]Peripheriebausteine[/b], wie beispielsweise den Zeitgeber. Damit sind Komponenten gemeint, die sich zwar innerhalb des Computers befinden, aber Funktionalitäten bieten, die nicht vom Prozessorkern selbst zur Verfügung gestellt werden.

Für dieses Level brauchen wir 3 neue Komponenten:
Einen [b]Bildschirm[/b], eine [b]Zeit[/b] Komponente und eine [b]Tastatur[/b] Komponente.

Den Bildschirm kannst du schon einmal mit dem [b]Arbeitsspeicher[/b] verknüpfen.



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

$10169473219025* 1 Sekunde = 1_000_000_000 Nanosekunden = 0x0000_0000_3B9A_CA00

$11549850182703* y Koordinate

$16841324702501* Roboter

$22405816552972* Richtung

$23344524651761* next_cycle aktualisieren

$25470599373421* Zeichne Geist an neuer Position

$25474902303790* Richtung hochzählen

$26430777268618* Roboter runter

$28230914387367* Münze

$29369794309677* TODO: Münze und frei unterschiedlich behandeln

$31647601023268* Sprite Adressen Sprungtabelle

$33327526977497* Geist

$33450896282702* Platzhalter

$34042928458359* modulo 3

$35647670060017* frei

$36791496238134* 2 * Befehlsbreite = 8

$37230877526029* Geist rechts

$37647180126584* Zeichne Roboter an neuer Position

$38695844571056* Überlauf

$40959483784712* Roboter rechts

$45301848117435* Geist runter

$50069163371185* Geist links

$50501450979711* Roboter hoch

$55263046326109* Wand -> Bewegung abbrechen

$55673115734516* Abstand um 32 Bits Anordnung beizubehalten

$61792431057747* x Koordinate

$62236058044269* [Abstand]

$64851396075477* 2 * Befehlsbreite = 8

$67744627518982* Münze

$69893421560125* Roboter links

$72366220861688* Geist hoch

$73803385159414* Der erste Wert ist also 0

$75937352730902* 0.5 Sekunden = 500_000_000 Nanosekunden = 0x0000_0000_1DCD_6500



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

$18975134592059* Ausgang muss aktiv sein.

$26871980917450* Dauerspeicher Adresse {i} sollte Wert {address} haben, nicht {value}.

$29202969341865* Falscher Zeit Ausgang (hast du daran gedacht die Zeit, während time_0, zwischenzuspeichern?)

$29909286517152* Das 'zr' Register muss immer 0 sein (Adresse 0 in der 'Registerbank').

$30816527015736* Ausgang sollte {expected_output} sein, nicht {output_value}.

$31400969059429* {register} ('Registerbank' Adresse {address}) sollte Hex Wert {expected_value} haben, nicht {actual_value}

$41024505081324* Du hättest Adresse {counter_value} vom Arbeitsspeicher lesen sollen, nicht {actual_counter}. Im letzten Taktzyklus wurde der Zähler anscheinend falsch gesetzt.

$42960087865089* Bildschirm Einstellung {i} sollte {expected_value} sein, nicht {value}.

$46474751521062* Verknüpfe den Bildschirm mit dem Arbeitsspeicher (kleiner roter Knopf in der Ecke des Bildschirms).

$78917660933958* Arbeitsspeicher Adresse {i} sollte Wert {address} haben, nicht {value}.



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

$63394282539727* Baue Befehle für den EA Modus ein



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

$11626177279992* Sprung zu %a, falls Wert 1 (unsigned) größer als Wert 2 ist (liest 'flags' Register).

$12835125621741* Speichert den Wert von %b in Bildschirm-Einstellung %a.

$13110303123442* Speichert %value in Adresse %adr des Dauerspeichers.

$13576771671264* Logisches Schieben Links von %b um %c und speichert Ergebnis in %a.

$15915531259935* Sendet %a zum Ausgang.

$16685334571248* Logisches Schieben Rechts von %b um %c und speichert Ergebnis in %a.

$18254089726214* Sendet %a zum Ausgang.

$19953421010778* Speichert %value in Adresse %adr des Arbeitsspeichers.

$23349431010010* ADD %b und %c und speichert Ergebnis in %a.

$23396316982953* Lädt Adresse %adr vom Arbeitsspeicher und speichert den Wert in %dest.

$26183125927881* Sprung zu %a, falls Wert 1 (unsigned) kleiner gleich Wert 2 ist (liest 'flags' Register).

$27219499692147* Lädt Adresse %adr vom Arbeitsspeicher und speichert den Wert in %dest.

$27868418224252* Liest Tastatur-Eingabe und speichert den Wert in %a.

$28652904157569* SUB %b und %c und speichert Ergebnis in %a.

$29562677483890* Speichert %value in Adresse %adr des Arbeitsspeichers.

$30574433901064* OR %b und %c und speichert Ergebnis in %a.

$31763492459833* Sprung zu %a, falls Wert 1 (unsigned) kleiner als Wert 2 ist (liest 'flags' Register).

$37102964808364* Vergleicht %a und %b und speichert das Ergebnis ins 'flags' Register.

$37333076617857* NOR %b und %c und speichert Ergebnis in %a.

$39857449355186* Speichert den Wert von %b als Bildschirm-Einstellung %a.

$40732211165530* OR %b und %c und speichert Ergebnis in %a.

$42626144645228* Arithmetisches Schieben Rechts von %b um %c und speichert Ergebnis in %a.

$44524771082050* Liest den Eingang und speichert den Wert in %a.

$46087142860391* NOR %b und %c und speichert Ergebnis in %a.

$46967848572964* XOR %b und %c und speichert Ergebnis in %a.

$47442552951774* Speichert %value in Adresse %adr des Arbeitsspeichers.

$51030225266712* ADD %b und %c und speichert Ergebnis in %a.

$53499765587663* Sprung zu %a, falls Wert 1 (signed) größer gleich Wert 2 ist (liest 'flags' Register).

$54565380946620* Vergleicht %a und %b und speichert das Ergebnis ins 'flags' Register.

$54577249258785* Logisches Schieben Links von %b um %c und speichert Ergebnis in %a.

$55551510150818* Arithmetisches Schieben Rechts von %b um %c und speichert Ergebnis in %a.

$57200935026773* Lädt Adresse %adr vom Arbeitsspeicher und speichert den Wert in %dest.

$59344052643304* Speichert %value in Adresse %adr des Dauerspeichers.

$61040780958703* Speichert %value in Adresse %adr des Arbeitsspeichers.

$66785854415645* XOR %b und %c und speichert Ergebnis in %a.

$67019902294705* Logisches Schieben Rechts von %b um %c und speichert Ergebnis in %a.

$67178948469318* Sprung zu %a, falls Wert 1 ungleich Wert 2 ist (liest 'flags' Register).

$67376584796076* Liest den Zähler und speichert den Wert in %a.

$67495552371225* SUB %b und %c und speichert Ergebnis in %a.

$68219187873304* Liest die oberen 4 Byte der Zeit und speichert den Wert in %a.

$69550893885320* Speichert %value in Adresse %adr des Arbeitsspeichers.

$69632418904622* Lädt Adresse %adr vom Arbeitsspeicher und speichert den Wert in %dest.

$71317192057126* Sprung zu %a, falls Wert 1 (signed) größer als Wert 2 ist (liest 'flags' Register).

$71637103729391* Sprung zu %a, falls Wert 1 (signed) kleiner als Wert 2 ist (liest 'flags' Register).

$72280171778920* Lädt Adresse %adr vom Dauerspeicher und speichert den Wert in %dest.

$72551400437977* Liest die unteren 4 Byte der Zeit und speichert den Wert in %a.

$73559051740347* Speichert %value in Adresse %adr des Arbeitsspeichers.

$74148826866592* Sprung zu %a.

$75302656449127* NAND %b und %c und speichert Ergebnis in %a.

$77040234358389* Sprung zu %a, falls Wert 1 (signed) kleiner gleich Wert 2 ist (liest 'flags' Register).

$77232719678109* Lädt Adresse %adr vom Arbeitsspeicher und speichert den Wert in %dest.

$82087388048746* Sprung zu %a, falls Wert 1 (unsigned) größer gleich Wert 2 ist (liest 'flags' Register).

$85679146831122* AND %b und %c und speichert Ergebnis in %a.

$85822609095465* Lädt Adresse %adr vom Arbeitsspeicher und speichert den Wert in %dest.

$86705346481666* NAND %b und %c und speichert Ergebnis in %a.

$86713121915282* AND %b und %c und speichert Ergebnis in %a.

$88180305667389* Sprung zu %a, falls Wert 1 gleich Wert 2 ist (liest 'flags' Register).

$88272577071256* (no operation) Tue nichts.

$89257021109854* Lädt Adresse %adr vom Dauerspeicher und speichert den Wert in %dest.

$90876214388280* Sprung zu %a.



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

$18099138932731* Dauerspeicher

$28246040923235* Registerbank

$35059654572638* Zeit

$41903613959902* Arbeitsspeicher

$79162322081640* Tastatur

$80985404567327* Bildschirm



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

$20456965663323* Befehls Aliase



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

$71972143734450* Hex Wert



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

$44683006232656* Der erste Befehl sollte Hex Wert 0x1235 nach r1 bewegen.

$67087756287234* r3 sollte Hex Wert 0x1234 haben.

$83123414679662* r2 sollte Hex Wert 0xffffedcb haben.



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

$13320201556243* Baue Aliase für die Befehle mov, neg und not



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

$52048822283735*
Hier ist eine Kopie deiner Overture ALU. Wir brauchen eine 32 Bit Variante und ein paar weitere Befehle:

[color=#87a8c8] 0 NAND      6 XOR 
 1 OR        7 LSL 
 2 AND       8 LSR 
 3 NOR       9 ASR 
 4 ADD      10 CMP 
 5 SUB             [/color]

Die [b]cmp[/b] Operation steht für [b]compare[/b] und ist deine Flag Komponente, die Zahlen vergleicht.

$71902120982324* Symphony ALU



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

$69427874681706* Baue die Overture ALU zur Symphony ALU um



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

$37729390402296* Symphony Flags

$64818361855764*
Dieses Level ist ähnlich zum Level [b]Bedingungen[/b]. Hier ist es jetzt aber so, dass wir zwei Werte miteinander vergleichen und ohne Befehl einfach ein paar Bedingungen prüfen. Für jede dieser Bedingungen gibt es einen eigenen Ausgang. Die Ausgänge sind nur ein einzelnes Bit und zeigen an, ob die entsprechende (eingebaute) Bedingung erfüllt ist. Die Ausgangs-Bits werden auch als [b]Flags[/b] bezeichnet. Bevor wir die Flags tatsächlich zum Ausgang schicken, sammeln wir sie wieder in einem gemeisamen Kabel.

Du bekommst einen 32-Bit breiten Eingang und sollst folgende Bedingungen prüfen:

Flag 0 ist [T], falls Arg A = Arg B           
Flag 1 ist [T], falls Arg A < Arg B (unsigned)
Flag 2 ist [T], falls Arg A < Arg B (signed)  

Falls du noch nicht weißt, wie man 32-Bit Komponenten baut, schau dir zuerst das Level [b]Symphony Zähler[/b] an.



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

$55730459238598* Erwarteter Ausgang: {a}{b}{c}.



=== campaign/symphony_cmp/ui.txt ===

$73310930628112* Prüfe die 3 Bedingungen und gebe die Flags aus



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

$13327132168076* Ergebnis

$17010689474441* Bedingung

$25959617344671* Flags



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

$20911185106374*
Wir brauchen eine Komponente, die prüft, ob eine bestimmte [b]Bedingung[/b] zu den berechneten [b]Flags[/b] passt.

Am Eingang bekommst du die 3 Flag-Bits und 4 Bits für die Bedingung. Die Bedingung ist aber diesmal kein Code (also [b]keine[/b] Zahl, die eine Bedingung beschreibt), stattdessen ist sie ein Spiegelbild der Flags. Wenn ein bestimmtes Bedingungs-Bit [T] ist, dann muss auch das passende Flag-Bit [T] sein, damit die Bedingung als erfüllt angesehen wird. Sobald eines der Paare [T] ist, gilt die Bedingung als erfüllt, und es soll [T] ausgegeben werden.

Das 4. Bit der Bedingung hat eine Sonderrolle:
Wenn das 4. Bit der Bedingung [T] ist, dann wird der Ausgang umgedreht. Ist die Bedingung also beispielsweise erfüllt und es soll [T] ausgeben werden, dann würde ein [T] 4. Bit dafür sorgen, dass stattdessen [F] ausgegeben wird.

$90224867995967* Bedingungen abgleichen



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

$33181499064044* Ergebnis sollte nie Z sein.

$73051402798264* Der richtige Ausgangswert ist {U1 result}



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

$41164574218692* Zählerwert

$42019997838216* Überschreiben

$48990052180226* Neuer Wert



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

$56387381898532* Symphony Zähler

$76860406179468*
Siehst du links den Knopf mit dem Pfeil  und der Zahl? Damit kannst du die [b]Bit-Breite[/b] der Komponenten einstellen. Also mit wie vielen Bits eine Komponente arbeiten soll. Über [b]Rechtsklick[/b] auf das Symbol kannst du die Bit-Breite einstellen, die für neu platzierte Komponenten verwendet wird.

Die Bit-Breite einer platzierten Komponente siehst du anhand der kleinen grauen Zahl innerhalb der Komponente. Um die Bit-Breite von bereits platzierten Komponenten zu ändern, kannst du das Symbol [b]linksklicken[/b], dann ändert sich der Cursor. Wenn du mit diesem geänderten Cursor auf eine Komponente klickst, ändert sie ihre Bit-Breite auf den eingestellten Wert.

$77897142643435*
Baue einen 32 Bit Zähler, der pro Taktzyklus immer 4 hochzählt. Er soll außerdem mit einem beliebigen Wert überschrieben werden können.

Um den Wert abzuspeichern brauchst du irgendwo einen Speicher. An diesem Speicher sollst du zusätzlich eine [b]Speichersonde[/b] anbringen, damit wir den gespeicherten Wert auch außerhalb der Komponente sehen können. Um eine Speichersonde an eine andere Komponente anzubringen, klicke auf das kleine Link-Symbol rechts oben innerhalb der Speichersonde und klicke dann auf die Zielkomponente, mit der du die Speichersonde verknüpfen möchtest.



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

$54301125260332* Speicherwert sollte {expected_memory} sein, nicht {memory_value}

$70376380014778* Ausgang darf nie Z sein.

$84451713761977* Ausgang sollte {expected_memory} sein.



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

$81792554779622* Baue einen 32 Bit Zähler, der pro Taktzyklus 4 hochzählt



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

$16402377924132* Direkt-Bit

$24747841106265* Argument B

$26207217884026* Operation

$26325060783055* Argument A

$40584554497383* Direkter Wert

$48212238534381* Befehl

$48506758479060* Modus

$67128656777473* Zielregister



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

$13883461694525* Symphony Befehlsdecoder

$41138026161536*
Um bestimmte Bits aus einem Kabel herauszulösen, kannst du die Komponente [b]Statischer Indexer[/b] benutzen. Sie verschiebt die Bits auf dem Kabel nach rechts und gibt dann vom Ergebnis eine bestimmte Bit-Breite aus.

Wenn du den Statischen Indexer anklickst, kannst du eine Zahl eintragen, um wie viele Stellen der Wert verschoben werden soll. Über die Bit-Breite kannst du einstellen, wie viele Bits er anschließend ausgeben soll, ausgehend vom kleinsten Bit.

Beispiel:
7 6 5 4 3 2 1 0
[T][T][F][F][T][T][T][F]
Wir möchten gern Bit [b]4,3,2[/b] herauslösen.
Also verschieben wir um 2 nach rechts,
[F][F][T][T][F][F][T][T]
und geben eine Bit-Breite von 3 aus:
[Z][Z][Z][Z][Z][F][T][T]
Es bleibt [F][T][T] als Ergebnis.



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

$15174125339458* Operation sollte {opcode} sein, nicht {actual_opcode}.

$31544476297744* Zielregister sollte {dest} sein.

$31942264008156* Argument B sollte {b} sein.

$45701446129480* Direkter Wert sollte {immediate_value} sein.

$63089562267538* Direkt-Bit sollte {immediate} sein.

$64926808682290* Modus sollte {mode} sein.

$82638458430252* Argument A sollte {a} sein.



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

$51036929729507* Löse den Befehl in seine einzelnen Segmente auf



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

$25477689162292* Ausgang Auswahl

$25535487507842* A

$43340511034957* Eingang Auswahl

$43474590938240* Y

$47236089523392* X

$65041743851294* B



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

$10949534274977* Bus

$25369396405852*
Dieses Level hat 2 Byte Eingänge und 2 Byte Ausgänge. Das Ziel ist es eine Zahl von einen der Eingänge zu einen der Ausgänge zu leiten.

Außerdem gibt es 2 Bit Eingänge. Der erste steuert, von welchem Eingang die Zahl durchgeleitet werden soll. Der zweite steuert, auf welchen Ausgang die Zahl geleitet werden soll.

In jedem Taktzyklus soll nur einer der Ausgänge einen Wert bekommen. Der andere bekommt Z (keinen Wert). Dies wird durch "-" am Ausgang dargestellt.



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

$28173496384607* Ausgang Y sollte {val} sein.

$46672500255781* Ausgang X sollte Z sein.

$65293894030728* Ausgang X sollte {val} sein.

$69214136994673* Leite den Wert von {source} nach {destination}

$75577618213381* Ausgang Y sollte Z sein.



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

$31341803878224* Baue einen Schaltkreis, der beliebige Eingänge auf Ausgänge leitet



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

$23374750315066*
Im Spiel die [b]Türme von Hanoi[/b] gibt es 3 Holzstäbe und einige runde Scheiben in verschiedenen Größen mit einem Loch in der Mitte. Die Scheiben können der Größe nach geordnet auf einen Holzstab gesteckt werden, sodass sie einen Turm bilden.

Ziel des Spiels ist es, den Turm durch Umschichten der Scheiben auf einem anderen Holzstab wieder aufzubauen. 

Es gibt aber ein paar Regeln beim Umschichten:
1. Immer nur eine Scheibe gleichzeitig 
2. Scheiben immer von oben nehmen      
3. Große Scheiben dürfen nie auf Kleine

$29450953142176* Türme von Hanoi

$62636370223849*
Unglaublich! Du hast all unsere Tests bestanden!
Schau nur, wie weit du gekommen bist, seitdem du dein erstes NAND Gatter angeschlossen hast.

Du hast bewiesen, dass die Menschheit einen Platz in der Galaktischen Föderation verdient hat!



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

$39419617008574* Huch... da lag eine größere Scheibe auf einer kleineren!



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

$89305883777750* Siehst du, dass das XNOR Gatter genau das Gegenteil vom XOR Gatter ist?



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

$29396170535219* Baue einen Schaltkreis, der [T] ausgibt, wenn die Eingänge gleich sind.

$50956872142719* XNOR Gatter



=== campaign/xor_gate/hint_0.txt ===

$15534865654723* Eingang 0

$17025412277453* Eingang 1

$59092390409834* Erwarteter Ausgang

$62308032073140* ODER Eingang 0 NICHT [T] UND Eingang 1 ist [T].

$84782011304318* Der Ausgang ist [T], wenn Eingang 0 [T] UND Eingang 1 NICHT [T] ist,



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

$16623524168613* Aber du kannst gerne versuchen eine bessere Lösung zu finden!

$30671593085518* Diese Lösung ist nicht die eleganteste und auch nicht die beste.



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

$22122562689406* Ausgang

$45326245069696* Eingang



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

$21287008524643* XOR Gatter

$30005674935190*
Dieser Schaltkreis heißt [b]XOR Gatter[/b] und wird immer dann verwendet, wenn man prüfen möchte, ob 2 Eingänge unterschiedliche Werte haben.

Das Level ist schwer, also lass dich nicht entmutigen, falls du die Lösung nicht sofort findest.
  
[tip]Kabel können aufgeteilt, und gleichzeitig auf verschiedene Komponenten geleitet werden[/tip]

$50002893048555* Im letzten Level hast du einen Schaltkreis gebaut, der im zweiten Taktzyklus [T] war. In diesem Level soll der Ausgang im zweiten [b]oder[/b] dritten Taktzyklus [T] sein.



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

$38271404408184* Aktueller Ausgang



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


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


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



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


# com_mux's output pin
$10003014068713* Ausgang


# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* Eingänge


# com_concatenator_8's input pin
$10080083255838* Word 3


# com_clz's output pin
$10092537578053* Ergebnis


# com_splitter_bit_4's output pin
$10111764008386* Bit 2


# com_level_output_4_pin's name
$10190739202646* Ausgang


# com_ctz's description
$10231593934948* Zählt 0en vom LSb, bis zur ersten 1


# com_xor_word's output pin
$10269927015049* Ergebnis


# com_static_indexer_config's name
$10289043699917* Auto Statischer Indexer


# com_lsr's input pin
$10335381544532* Schieben


# com_halt's name
$10351143139905* Halt


# com_nand_word's input pin
$10425218359878* Eingang 0


# com_splitter_bit_8's description
$10488114435022* Trennt 1 Byte in 8 Bits


# com_splitter_bit_8's output pin
$10491931394044* Bit 3


# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* E/A


# com_probe_wire_bit's input pin
$10499689720024* Wert


# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* Entw


# com_splitter_bit_4's name
$10524104374521* Trenner


# com_cc_output's name
$10557704838301* Ausgangs-Pin


# com_segment_display's name
$10582128204153* 7 Segment Anzeige


# com_switch_word's name
$10611658692685* Schalter


# com_xnor_bit's description
$10614106399129* Eingänge sind gleich


# com_not_word's description
$10624873506476* Bitweises NOT eines Werts


# com_counter's output pin
$10629272823895* Zählen


# com_splitter_bit_2's output pin
$10655485270988* Bit 0


# com_splitter_bit_8's output pin
$10688845521356* Bit 1


# com_level_input_3_pin's name
$10689623552857* Eingang


# com_maker_bit_8's input pin
$10716205698752* Bit 5


# com_decoder_3's input pin
$10755367544042* Eingang


# com_delay_line_word_config's output pin
$10757852071445* Ergebnis


# com_rol's input pin
$10762061266647* Wert


# com_decoder_2's output pin
$10762093809413* Bit 1


# com_nor_word's input pin
$10770218762282* Eingang 0


# com_concatenator_2's description
$10776829749898* Verbindet 2 Werte. Bit-Breite des Ausgangs ist Summe der Bit-Breiten des Eingangs


# com_cc_output's description
$10781578424003* Ausgangs-Pin


# com_ror's description
$10802217509530* Rotiert die Bits des Eingangs nach rechts


# com_add's output pin
$10815269647822* Übertrag


# com_not_bit's description
$10844421681709* Eingang ist nicht [T]


# com_nand_word's description
$10859914201083* Bitweises NAND von 2 Werten


# com_full_adder's output pin
$10918445419498* Ergebnis


# com_static_value's output pin
$10920459933396* Wert


# com_mod's description
$10934212906097* Modulo von 2 Zahlen


# com_level_input_word's name
$10943344093513* Eingang


# com_keyboard's name
$10965596602414* Tastatur


# com_less_s's output pin
$11019209691112* Ergebnis


# com_asr's name
$11034107377099* Arithmetisches Schieben Rrechts


# com_maker_word_2's description
$11048127331082* Sammelt zwei (n/2)-Bit Werte in einem n-Bit Wert


# com_register_word_config's input pin
$11057152094224* Größe


# com_concatenator_8's input pin
$11115698874478* Wort 0


# com_maker_bit_4's name
$11119510732154* Sammler


# com_nand_bit's name
$11130919681688* NAND


# com_static_indexer_config's output pin
$11132082500971* Ergebnis


# com_mux's description
$11168613697835* Wählt einen aus zwei Eingängen


# com_full_adder's input pin
$11264799740288* Eingang 0


# com_level_input_switched's name
$11278573510238* Schaltbarer Eingang


# com_not_word's name
$11286216680410* NOT


# com_maker_word_2's output pin
$11293966912554* Ergebnis


# com_decoder_2's output pin
$11297026031742* Bit 2


# com_level_output_word's name
$11300749636961* Ausgang


# com_full_adder's input pin
$11312161634667* Eingang 1


# com_delay_line_word_config's late input pin
$11320392055125* Eingang


# com_mod's output pin
$11329013865174* Ergebnis


# com_or_word's input pin
$11335506036805* Eingang 1


# com_level_input_word's description
$11342065742485* Wort Eingang


# com_splitter_word_4's output pin
$11345730126879* Wort 0


# com_static_indexer_config's input pin
$11349557191063* Eingang


# com_maker_word_8's output pin
$11351867388170* Ergebnis


# com_mod's input pin
$11352468367638* Dividend


# com_concatenator_8's input pin
$11366501215506* Word 2


# com_level_gate's name
$11417416554850* Level Komponente


# com_splitter_word_8's input pin
$11440186157356* Eingang


# com_level_input_4_pin's name
$11447837612693* Eingang


# com_inc's description
$11449663590476* Erhöht den Eingangswert um 1


# com_splitter_word_8's output pin
$11465347976002* Word 3


# com_level_output_switched's input pin
$11520072088720* Aktivieren


# com_asr's output pin
$11521973612539* Ergebnis


# com_splitter_bit_8's output pin
$11548514728473* Bit 0


# com_switch_bit's name
$11574334638147* Schalter


# com_nand_word's input pin
$11578787451669* Eingang 1


# com_div's input pin
$11611913368782* Divisor


# com_switch_word's output pin
$11625195403324* Ausgang


# com_maker_bit_8's input pin
$11634467729625* Bit 4


# com_neg's input pin
$11637742665554* Eingang


# com_clz's name
$11678932883790* Zählt führende Nullen


# com_ram's name
$11710093917097* RAM


# com_decoder_2's name
$11727998752868* 2 Bit Decoder


# com_maker_bit_2's input pin
$11752209410617* Bit 1


# com_and_word's description
$11791872137683* Bitweises AND von 2 Werten


# com_mul's output pin
$11838813794006* Ergebnis


# com_off's name
$11860786587357* AUS


# com_splitter_bit_8's name
$11904470559153* Trenner


# com_nor_word's output pin
$11938328576163* Ergebnis


# com_delay_line_bit's output pin
$11945697622944* Ergebnis


# com_and_word's input pin
$11977039914327* Eingang 0


# com_neg's description
$12021716182809* Negiert den Eingang


# com_splitter_bit_2's input pin
$12046095993506* Eingang


# com_screen's name
$12046117430308* Bildschirm


# com_cc_level_output's description
$12051024347384* Wort-Ausgang, der zu Eingang/Ausgang-Pin wird, wenn Lösung als Komponente gespeichert wird


# com_splitter_bit_4's input pin
$12060097589370* Eingang


# com_xnor_word's name
$12087865653212* XNOR


# com_ror's name
$12093087039542* Rotiere Rechts


# com_delay_line_bit's name
$12121899638400* Verzögerung


# com_nor_word's name
$12175906806727* NOR


# com_neg's output pin
$12196354295621* Ergebnis


# com_level_output_1_pin's name
$12242923444593* Ausgang


# com_level_output_counter's name
$12247325526438* Zähler


# com_maker_word_4's output pin
$12262460678043* Ergebnis


# com_probe_memory_bit's name
$12318534735397* Speichersonde (Bit)


# com_concatenator_2's input pin
$12329350771997* Kabel 2


# com_concatenator_8's input pin
$12341255296823* Word 1


# com_verilog_output's name
$12353364840899* Verilog Ausgang


# com_probe_wire_asm's late input pin
$12365938365321* Eingang


# com_splitter_word_4's description
$12370556827575* Trennt 1 (4n)-Bit Wert in 4 n-Bit Werte


# com_concatenator_4's input pin
$12371272172145* Word 1


# com_concatenator_8's input pin
$12384635971036* Word 5


# com_decoder_3's output pin
$12390018918095* Bit 7


# com_asr's input pin
$12408847893200* Schieben


# com_register_word's late input pin
$12420839132846* Neuer Wert


# com_constant's description
$12424468899005* Konstanter Wert


# com_concatenator_8's description
$12443053648819* Verbindet 8 Werte. Bit-Breite des Ausgangs ist Summe der Bit-Breiten des Eingangs


# com_keyboard's output pin
$12465282633818* Tastenwert


# com_level_input_1_pin's output pin
$12465938629713* Eingang


# com_concatenator_8's output pin
$12478474747295* Ergebnis


# com_probe_memory_word's description
$12492235992906* Zeigt einen Wert auf einer Eigenen Komponente an, oder im Programm-Editor


# com_mux's input pin
$12520768681157* Wert 1


# com_switch_word's input pin
$12550214308917* Wert


# com_maker_word_8's input pin
$12592072659210* Word 1


# com_maker_bit_2's name
$12602955212919* Sammler


# com_maker_word_8's input pin
$12616927929524* Word 3


# com_static_indexer_config's input pin
$12633414511976* Größe


# com_delay_line_word's late input pin
$12644592179746* Eingang


# com_register_bit's name
$12678278048629* Register


# com_mux's input pin
$12687047365426* Wert 0


# com_and_bit's description
$12719674432950* Eingänge sind [T]


# com_splitter_word_2's name
$12723870092766* Trenner


# com_counter's description
$12736827510023* Zählt jeden Taktzyklus hoch


# com_level_input_1_pin's name
$12746117288689* Eingang


# com_off's description
$12749460799924* Immer [F]


# com_less_s's description
$12765625016236* Prüft, ob der erste Eingang kleiner ist, als der zweite


# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* Bit


# com_switch_word's input pin
$12784430582183* Aktivieren


# com_lsl's input pin
$12849468178655* Wert


# com_static_indexer_config's input pin
$12869119410565* Schieben


# com_nand_bit's description
$12903183841172* Mindestens ein Eingang [F]


# com_and_word's name
$12926911335769* AND


# com_lsr's name
$12931148241340* Schiebe Rechts


# com_splitter_word_4's input pin
$12938882109013* Eingang


# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* Anzeigen


# com_halt's description
$12990744955549* Stoppt die Ausführung mit einer benutzerdefinierten Nachricht.


# com_or_bit's description
$13013154620359* Mindestens ein Eingang [T]


# com_level_output_8_pin's name
$13087193858087* Ausgang


# com_maker_bit_8's input pin
$13104890311933* Bit 1


# com_rol's input pin
$13135722015590* Rotieren um


# com_decoder_3's output pin
$13138546420646* Bit 6


# com_store_port's name
$13159020985209* Speicher-Port


# com_level_delay_gate's name
$13161432526100* Level und Laufzeit Komponente


# com_level_output_3_pin's description
$13174121812559* 3-Bit Ausgang


# com_maker_word_4's input pin
$13236424504117* Word 2


# com_xor_word's description
$13236921580268* Bitweises XOR von 2 Werten


# com_level_output_2_pin's name
$13255344581755* Ausgang


# com_level_gate's description
$13259215761047* Braucht man für Level


# com_cc_input's description
$13263310288543* Eingangs-Pin


# com_delay_line_word_config's input pin
$13271299225650* Größe


# com_level_input_1_pin's description
$13272198916233* 1-Bit Eingang


# com_register_word's late input pin
$13298317818150* Speichern


# com_concatenator_4's input pin
$13331778821779* Wort 0


# com_verilog_input's output pin
$13351141217116* Eingang


# com_nor_bit's name
$13375115196253* NOR


# com_maker_word_8's input pin
$13378739117488* Word 6


# com_less_u's name
$13502755965496* Kleiner als < (unsigned)


# com_splitter_word_2's output pin
$13510688527850* Word 1


# com_ror's input pin
$13521735131997* Rotieren um


# com_register_word's description
$13576980017857* Kleine Speicher Komponente


# com_splitter_word_2's output pin
$13625849577132* Wort 0


# com_splitter_bit_8's output pin
$13666042416530* Bit 2


# com_keyboard's output pin
$13705122401876* Event in Warteschlange


# com_splitter_bit_2's name
$13766521376720* Trenner


# com_maker_bit_4's input pin
$13826250945595* Bit 3


# com_ctz's input pin
$13829181406158* Eingang


# com_equal's input pin
$13859686951415* Eingang 0


# com_add's name
$13973952772642* Addierer


# com_xnor_bit's name
$14079327237795* XNOR


# com_lsl's output pin
$14132199132916* Ergebnis


# com_less_u's input pin
$14201184715010* Eingang 0


# com_maker_bit_4's input pin
$14237744302250* Bit 0


# com_keyboard's output pin
$14338437722935* Taste gedrückt


# com_maker_bit_8's description
$14338505460996* Sammelt 8 Bits zu einem Byte


# com_level_input_2_pin's description
$14340334686746* 2-Bit Eingang


# com_decoder_3's name
$14375716460090* 3-Bit Dekoder


# com_verilog_input's description
$14408471620057* Verilog Eingang


# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* Breite


# com_probe_wire_word's name
$14427436420428* Kabelsonde


# com_not_bit's name
$14453052824732* NOT


# com_inc's name
$14456039381703* +1


# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* Verilog


# com_nor_word's description
$14517798310461* Bitweises NOR von 2 Werten


# com_maker_bit_2's description
$14531866237078* Sammelt 2 Bits zu einem 2-Bit Wert


# com_splitter_word_8's output pin
$14592399073683* Word 7


# com_splitter_bit_4's output pin
$14645527447275* Bit 0


# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* Speicher


# com_decoder_3's output pin
$14688114733776* Bit 5


# com_maker_bit_8's input pin
$14770992007366* Bit 6


# com_maker_word_2's name
$14812135740513* Wort Sammler


# com_xor_bit's name
$14832952840086* XOR


# com_register_bit's output pin
$14834136969633* Gespeicherter Wert


# com_maker_bit_2's input pin
$14834270613682* Bit 0


# com_segment_display's input pin
$14849689592952* Wert


# com_maker_bit_4's input pin
$14852108377004* Bit 2


# com_level_output_2_pin's description
$14875690243444* 2-Bit Ausgang


# com_maker_bit_8's output pin
$14889574903079* Ergebnis


# com_mul's input pin
$14896244080868* Eingang 0


# com_mul's input pin
$14913258317738* Eingang 1


# com_probe_wire_word's input pin
$14914933156268* Wert


# com_level_input_switched's input pin
$14935676453720* Aktivieren


# com_maker_bit_8's input pin
$14944669923906* Bit 7


# com_div's name
$14959426271423* Teilen


# com_verilog_output's description
$14973155280765* Verilog Ausgang


# com_less_u's output pin
$15024221028085* Ergebnis


# com_mux's input pin
$15091015683874* Auswahl 0 / 1


# com_asr's description
$15194709458499* Schiebt Bits nach recht, beachtet aber das Vorzeichen


# com_probe_wire_bit's description
$15206117280094* Zeigt einen Wert auf einer Eigenen Komponente an, oder im Programm-Editor


# com_splitter_word_8's description
$15228522216068* Trennt einen (8n)-Bit Wert in acht n-Bit Werte


# com_maker_word_4's input pin
$15232070727738* Word 1


# com_lsl's name
$15268915597774* Schiebe links


# com_inc's output pin
$15310910823919* Ergebnis


# com_splitter_word_4's output pin
$15360783001914* Word 2


# com_less_s's name
$15403981009644* Kleiner als < (signed)


# com_maker_word_4's description
$15410415450178* Sammelt 4 (n/4)-bit Werte zu 1 n-Bit Wert


# com_splitter_word_2's description
$15417695246232* Trennt einen (2n)-Bit Wert in zwei n-Bit Werte


# com_mux's name
$15422378975821* Multiplexer


# com_less_s's input pin
$15432695156488* Eingang 0


# com_concatenator_4's description
$15492861320167* Verbindet 4 Werte. Bit-Breite des Ausgangs ist Summe der Bit-Breiten des Eingangs


# com_decoder_3's output pin
$15527856774069* Bit 2


# com_rol's description
$15557725551789* Rotiert die Eingangs-Bits nach links


# com_splitter_word_4's output pin
$15566912320742* Word 1


# com_cc_level_output's name
$15625973306519* Ausgang


# com_not_word's output pin
$15635980858172* Ergebnis


# com_level_output_8_pin's input pin
$15649241608462* Ausgang 6


# com_equal's description
$15668435514829* Prüft, ob 2 Eingänge gleich sind


# com_maker_word_4's input pin
$15693531522415* Wort 0


# com_splitter_bit_4's output pin
$15744234453408* Bit 3


# com_concatenator_8's input pin
$15759275278695* Word 4


# com_ror's input pin
$15762072154176* Wert


# com_xnor_word's description
$15789912406647* Bitweises XOR von 2 Werten


# com_static_value's output pin
$15833633678405* Bit-Größe


# com_maker_word_8's description
$15845204308823* Sammelt 8 (n/8)-Bit Werte zu einem n-Bit Wert


# com_constant's name
$15858905835416* Konstante


# com_on's name
$15896157427528* AN


# com_decoder_2's output pin
$15898724303882* Bit 3


# com_concatenator_4's name
$15908922745328* Verbinder


# com_or_word's input pin
$15962339721851* Eingang 0


# com_probe_wire_word's description
$15969687819995* Zeigt einen Wert auf einer Eigenen Komponente an, oder im Programm-Editor


# com_clz's input pin
$15988469904002* Eingang


# com_register_word's name
$16007777261800* Register


# com_time's name
$16011300295966* Zeit


# com_splitter_word_4's output pin
$16099286786157* Word 3


# com_static_indexer's description
$16103423834548* Schiebt Wert eines Kabels um eine feste Anzahl ohne Gatter/Laufzeit-Kosten. Positive Werte schieben rechts, negative links


# com_lsr's input pin
$16105779236896* Wert


# com_less_s's input pin
$16118461327893* Eingang 1


# com_splitter_word_8's output pin
$16120663256468* Word 4


# com_level_output_word's description
$16148744080822* Wort-Ausgang, der zu Eingang/Ausgang-Pin wird, wenn Lösung als Komponente gespeichert wird


# com_maker_word_2's input pin
$16178897760565* Word 1


# com_splitter_bit_8's input pin
$16196769003341* Eingang


# com_on's description
$16212935718484* Immer [T]


# com_mod's name
$16223673009720* Modulo


# com_level_output_4_pin's input pin
$16259545926196* Ausgang 0


# com_ror's output pin
$16261916666444* Ergebnis


# com_level_output_3_pin's name
$16269858195218* Ausgang


# com_static_eval's name
$16294314784377* Statischer Auswerter


# com_less_u's input pin
$16307028951926* Eingang 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* Logik


# com_load_port's name
$16380513614754* Lade-Port


# com_counter's late input pin
$16380665909610* Überschreiben


# com_splitter_bit_4's description
$16428357982878* Trennt einen 4-Bit Wert in 4 Bits


# com_load_port's description
$16440979564796* Lade-Pin für einen RAM


# com_concatenator_4's output pin
$16450922709110* Ergebnis


# com_lsl's description
$16482114876737* Schiebt die Bits des Eingangs nach links


# com_mul's name
$16549841656852* Multiplizieren


# com_add's output pin
$16559516323162* Ergebnis


# com_splitter_word_4's name
$16563671560208* Trenner


# com_level_input_3_pin's description
$16604606953092* 3-Bit Eingang


# com_maker_word_4's name
$16610055905190* Wort Sammler


# com_decoder_3's output pin
$16637198920534* Bit 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* Ausgänge


# com_xor_word's input pin
$16674052164634* Eingang 0


# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* Eigen


# com_decoder_1's description
$16685462633615* 2 Bit Auswahl mit 1-Bit Eingang


# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* Level


# com_rol's name
$16755142829250* Links Rotieren


# com_segment_display's description
$16761198694928* Für das Darstellen von Zahlen


# com_keyboard's description
$16766452660421* Nimmt Tastenanschläge deiner Tastatur auf


# com_decoder_3's input pin
$16773243310913* Deaktivieren


# com_level_input_switched's description
$16797889673362* Lädt den Eingang für Level


# com_and_word's output pin
$16806711173957* Ergebnis


# com_cc_level_input's name
$16810631435170* Eingang


# com_and_3_bit's description
$16839706221116* 3-Eingang AND Gatter


# com_xor_word's name
$16843812162355* XOR


# com_xor_bit's description
$16856280609387* Eingänge sind verschieden


# com_level_input_2_pin's name
$16870364449392* Eingang


# com_static_eval's description
$16874064281189* Berechnet einen Wert vor Simulationsbeginn (wird dann zu einer Konstanten)


# com_probe_memory_bit's description
$16875362121056* Zeigt einen Wert auf einer Eigenen Komponente an, oder im Programm-Editor


# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* Wort


# com_switch_bit's description
$16917313833836* Schaltet ein Bit an oder ab


# com_concatenator_8's name
$16974631589430* Verbinder


# com_cc_level_output's input pin
$17030391013189* Ausgang


# com_splitter_bit_8's output pin
$17053062486634* Bit 4


# com_or_word's name
$17053670145576* OR


# com_xnor_word's output pin
$17089816656649* Ergebnis


# com_decoder_3's output pin
$17090003684860* Bit 4


# com_splitter_bit_8's output pin
$17163920171569* Bit 6


# com_static_value's name
$17192199509688* Statischer Wert


# com_store_port's description
$17240636780043* Speicher-Pin für einem RAM


# com_mod's input pin
$17244932190980* Divisor


# com_or_bit's name
$17247779246257* OR


# com_splitter_bit_2's output pin
$17293853955838* Bit 1


# com_switch_word's description
$17345192339084* Schaltet einen Wert an oder ab


# com_delay_line_word's name
$17407828844862* Verzögerung


# com_splitter_word_8's output pin
$17425893786880* Word 6


# com_concatenator_2's name
$17495243848605* Verbinder


# com_nor_bit's description
$17510848535619* Eingänge sind [F]


# com_maker_bit_8's input pin
$17515061804367* Bit 0


# com_full_adder's description
$17559382166174* Addiert 3 Bits und gibt Summe und Übertrag aus


# com_or_3_bit's description
$17576327690867* 3-Eingang OR Gatter


# com_maker_word_8's name
$17581447274882* Sammler


# com_register_word_config's name
$17630501850089* Auto Register


# com_level_output_3_pin's input pin
$17644027370563* Ausgang 2


# com_splitter_bit_8's output pin
$17664445405251* Bit 5


# com_full_adder's name
$17669928463861* Volladdierer


# com_register_bit's description
$17670626909848* 1 Bit Speicher


# com_maker_word_4's input pin
$17742753106024* Word 3


# com_register_bit's late input pin
$17744526831576* Speichern


# com_concatenator_2's output pin
$17758165407719* Ergebnis


# com_counter's late input pin
$17764401720104* Neuer Wert


# com_equal's input pin
$17767800149691* Eingang 1


# com_static_value's description
$17781742628050* Zum Setzen von Werten oder Bit-Breiten für Eigene Komponenten


# com_add's input pin
$17802619460312* Übertrag


# com_cc_input's name
$17814826739168* Eingang Pin


# com_add's input pin
$17820183531095* Eingang 0


# com_splitter_bit_4's output pin
$17862413256378* Bit 1


# com_equal's output pin
$17864898529357* Ergebnis


# com_maker_bit_4's input pin
$17897455882076* Bit 1


# com_store_port's input pin
$17908666907710* Speicherwert


# com_concatenator_8's input pin
$17908668221433* Word 7


# com_maker_bit_8's input pin
$17957417956069* Bit 3


# com_level_output_switched's input pin
$17979647868788* Ausgang


# com_load_port's output pin
$17988237627670* Ausgang


# com_nand_word's name
$17989404583269* NAND


# com_store_port's input pin
$18001316449428* Adresse


# com_counter's name
$18007194288764* Zähler


# com_splitter_word_8's name
$18008204445107* Trenner


# com_add's input pin
$18009367936916* Eingang 1


# com_div's input pin
$18043895181775* Dividend


# com_maker_bit_2's output pin
$18060429242565* Ergebnis


# com_probe_wire_asm's late input pin
$18082830776248* Adresse


# com_not_word's input pin
$18100827224098* Eingang


# com_and_word's input pin
$18149321315676* Eingang 1


# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* E/A


# com_keyboard's input pin
$18168295822085* Event ausgeben


# com_store_port's input pin
$18196820862263* Aktivieren


# com_delay_line_bit's description
$18206009264853* Speichert den Eingang für 1 Taktzyklus


# com_decoder_3's output pin
$18208851966397* Bit 3


# com_decoder_1's name
$18250587600120* 1-Bit Dekoder


# com_level_output_2_pin's input pin
$18282543476901* Ausgang 0


# com_level_output_4_pin's description
$18308856504509* 4-Bit Ausgang


# com_level_output_switched's description
$18319747827404* Schaltbarer Ausgang


# com_level_output_1_pin's description
$18342586404936* 1-Bit Ausgang


# com_maker_word_2's input pin
$18365137610205* Wort 0


# com_neg's name
$18379907297327* Negieren


# com_load_port's input pin
$18399493738021* Aktivieren


# com_register_bit's late input pin
$18405644304073* Neuer Wert


# com_full_adder's output pin
$18410639135888* Übertrag raus


# com_concatenator_2's input pin
$18414950181373* Kabel 1


# com_splitter_word_8's output pin
$18425501753807* Wort 0


# com_add's description
$18429814030509* Addiert zwei Zahlen


# com_splitter_bit_8's output pin
$18437214963047* Bit 7


# com_delay_line_word_config's description
$18447417990806* Speichert den Eingang für 1 Taktzyklus


# com_full_adder's input pin
$18480011054605* Übertrag


# com_probe_memory_word's name
$18495107507052* Speichersonde


# com_time's output pin
$18510923212418* Nanosekunden seit 01.01.1970


# com_maker_bit_4's output pin
$18538545767544* Ergebnis


# com_splitter_word_8's output pin
$18541722201520* Word 2


# com_asr's input pin
$18563543025377* Wert


# com_splitter_bit_2's description
$18566798809283* Trennt einen 2-Bit Wert in 2 Bits


# com_register_word_config's late input pin
$18592599175225* Neuer Wert


# com_or_word's output pin
$18599325743999* Ergebnis


# com_nand_word's output pin
$18604301487974* Ergebnis


# com_mul's description
$18631919890554* Multipliziert 2 Zahlen


# com_less_u's description
$18645721548287* Prüft, ob der erste Eingang kleiner ist, als der zweite


# com_maker_word_8's input pin
$18747558269936* Word 7


# com_maker_bit_8's name
$18747779812970* Sammler


# com_time's description
$18774996925434* Nanosekunden seit 01.01.1970


# com_maker_bit_4's description
$18837875001662* Sammelt 4 Bits zu einem 4-Bit Wert


# com_clz's description
$18865460617183* Zählt 0en vom MSb, bis zur ersten 1


# com_and_bit's name
$18912167455465* AND


# com_concatenator_4's input pin
$18970466583796* Word 2


# com_decoder_3's output pin
$19041825668970* Bit 0


# com_level_output_counter's description
$19047791955795* 3-Bit Ausgang


# com_maker_word_8's input pin
$19068496076705* Word 2


# com_load_port's input pin
$19069820293504* Adresse


# com_concatenator_8's input pin
$19112189486457* Word 6


# com_lsl's input pin
$19120200575252* Schieben


# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* Sonden


# com_level_input_4_pin's description
$19187328896214* 4-Bit Eingang


# com_register_word_config's description
$19209488297941* Register mit automatischer Bit-Breite


# com_maker_bit_8's input pin
$19209724501083* Bit 2


# com_ctz's name
$19218324472471* Zähle anhängende Nullen


# com_splitter_word_8's output pin
$19229992367375* Word 5


# com_div's description
$19251828025705* Dividiert 2 Zahlen


# com_decoder_2's output pin
$19275565166747* Bit 0


# com_verilog_output's input pin
$19276197821142* Eingang


# com_concatenator_4's input pin
$19277763516215* Word 3


# com_xnor_word's input pin
$19329533997829* Eingang 0


# com_nor_word's input pin
$19354802063529* Eingang 1


# com_equal's name
$19369982838671* Gleichwertig


# com_lsr's description
$19394421220436* Schiebt die Bits des Eingangs nach rechts


# com_div's output pin
$19403575811053* Ergebnis


# com_or_word's description
$19406015796751* Bitweises OR von zwei Werten


# com_delay_line_word_config's name
$19421095581293* Auto Verzögerung


# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* Mathe


# com_level_output_switched's name
$19513138880387* Schaltbarer Ausgang


# com_probe_wire_bit's name
$19521764791439* Kabelsonde (Bit)


# com_maker_word_8's input pin
$19579002124406* Word 4


# com_inc's input pin
$19579388993928* Eingang


# com_xnor_word's input pin
$19579585753615* Eingang 1


# com_or_3_bit's name
$19630419947500* 3-Pin OR


# com_splitter_word_2's input pin
$19630801846451* Eingang


# com_and_3_bit's name
$19664974941910* 3 Pin AND Gatter


# com_register_word_config's late input pin
$19717901345023* Speichern


# com_xor_word's input pin
$19719622211817* Eingang 1


# com_maker_word_8's input pin
$19740232065347* Wort 0


# com_lsr's output pin
$19748092068880* Ergebnis


# com_maker_word_8's input pin
$19779691531031* Word 5


# com_verilog_input's name
$19796166910463* Verilog Eingang


# com_static_indexer's name
$19804933576629* Statischer Indexer


# com_ram's description
$19814732518166* Große Speicher Komponente


# com_cc_level_input's description
$19864966939331* Eingang, der zu benutzerdefinierten Eingang wird, wenn Lösung als Komponente gespeichert wird


# com_ctz's output pin
$19883191600386* Ergebnis


# com_splitter_word_8's output pin
$19903808503639* Word 1


# com_rol's output pin
$19903955254861* Ergebnis


# com_screen's description
$19974317694842* Konfigurierbarer Bildschirm


# com_push_button's name
$20020953885936* Taster


# com_level_output_3_pin's input pin
$21084166025569* Ausgang 1


# com_level_input_word's output pin
$21448308897245* Eingang


# com_level_input_2_pin's output pin
$24473197268827* Eingang 0


# com_probe_wire_asm's description
$27381538627533* Zerlegt einen Eingang gemäß ISA Spezifikation der Architektur


# com_level_output_word's input pin
$27680966493404* Ausgang


# com_level_output_4_pin's input pin
$29217965518477* Ausgang 1


# com_static_eval's output pin
$29937009351190* Ergebnis als Größe


# com_level_input_4_pin's output pin
$36196915566111* Eingang 3


# com_level_output_8_pin's input pin
$38015555977208* Ausgang 3


# com_level_output_4_pin's input pin
$39260627694444* Ausgang 3


# com_level_output_8_pin's input pin
$39299381405096* Ausgang 0


# com_level_output_3_pin's input pin
$39908016538045* Ausgang 0


# com_delay_line_word's output pin
$40182352594863* Ergebnis


# com_level_output_8_pin's description
$41781588125341* 4-Bit Ausgang


# com_level_input_3_pin's output pin
$42291627335021* Eingang 2


# com_delay_line_bit's late input pin
$43397945955203* Eingang


# com_level_output_2_pin's input pin
$44555908976270* Ausgang 1


# com_level_input_4_pin's output pin
$45891070331034* Eingang 1


# com_level_output_1_pin's input pin
$50802766489958* Ausgang


# com_probe_wire_asm's name
$53494192640542* Zerlegesonde


# com_delay_line_word's description
$53901484249817* Speichert den Eingang für 1 Taktzyklus


# com_screen's input pin
$55023356915123* Einstellung


# com_level_input_2_pin's output pin
$55925432534232* Eingang 1


# com_push_button's description
$57617462098732* Liefert [T], wenn der Taster zu Beginn des Taktzyklus gedrückt ist


# com_register_word's output pin
$58518173140953* Gespeicherter Wert


# com_cc_level_input's output pin
$59388037506003* Eingang


# com_decoder_3's description
$61176454433312* 8 Bit Auswahl mit 3-Bit Eingang


# com_level_output_8_pin's input pin
$62385154489080* Ausgang 2


# com_screen's input pin
$63216408139965* Aktivieren


# com_level_delay_gate's description
$64425234668581* Für die Erstellung von Leveln. Hat einen Extra-Pin der die beste Laufzeit des Levels ausgibt.


# com_level_output_8_pin's input pin
$64999131838438* Ausgang 4


# com_level_input_3_pin's output pin
$65765566466116* Eingang 0


# com_level_input_switched's output pin
$69212597107829* Eingang


# com_level_input_4_pin's output pin
$70142958857584* Eingang 2


# com_level_output_8_pin's input pin
$72375982885383* Ausgang 1


# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* Auto


# com_level_input_3_pin's output pin
$79311371309532* Eingang 1


# com_level_input_4_pin's output pin
$81933801309767* Eingang 0


# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* Divers


# com_level_output_counter's input pin
$84023157447564* Ausgang 0


# com_register_word_config's output pin
$84598344098990* Gespeicherter Wert


# com_static_indexer_config's description
$85065774878853* Fortgeschrittene Version des "Statischen Indexer". Schiebe-Wert und Breite des Ausgangs wird von der Breite der eingehenden Kabel abgeleitet.


# com_level_output_counter's input pin
$86331851878040* Ausgang 1


# com_decoder_2's description
$86848277190736* 4 Bit Auswahl mit 2-Bit Eingang

$87754378235471* Ausgang


# com_level_output_4_pin's input pin
$87954408093587* Ausgang 2


# com_screen's input pin
$88137790657923* Wert


# com_level_output_8_pin's input pin
$88250281919265* Ausgang 5


# com_static_eval's output pin
$89594489498667* Ergebnis als Wert


# com_level_output_counter's input pin
$89669851602178* Ausgang 2


# com_level_output_8_pin's input pin
$90233476470983* Ausgang 7



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

$12097260550100* Wert {num} außerhalb des Bereichs für {field}

$15585581119466* Befehl '{instruction_name}' fehlt die Bit Feld-Definition

$15728875852508* Fehler beim Parsen der Datei {file}

$18981788561705* Erwartet ein Leerzeichen

$19131785861372* Rekursives Einbinden von:

$19581803133960* Erwartet '{syntax}' nach '{partial_instruction}'

$21828993759952* Unbekannter Befehl

$23413102374088* Ungültiger Befehl

$30066682696902* Assert {source} passt nicht zusammen

$33085034295813* Erwartet eine Zahl oder ein Symbol

$35071857261934* Erwartet ein Freizeichen nach 'as'

$35210741057769* Kann Zeile nicht verstehen

$37770431994640* Ungültiger Befehl

$39195841380612* Label {name} ist bereits deklariert

$42442531119863* {constant_name} ist bereits deklariert

$45433710484419* Erwartet eine Größenangabe vor der Zahl, wie: U64 {number}

$47300717145684* Fehlendes '=' nach 'const'

$48895355188042* Erwarte eine Zahl nach '@'

$51460031660101* Kann den Befehl nicht zusammensetzen bei der Auflösung von Label {name}: {err}

$51466436379956* Kann nur nach vorne auffüllen, aktuelle Adresse ist bei: {address}

$53378617686677* Wert {num} außerhalb des Bereichs für {field}

$57794055991905* Fehler bei der Auswertung von Assert {assertion}: {err}

$58979769991732* Erwartet Zeilenumbruch nach 'include'

$59248806788382* Kann privates Label {name} nicht referenzieren

$60515742509356* Erwartet eine Zahl nach einer Größenangabe

$60631582636278* Undefiniertes Label {name}

$62050046600010* Der Dateiname {name} kann nicht als Referenz-Alias verwendet werden. Deklariere einen anderen Alias mit dem Schlüsselwort 'as', z.B. 'include .A as A'

$66273157704409* Fehlender '{field_type}' Operand

$66575346967082* Datei exsistiert nicht: 

$67922577781529* Nur positive Vielfache von 8 Bits werden derzeit unterstützt

$68530592279217* Erwartet validen Operand-Name. Bekommt '{operand_name}' und schaut in {all_operand_names}

$69537550553443* Erwartet Freizeichen nach '{partial_instruction}'

$71714150108621* Fehler beim Auswerten des Operands %{operand_name}: {err}

$76017808702292* Breite des Befehls '{instruction_name}' ist {width} Bits. Es werden nur Vielfache von 8 unterstützt.

$79977943868423* '{field_string}' ist kein '{field_type}'

$80097289956044* Erwartet Freizeichen zwischen Größenangabe und Zahl, wie etwa U{size} {number}

$82512572175623* Unerwartetes Ende des Befehls nach {partial_instruction}

$83023561541280* Erwartet einen Label-Name

$83649060120708* Zahlen mit Vorzeichen werden nicht unterstützt

$84557608492963* Unbekannter Code nach Befehl:

$86607635528717* Undefinierte Konstante {field_string}

$87525828760679* Fehler beim Auflösen von pattern({err}): {resolved_pattern}

$90294506138532* Definierter Wert muss entweder Zahl oder Feld sein



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

$14037712136328* Operand {op} nicht gefunden

$15525193700799* Unbekannter Prefix Operator 

$16677833364088* Unbekannter Bezeichner: %{operand}

$17795651801484* Erwartet ':'

$18996202754936* Erwartet ')'

$21791372106633* Erwartet '('

$36919792698704* Befehlszeiger nicht verfügbar

$49919016022369* Unbekannte Adresse: ${identifier}

$50863314907270* Erwartet ')'

$62520916869207* Erwartet ','

$76203559781109* Erwartet ']' or ':', bekommt aber '{sep}'

$86940018019179* Ungültiger Bezeichner: %{operand}



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

$11703098452145* Unbekannter settings Name {name}

$11824708197936* Erwarte gültigen field/pattern Name, aktuell '{operand_name}'

$15904571494199* Erwarte slice Syntax nach field/pattern Referenz im Bitmuster

$16564670893367* Erwarte Name eines pattern

$18247681204565* Erwarte ')' nach assert

$18304638469397* Erwarte nicht-leeren string, um Zeilenkommentar zu starten

$19678805612580* Wiederholte field Referenzen stimmen nicht überein

$20574862674671* Erwarte neue Zeile nach virtuellem field

$20981379307111* Feste Bits in %{operand} stimmen nicht überein

$23037984432484* Erwarte ':' nach 'when'-Bedingung

$24713798894610* Erwarte keine Überschreitung der Obergrenze von 32767

$25123045290962* Erwarte hier [instructions] header

$25249187420360* Erwarte Name einer Option oder Beginn eines neuen Abschnitts

$25285447732570* Erwarte Obergrenze größer gleich Untergrenze

$26426549472884* Zu viele virtuelle Operanden

$27111936748508* Erwarte schließende Klammer nach pattern Typ

$28197258085607* Erwarte slice Syntax nach field/pattern Referenz in Bitmuster

$29837913233106* Erwarte neue Zeile zwischen Befehlen

$31223930569837* Erwarte Obergrenze größer gleich Untergrenze

$32763965727763* Vorzeichen-Bits stimmen nicht überein

$33105996916812* Patterns können nur solche ausführen, die vorher definiert wurden

$33504435568130* Kann virtuellen Operand %{variable_name} nicht verstehen: {err}

$33645913580119* Zu viele field types, maximal {max_field_types} erlaubt

$33890983338825* Erwarte Liste von strings

$35053289858864* Zu viele pattern, maximal {max_patterns} erlaubt

$35468867558322* Erwarte neue Zeile nach section header

$39427635035157* Doppelte setting '{name}'

$40392382190976* Erwarte Bitmuster für pattern {field_name}

$40815956642962* Erwarte slice Syntax nach Referenz einer Zahl auf Basis-16 in Bitmuster

$42160516340132* Erwarte entweder (' oder '[' nach Operanden Name, wie: {variable_name}(immediate), {variable_name}[pattern()]

$42907704133778* Erwarte ')' nach Muster-Parameterliste.

$43708359021513* Muster braucht einen Rumpf.

$45247724910259* Operand außerhalb des Bereichs von unsigned {n}-bit

$45267257140327* Erwarte neue Zeile nach section header

$45631078896174* Erwarte keine Überschreitung der Obergrenze von 32767

$47258389995911* Erwarte ',' zwischen pattern Parametern

$48321097736953* Erwarte keine Überschreitung der Ziffernanzahl von 32767 bei Hex-Zahl

$48639756889210* Breite des Befehls darf nicht 0 sein.

$48942522553057* Erwarte slice Syntax nach field/pattern Referenz in Bitmuster

$50971737349470* Pattern Operand wird für disassembly noch nicht unterstützt

$51752498682665* Field Name '{field_name}' ist nicht definiert

$52261961290701* Gedrehte slice Syntax nach Referenz einer Zahl auf Basis-16 in Bitmuster 

$52710717731997* Erwarte neue Zeile nach Syntax Deklaration

$55289908013299* Virtueller Operand {variable_name} überschattet einen anderen Operand in Syntax Zeile

$55444523984237* Erwarte schließende Klammer nach field type

$55537815420873* Erwarte ',' oder ')' nach pattern Argument

$55929094649794* Erwarte eine Tabelle von strings

$56352157276583* Operand außerhalb des Bereichs von signed {n}-bit 

$57773886232356* Erwarte Name für field type

$58295598661589* Beschreibungen in pattern müssen leer bleiben

$59115040206693* Erwarte nicht-leeren string um Block-Kommentar zu starten

$59388744207582* Erwarte neue Zeile am Ende des Bitmusters

$59877879891546* Kann Ausdruck für 'when'-Bedingung nicht verstehen: {err}

$61352853872444* Nur immediates mit Breite 0 bis {max_field_size} sind erlaubt

$61772889138477* Erwarte '(' vor pattern Parameter-Liste

$62103010038950* Erwarte neue Zeile nach section header

$62334191081955* Erwarte slice Syntax nach Referenz einer Zahl auf Basis-16 in Bitmuster

$62712568576067* Doppelter field type Name: {name}

$63072912015761* Erwarte neue Zeile vor pattern body

$63246722572594* Erwarte slice Syntax nach field Referenz in Bitmuster

$63957561177031* Pattern '{pattern_name}' mit {argument_count} Parametern ist nicht definiert

$64093416909416* Erwarte einen Kenner nach '%'

$67219559926029* Field Namen dürfen keine Leerzeichen enthalten

$67707174963301* Erwarte einen Kenner nach '%'

$68066163358870* Erwarte Leerzeichen nach 'when' 

$68533544457789* Operand {variable_name} überschattet einen anderen Operand in Syntax Zeile

$68587613470552* Erwarte Namen eines field Werts

$70205284263092* Erwarte einen nicht-leeren string um Block-Kommentar abzuschließen

$70814401439344* Erwarte Obergrenze größer gleich Untergrenze

$72400465574342* Nut field Längen von bis zu {max_field_width}-Bit werden unterstützt

$72620639818015* Erwarte neue Zeile nach section header

$72958581072457* Erwarte Namen für das pattern

$73627734748417* Erwarte Schlüsselwort 'pattern' vor dem Namen des pattern

$75146029145419* Erwarte Namen für pattern Parameter

$76494975412451* Erwarte gültigen Operand Namen, suche '{operand_name}' in {all_operand_names}

$77234329031993* Erwarte slice Syntax nach field/pattern Referenz in Bitmuster

$77449878176461* Erwarte Kenner nach '%'

$77851254343918* Kein Operand beginnt mit {c}'

$78591996283483* Erwarte field Name oder immediate mit definierter Größe

$79195048703101* Erwarte '=' hier

$79975911393070* Erwarte slice Syntax nach field/pattern Referenz in Bitmuster

$81691406697268* Erwarte Obergrenze in slice Syntax nach field Referenz in Bitmuster

$82876816015252* Zu viele Auflösungs-Wege für Operand für automatisches disassembly, maximal {num_path} erlaubt

$83804207975330* Erwarte keine Überschreitung der Obergrenze von 32767

$85972591916322* Erwarte neue Zeile nach setting Zuweisung

$87843223218582* Die Breite des Befehls ist {width} Bits, es werden aber nur Vielfache von 8 unterstützt

$90809893168338* Immediate Operand braucht eine Größenbeschränkung, z.B. %a:U8(immediate)



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

$10198498286711* Unabgeschlossene escape Sequenz

$11064758781325* Erwarte '"', ''', oder '`' zu Beginn eines UI Tabellen Zellwerts

$12492443144951* Erwarte ',' oder Ende der Tabelle

$13040813748160* Erwarte einen key

$19807940646400* Erwarte einen von {expected}, bekomme {actual}

$22378976352410* Zeile {num}: 

$22452670489981* Erwarte ein Zahlen-Zeichen

$25983481845150* Erwarte '{symbol}', bekomme end-of-file

$27682737127628* Erwarte öffnendes Anführungszeichen (eins von ", ' oder `)

$29112746104375* Erwarte einen booleschen Wert hier

$33400766069212* Erwarte eine öffnende Klammer (eine von '(', '[' oder '{{'), bekomme '{open}'

$33551107641907* Int Literal zu groß

$36313699368590* Ungültige oktale escape Sequenz

$43326454052643* Erwarte ein U für unsigned oder S für signed hier

$44942745729831* Ungültige hex escape Sequenz

$49180229055343* Erwarte einen Wert

$51855228989260* Ungültiges unsigned int Literal

$56457570130031* Ungültiges escape Zeichen '{nc}'

$64743950507593* Erwarte einen Listen Wert

$64926004981217* Ungültiges int Literal

$66187706284192* Erwarte ':' nach dem key

$71666516845083* Erwarte ein unsigned number Literal

$72110029133381* Erwarte {prefix}

$73113688099439* Erwarte eines aus {expected}

$73973243772156* Erwarte ein signed number Literal

$75565287060042* Unerwartetes end-of-file beim Parsen des string

$77089554485217* Erwarte eine Größen Deklaration hier

$82386938622647* Erwarte ein Zeichen nach dem escape Zeichen '\\'



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

$12246885387560* variable {name}


# Assembly label
$17885987456433* label

$18299156828551* signed {n}-bit immediate

$74639900282369* unsigned {n}-bit immediate



=== model/translations.nim ===

$11567406591202* 1 Byte

$14036822471924* vor {days} Tagen

$16391754618645* {size} KB

$17901039729248* vor {months} Monaten

$18300496139706* vor 1 Monat

$18683857303458* {size} Bytes

$21685594109067* gerade jetzt


# Million
$22896492410578* Mio

$42553566189409* vor {minutes} Minuten

$70945526841433* vor {years} Jahren


# Billion
$71072134093858* Mrd

$84076931764831* vor 1 Tag


# Thousand
$84696693690500* K

$86244493049244* vor {hours} Stunden

$95018143828198* vor 1 Jahr

$98363990684104* vor 1 Stunde

$98703677236827* vor 1 Minute



=== presenter/board_ui.nim ===

$36331525379247* Speichere diesen Schaltplan



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

$55369640789869* Klicke irgendwo auf das Spielfeld, um ein Kabel zu ziehen\nMit der rechten Maustaste kannst du gezogene Kabel wieder löschen\nVerbinde die beiden roten Komponenten mit dem NAND Gatter

$79416009887091* Klicke irgendwo auf das Spielfeld, um das Gatter zu platzieren

$86840165316981* Mit der rechten Maustaste kannst du die Gatter-Auswahl aufheben



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

$13880985462901* Baue einen Schaltkeis, bei dem der Eingang einer Komponente von ihrem eigenen Ausgang abhängt

$16336401898647* Test 1/2

$22446480186064* Baue eine Kreisabhängigkeit, die aus mindestens 2 Komponenten besteht

$32314337981189* Prüfen

$73467991035922* Eher nicht!

$89309211963063* Test 2/2



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

$10634456248075* Eingang 1

$10792411581963* {size} MB

$10967837475411* Eingang 1

$12673774208656* Bit 1

$12729457392140* {size} GB

$12806857886815* Bit 0

$12955769263032* Eingang

$13973719570693* Größe

$14527438551030* Eingang

$14913356525578* Kosten

$16406822661708* Eingang

$17231618567710* Datenquelle

$18430168550669* Ergebnis

$23494294864855* Min {unit}

$23854618911893* Simulierte Laufzeit

$24632471752785* Datei

$26116781897961* Kosten

$27295540163510* Eingang 1

$30447216087962* Schieben

$31208530565026* Eingang 0

$32492998000365* Eingang 0


# com_static_eval's expression
$32721727081818* Ausdruck

$34792822299047* Eingang 1

$36741466396909* Eingang 2

$39848783424235* Eingang

$40353371905977* Konstante


# Load a level
$41294322771286* Laden

$45584048068675* Eingang 1

$47647445869837* Nullen

$48920514303805* Werkstatt

$49848147518867* Eingang 2

$50011261574308* Eingang 1

$50488075986026* Ausgang

$52764622766005* Ausgang

$53201813578269* Assembler

$55717355371460* Ausgang

$56555605872372* Ausgang

$58366024847549* Eingang 0

$58805963760936* Positiv → , Negativ ←

$59987930153159* Ausgang

$60193172250813* Die Einstellungen, die du für diese Komponente gewählt hast, benötigen {size} Speichersplatz auf deinem Computer. Ist das okay?

$61114700325299* Eingang 0

$64034551286307* Persistent

$64695289448271* Jedes der 8 Bits des Wertes aktiviert jeweils 1 der 8 Bereiche der Anzeige.

$65186041856822* Ausgang

$65254105186908* Ausgang

$65365515206856* Hinweis: Obwohl viele Tasten-Events gespeichert werden, wird pro Taktzyklus immer nur 1 ausgegeben!

$69729205667293* Hex-Editor

$70002762618597* Unten

$71918065858983* Speichern

$75293122338496* Pipeline Tiefe

$76078010638637* Aktivieren

$76120552154698* Eingang 0

$76125262162505* Eingang 1

$77252050278971* Ausgang

$78475032277779* Eingang 0

$80252365204151* Lochkarte

$81678588906692* Halte-Nachricht

$82521178851608* Eingang 0

$84542005958715* Beschriftung

$85815999713437* Eingang 1

$86658255589213* Veränderliche Daten

$88655619989708* Eingang 0

$88881918807029* Unveränderbar

$89612128414294* Bezeichnungsrichtung

$90286330794518* Ausgang

$91063734228931* Links

$95419083709418* Little Endian

$95766090310621* Rechts

$97169317610794* Oben



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

$24027424800887* Weiter geht's

$70403032472607* Akzeptabel. Nächster Test.



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

$32982011047799* Passt so

$43078933051174* Klicke auf die grauen Symbole und finde den richtigen Ausgabewert

$61241226128494* Nee :(

$71204033550134* Was macht das NAND Gatter?



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

$95509904060545* Passt so



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

$21618236951146* Lösung anzeigen

$65770257567603* Bist du sicher, dass du die vollständige Lösung anzeigen möchtest?



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

$10446152707984* Adresse

$20074247151096* Befehl

$41540713506719* Befehl

$64281970848639* Beschreibung



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

$10463931654475* Eingang 0

$14057674753878* Eingang 1

$58374689721038* BYTES

$73841752788709* Eingang

$74796974148718* Ausgang



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

$70994998239232* Klicke auf das NAND Gatter, um es auszuwählen



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

$18403698792036* Leveltyp

$41662660252584* Cursor

$53456282160464* Sandkasten Modus

$72245209470436* FPS

$74564675939961* Taktfrequenz

$99534264629442* Test



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


# Placeholder on the name input field of the file explorer
$18871898542185* Neuer Ordner

$56429258960561* Umbenennen

$69090690657232* Kopie erstellen


# Load a schematic
$70369485875359* Laden


# Placeholder on the name input field of the file explorer
$84870575118100* Neue Datei

$91861509153454* Löschen



=== presenter/board_ui/function_icons.nim ===

$36396661222670* Rechtsklick um die Taktfrequenz zu erhöhen

$39440928972984* Zurücksetzen (Schnelltaste: F4)

$42454393978813* Alle Tests ausführen

$53448014080434* Löschen (Schnelltaste: Rechtsklick)

$54853798559740* Ausführen (Rechtsklick: Geschwindigkeit ändern)

$66405942066048* Zurück

$68617247634978* Bit Breite (Rchtsklick: Breite ändern)

$69987793052607* Kabelbeschriftung (Klicke auf ein Kabel)

$78287906849040* Kabelfarbe

$80451578314373* Zoom rein

$80746616574054* Nächster Taktzyklus (Schnelltaste: F5)

$84434122873489* Zoom raus

$85147529532131* Mehrfachauswahl (Schnelltaste: UMSCHALT & ziehen)



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


# MEMORY section title on the left panel
$13690653984793* Ausgänge


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


# INPUTS section title on the left panel
$64033841051521* Eingänge



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

$11731996208080* Werkstatt

$30516879701896* Sandkasten

$33761197388580* Hinweise anzeigen

$38557550573896* Aufgabe

$50924073287410* Zahlenformat

$56916384895438* Hauptmenü

$71951682957395* Levelübersicht

$79554853897000* Schaltplan wechseln

$85248932172256* Hinweise schließen

$85430022417382* Zeige Laufzeit

$91515053618360* Handbuch

$98930461722118* Zurück



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

$68227209887733* Werkstatt


# Placeholder for the search bar in the level tree
$72813322690589* Suche



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


# OK button on popups
$26766209496460* Ok

$36265530817755* Zu Adresse springen

$40263691211335* Versatz in Bytes (16, 0xF, ...)



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

$37885763626223* RAM verbinden

$51331074553774* Wie viele Register

$67225915898937* Prefix

$67275059688693* Größe

$77103446544344* Beispiel: reg_

$77741358519166* Zählen



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

$19062117579269* Ausführen bis Taktzyklus: 



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

$16026817441460* Taktzyklen pro Sekunde



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

$52150443679969* Weiter

$89787506720574* Schließen



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

$10090938799865* [large]Handbuch Eintrag[/large]\nEintrag: [color=#68d277]{page}[/color]

$14047403461014* Energie (Gatter x Zeit)

$16820079067437* Level Abgeschlossen

$20801641140962*
[b]Levelübersicht[/b]
[color=#cccccc]Klicke "[color=#e49f44]Weiter[/color]", dann siehst du's[/color]

$26794262854382* Verwerfen

$30368115829346* Schlechtester Taktzyklus

$32133561664335* Beide behalten

$33922330743421*
[b]Kabelfarbe[/b]
[color=#cccccc]Halte deine Kabel übersichtlich durch Farben.[/color]

$40510295620397* Überschreiben

$41649402437253*

[b]Negative Zahlen[/b]
[color=#cccccc]Schalte zwischen vorzeichenbehafteten 
und vorzeichenlosen Zahlen[/color]

$43591599177045* Energie (Gatter x Laufzeit)

$44038153424304* Es gibt schon einen gespeicherten Schaltplan mit Namen "{save}"

$45250062735373* Freischaltungen

$51096427131653* Weiter

$53037516781370* Speicherkonflikt:

$53389567901907* Eine eigene Komponente "{comp}" existiert bereits


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$58769207148712* Komponente

$65428404547905* Ergebnis


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$66101029228279* Programmierung


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$69219742310717* Architektur

$69511102367948* Typ

$72987046679863* Zeit (Laufzeit x Taktzyklen)

$76805548224716* RAM ist zu groß! Die Lösung wird nicht vom Server bewertet.

$78783902500954*
[b]Online Profil[/b]
[color=#cccccc]Neuer Menüpunkt im Hauptmenü[/color]

$84923734370936* Schlechtester Test


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$90134890578411* Verschiedenes

$92313038380926* Level

$92673421413755*

[b]Kabel Kommentare[/b]
[color=#cccccc]Kommentare zu deinen Kabeln hinzufügen.[/color]

$94261690850981*

[b]Hexadezimal[/b]
[color=#cccccc]Schalte zwischen vorzeichenbehafteten, vorzeichenlosen und Hexadezimalen Zahlen[/color]



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


# IDE tab name
$11106925604855* Dateien

$11967666262990* Fehler in Spezifikation! Öffne den Spezifikations Editor, um ihn zu beheben

$13400106910274* Zeile {nr}: {msg}


# IDE tab name
$88520918982355* Register



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

$63693638857058* Darin enthalten sind {folders} Ordner.

$66107456188362* Darin enthalten sind {folders} Ordner und {asm} .asm Dateien.

$86093358515620* Es ist ein leerer Ordner.

$93027749509988* Es enthält {asm} .asm Datei(en).



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

$84832818424728* Dateien



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

$12944436882589* Register hinzufügen



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

$10141348037745* Direkt: {nr}

$10366913897135* Klicke, um die Bits umzuschalten

$14831276667273* Befehle


# The text above the 3 LSBs
$25145891843959* Immer

$26521666422399* Rechne

$31185395052385* AUSGANG


# The text above the 3 LSBs
$39935096343723* Niemals

$41846451178700* Bewege nach {to} von {from}

$43723329256095* REG {nr}

$53665446068319* UNGENUTZT

$54909668901048* Direkt

$67413863640193* Bewege niemals [color=#DD6576][bold]REG 0[/bold][/color] zum Zähler

$81322935207536* EINGANG

$89294533225655* {operation} [color=#DD6576][bold]REG 1[/bold][/color] und [color=#DD6576][bold]REG 2[/bold][/color]

$89662716409733* Bewege immer [color=#DD6576][bold]REG 0[/bold][/color] zum Zähler

$92046368194170* Bedingung

$98983752580592* Bewege



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

$14436541903929* Architekturen: {list}

$17985924005596* Enthält {nr} Architekturen.

$38011567415872* Der Ordner ist leer.

$51791491383290* Die eigene Komponente wird benutzt in

$57790786178566* Eigene Komponenten: {list}

$66392158413243* Bist du dir sicher das du "{file_name}" löschen willst?

$68586106474430* Hinweis: Alle Architektur Level teilen sich die Schaltpläne, also wird es überall gelöscht!

$89354977462546* Nein



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

$15827374884671* Übergeordnetes Verzeichnis

$19184997172542* Verwendet in Architekturen

$23950941073542* Name

$32598300339944* <Als neuen Schaltplan teilen>

$32645745463577* Verwendet in Komponenten

$34084132835354* Sichtbar im Menü

$36200352866864* Letzte Änderung

$38755675398147* WOR verwenden

$54460367152653* Teilen

$62604042376934* Verilog Export

$74184088067843* Auswählen

$84344684205464* Pfad

$87138477300432* BBCodes [image]&[link] sind deaktiviert

$87579936985765* Verwendung von [link=`CC0`]CC0[/link] Lizenz zustimmen

$95386916091656* Beschreibung



=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* Breite so wie Eingang

$61685569269160* Automatisch

$70256730895162* Bit Breite



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

$36027984716180* Kabelbeschriftung



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

$11176073682097* Was ist {number} in binär?

$13872783467999* Was ist {number} in binär?

$19099025738142* Start

$23959994711260* Bereit für's Rennen?

$37093663674348* Level {x}

$41793938939207* Zeit abgelaufen (kann in den Optionen deaktiviert werden)

$45532697833519* Du hast Level {level} erreicht!

$56999237564848* Noch {x} Sekunden

$92057009138253* Was ist {number} in binär?



=== presenter/console.nim ===

$63321577947087* Enter öffnet das Handbuch



=== presenter/level_tree_ui.nim ===

$19508086025944* PROGRAMMIEREN 2

$26276191141664* Bewegen

$35696974632265* Levelübersicht Farben

$38100016313511* CPU ARCHITEKTUR 2

$38843517090942* FUNKTIONSFÄHIGER COMPUTER

$44937904689376* PROGRAMMIEREN

$51337598329530* ARITHMETIK

$55841332003989* LAUFZEIT VERBESSERN ZUM PASSIEREN

$65362728703588* SPEICHER

$75049509201775* BOOLESCHE ALGEBRA

$81337533438394* Abgeschlossen

$81707212583931* Verfügbar

$87420015169370* EXTRA KOMPONENTEN

$95146987030704* Verschlossen

$95559333192525* CPU ARCHITEKTUR



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

$15872341864658*

Besonderer Dank an:

[b]Übersetzer[/b]
{translators}

[b]Frühe Beta-Tester[/b]
{beta_testers}

[b]Schriftarten[/b]
{font_work}

[b]Symphony-Spiel[/b]
Ettapp

[b]Soundtrack[/b]
{soundtrack}

$21717110565858* Mitwirkende



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

$12639868461113* Schließen

$13921098180953* Online Schaltpläne

$15234594767991* Mitwirkende

$16857608955464* Sandkasten

$32835651830157* Profil

$49251062339706* Optionen

$66967233942803* Spiele Kampagne



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


# The hub schematic size
$15762392983604* Größe:

$22639280459994* Lade Liste herunter...

$44524092309946* Lädt...


# To download hub schematics
$55983490912314* Laden

$61693098943939* Weiter


# To delete hub schematics
$62589392744014* Löschen


# To confirm deleting hub schematics
$66333328482057* Bist du sicher?


# The hub author
$71812400203030* Von:

$76747661573536* Ja

$76770986264566* Suche

$84668607423763* Für den Download muss die Begrenzung der Pfadlänge unter Windows deaktiviert werden. Es kommt gleich ein Popup-Fenster, wo du das deaktivieren kannst. Die Begrenzung der Pfadlänge ist eine veraltete Einstellung unter Windows und es gibt keinen Grund, sie aktiviert zu lassen.

$90731554079332* Keine Schaltpläne gefunden



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

$23829497228009* Typ

$25536941657464* Komponenten

$43488408276984* Beliebt

$56045953383535* Architekturen

$70134513915163* Neu hinzugefügt

$77788981567936* Level

$83319579232915* Sortieren nach

$87115430626073* Meine Uploads



=== presenter/main_menu_ui/options/control_tab.nim ===

$13231048881956* Taktzyklus zurücksetzen

$15032124477918* Kabelfarbe 4

$20313704155593* Kabelfarbe 6

$21380256293472* Alles auswählen

$33884219481037* Rechts bewegen

$36372993787575* Kabelfarbe 1

$50610605761210* Wiederherstellen

$52159578521318* Einfügen

$53266310714298* Steuerung

$55156524671891* Kabelfarbe 5

$58334563411624* Rückgängig

$58442122157391* Kabelfarbe auftragen

$60118970740682* Ausführen

$64529333110609* Kabelfarbe 7

$66251711975517* Kabelfarbe 9

$67362258372706* Farbe auf Kabelmenge auftragen

$74309706297402* Kopieren

$76995246992803* Kabelfarbe 10

$77819900580235* Kabelfarbe 2

$78515694621006* Links bewegen

$78673220868687* Kabelfarbe 8

$78777350869870* Drücke neue Taste

$80031998727851* Hoch bewegen

$83373647697807* Kabelfarbe 3

$86574817679356* Nächster Taktzyklus

$87273391208106* Kabelfarbe 0

$88236351843942* Rotieren

$88238310953306* Ausschneiden

$93140495547084* Runter bewegen

$96339976117958* Kabel-Pipette

$96449970906640* Kabelbeschriftung

$96601731563408* Konsole öffnen



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

$12034378482152* Zurücksetzen bestätigen

$13442839894535* Geschwindigkeit der Kabelanimation

$15557473522933* Zurücksetzen

$21908594290225* Allgemein

$23270083417453* Abbrechen

$24145565754506* Effektlautstärke

$30910326565868* Sprache

$49806848871093* Farbenblind Modus

$54328660964287* Fenstermodus

$55047615798435* Zeitlimits deaktivieren

$61172959716558* Speicherort

$67420270098223* Werkseinstellungen

$70994568832660* Alles löschen

$71208664264770*
Diese Aktion löscht alle Level-Lösungen, Eigene Komponenten und Architekturen.

Dieser Vorgang kann NICHT rückgängig gemacht werden.

Bist du sicher, dass du das tun willst?
Dadurch wird das Spiel geschlossen und beim nächsten Start zurückgesetzt.

$93981778736076* Musiklautstärke

$95307230990123* Verilog Modus



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

$36195388998735* Allgemein



=== presenter/markup/markup.nim ===

$66207112287034* TIPP



=== presenter/update_state_common.nim ===

$13327741293223* Eingang {nr}

$29169064199243* Ausgang {nr}

$39906291838542* Taktzyklus

$43118901497406* Laufzeit

$70170261551278* Energie

$95192766583497* Gatter



=== presenter/update_state_stream.nim ===

$12823129240050* Klicke Knopf oben links, um Bildschirm zu verbinden


# Text on keyboard component
$41639816417947* Nimmt auf bei Ausführung


# Text on keyboard component
$61909856780806* Zeichnet auf


# Text on keyboard component
$73297471730751* Zeichnet nicht auf



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

$10186190492148* ALT-Klick um Kabelpunkt zu bewegen

$22780831606716* Datei laden

$26085882338208* Lochkarte editieren

$38481453712356* Programm bearbeiten

$64854367750357* Hex-Editor öffnen

$80005228759908* Wert hier: 

$98772447663910* Verknüpfte Komponenten



=== presenter/utilities.nim ===


# Switched Output is the name under 19513138880387
$12249248261034* Um das Level zu lösen, musst du die Komponente 'Schaltbarer Ausgang' einbauen

$12256736989028* Du hast mehr als eine Sonde in einem Quadrat (Hintergrund beachten).

$14665712485657* Diese Eigene Komponente kann nicht verwendet werden, weil sie keine Fläche hat.

$15549447390000* 2 Eingangs-/Ausgangskomponenten befinden sich im gleichen Quadrat. Da sich somit 2 Pins überlagern würden, kann die Komponente nicht verwendet werden.

$18997072674417* <Komponente> ist in diesem Level nicht freigeschaltet.

$25337574230078* Zwei Pins sind auf dem selben Quadrat.

$27322222841583* Kurzschluss zwischen <> und <>

$29718660090112* Falsche Antwort

$32087108522443* Größen-bestimmende Pins dürfen nur mit anderen Größen-bestimmenden Pins verbunden werden.

$42649958199625* Die Levelübersicht wurde aktualisiert. Du musst erst woanders weiter machen: <level>.

$44947135063289* Kreisabhängigkeit - eine Komponente leitet ihren Ausgang zurück zum Eingang.

$45545544521085* Eine <Komponente> ist an einer ungültigen Position.

$45678915971282* Kurzschluss in der <Komponente>.

$47880883686501* Kreisabhängigkeit:\nDer Ausgang einer Komponente wird zurück auf ihren eigenen Eingang geleitet\nMehr dazu unter 'Kreisabhängigkeit' im Handbuch

$48909199348313* Tests bestanden, aber deine Lösung hat mehr als {max_delay} Laufzeit.

$51332486391182* Der Kritische Pfad ist innerhalb dieser <Eigenen Komponente>.

$51730362111148* <Diese Eigene Komponente> benutzt eine {name} Komponente, die in diesem Level nicht freigeschaltat ist.

$56798729463813* Level Code ist kaputt.

$73948669941805* Tests bestanden, aber deine Lösung benutzt mehr als {max_gates} Gatter.


# Switched Input is the name under 11278573510238
$95056157627313* Um das Level zu lösen, musst du die Komponente 'Schaltbarer Eingang' einbauen



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


# Fallback for component name on the left panel
$11467644007149* Zähler {nr}


# Fallback for component name on the left panel
$11980538317261* Speicher


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

$25272818268849*
[b]ZUSAMMENFASSUNG[/b]

Hoffentlich hast du bemerkt:
1. Jede Zahl hat ein eindeutiges Bitmuster in binär.
2. Jedes Bit ist immer doppelt so viel wert, wie das Bit davor.

$37319690622142* Sehr gut! Du hast Stufe {current_level} erreicht!


# Fallback for component name on the left panel
$41936481068702* Zähler


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


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

$87016829502381* Sehr gut! Du hast Stufe {current_level} erreicht!


# Fallback for component name on the left panel
$87591753278764* Reg {nr}

$97450409600317*
[b]ZUSAMMENGEFASST[/b]

1. Wechsel zwischen Negativ und Positiv: alle Bits drehen und 1 addieren.
2. Unser Addierer funktioniert auch mit negativen Zahlen.
3. Jede Zahl hat genau 1 binäre Darstellung.


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

