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


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

$78454657849319* IO Devices


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


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

$76434165550872*
[large]Modes d'écran[/large]
L'écran dispose de quatre modes qui modifient la manière dont les valeurs sont affichées:
0: ASCII 8
1: ASCII 32
2: Pixel 8
3: Pixel 32

De plus, chaque mode dispose de paramètres différents qui peuvent être modifiés en cours de fonctionnement via les broches d'entrée de l'écran.

[large]mode ASCII 8[/large]
Chaque octet est interprété comme un caractère sur un écran de 96 par 40 caractères. 

[b]Commandes:[/b]
0 Changer de mode
1 Définir le décalage des données(offset)
2 Définir la couleur de premier plan
3 Définir la couleur d'arrière-plan
4 Définir la police

[large]mode ASCII 32[/large]
Chaque groupe de 4 octets se compose d'un caractère, d'une couleur de premier plan, d'une couleur d'arrière-plan et d'un octet de remplissage.

Les couleurs 8 bits utilisent 3 bits pour le rouge, 3 bits pour le vert et 2 bits pour le bleu, comme ceci :
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

[b]Commandes:[/b]
0 Changer de mode
1 Définir le décalage des données(offset)

[large]Pixel 8[/large]
Chaque octet est interprété comme la couleur d'un pixel, avec 3 bits pour le rouge, 
3 bits pour le vert et 2 bits pour le bleu, comme ceci :
[b][color=#ff5555]RRR[/color][color=#55ff55]GGG[/color][color=#5555ff]BB[/color][/b]

Les résolutions en mode pixels présentent un rapport hauteur/largeur de 4:3, allant de 4×3 jusqu'à 1024×768.
La résolution est calculée en fonction du réglage, comme suit :
4 × (paramètre + 1) : 3 × (paramètre + 1)

[b]Commandes:[/b]
0 Changer de mode
1 Définir le décalage des données(offset)
2 Définir la résolution

[large]Pixel 32[/large]
Chaque groupe de 4 octets est interprété comme une couleur de pixel, avec un octet pour le rouge, le vert et le bleu, et un dernier octet de remplissage :
[b][color=#ff5555]RRRRRRRR[/color][color=#55ff55]GGGGGGGG[/color][color=#5555ff]BBBBBBBB[/color][/b]

Les résolutions en mode pixels présentent un rapport hauteur/largeur de 4:3, allant de 4×3 jusqu'à 1024×768.
La résolution est calculée en fonction du réglage, comme suit :
4 × (paramètre + 1) : 3 × (paramètre + 1)

[b]Commandes:[/b]
0 Changer de mode
1 Définir le décalage des données(offset)
2 Définir la résolution

[large]polices ASCII[/large]
Voici les polices ASCII :

[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/symphony_5_jumps/hint_solution.txt ===

$30888506574129* Les fils blancs implémentent le mode JUMP(Saut)



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

$29247683714165*
Jusqu'à présent, le mode IO ne comportait que 3 instructions, mais il est temps d'en ajouter plusieurs autres. Voici les codes d'opération pour la liste complète des instructions d'IO:
[left]
   0  nop       Ne rien faire
   1  in        Entrée
   2  out       Sortie
   3  keyboard  Lire la valeur du clavier
   4  screen    Définir les paramètres de l'écran
   5  time_0    Lire les 32 bits de poids faible du temps
   6  time_1    Lire les 32 bits de poids fort du temps
   7  counter   Lire la valeur du compteur
[/left]


L'écran peut interpréter les octets du composant RAM auquel il est lié de plusieurs manières (voir manuel).L'écran comporte les entrées "Activer", "Index du paramètre" et "Valeur", qui permettent d'interagir avec les registres internes de l'écran (également expliqués dans le manuel).
Lorsqu'une instruction d'écran est exécutée , le registre de l'écran fourni par l'argument A doit être défini sur la valeur de l'argument B (qui peut être une valeur immédiate ou provenir d'un registre).

Le composant de temp renvoie le temps en nanosecondes écoulées depuis le 1er janvier 1970 (l'époque Unix) sous forme d'un nombre de 64 bits. Cette architecture ne traitant que 32 bits, la valeur est divisée en deux parties pouvant être lues séparément. Cependant, la combinaison de ses valeurs temporelles provenant de deux cycles d'horloge distincts peut en réalité produire des valeurs futures ou passées, en raison de dépassements de capacité. Pour éviter ce problème, nous ne lisons le minuteur que lors de l'exécution de « time_0 » et stockons le résultat afin que « time_1 » puisse le lire ultérieurement. Cela signifie que « time_1 » doit être égal à 0 si « time_0 » n'a pas encore été exécuté.

Le compteur fait référence au composant personnalisé qui détermine le décalage à partir duquel l'assembleur est lu. Ceci devrait afficher le décalage actuel.

La valeur du clavier doit être une combinaison des broches de sortie « Touche enfoncée » et « Valeur de la touche », comme ceci:
D = Touche enfoncée
V = Valeur de la Touche
[highlight]0000000D VVVVVVVV[/highlight]



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

$81974422302188* Lire



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

$39851490511821* Mode Emplacement physique


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


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

$29435797471674*
[large]Aperçu[/large]
L'objectif d'un langage d'assemblage est d'attribuer des noms compréhensibles par l'humain aux instructions que les ordinateurs exécutent.

La syntaxe d'assembleur utilisée ici suit les conventions générales, tu devrais donc être capable de lire le code assembleur de la plupart des processeurs réels une fois que tu les auras apprises.

La syntaxe d'une instruction commence par un mot abrégé, appelé "[color=#9966ff]mnémonique[/color]", qui décrit l'instruction. Elle est suivie d'une liste d'[color=#66ccff]opérandes[/color], comme ceci:[box][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]4[/color][/box]

Les programmes en assembleur ne sont pour l'essentiel que des listes d'instructions.

[large]Opérandes[/large]

Il existe plusieurs types d'[color=#66ccff]opérandes[/color].

[b]Registres[/b]
Dans l'exemple ci-dessus, [color=#66ccff]r1[/color] est remplacé par 1 dans le code machine généré.

[b]Nombres[/b]
Dans l'exemple ci-dessus, [color=#66ccff]4[/color] est inséré directement dans le code machine.

[b]Labels[/b]
Pour les instructions de saut, on souhaite généralement faire référence à des décalages dans le code machine généré. Ces décalages peuvent être calculés automatiquement pour toi à l'aide des labels: [box][color=#9966ff]jmp[/color] [color=#66ccff]mon_label[/color]
...
[color=#66ccff]mon_label:[/color][/box]
Les labels sont toujours déclarées en ajoutant un nom sur une ligne, suivi d'un deux-points.


[large]Autres fonctionnalités[/large]

[b]Comments[/b]
Tout ce qui se trouve sur la même ligne après [highlight];[/highlight] est considéré comme un commentaire et ignoré par l'assembleur, comme ceci:
[box][color=#eeeeee]mov r1, 123 [/color][color=#999999]; Déplacement de 123 vers le registre 1[/color]
[/box]

[b]Données brutes[/b]
Tu peux insérer des données directement entre les instructions assemblées, comme ceci :
[highlight]U8 123[/highlight]
Ici, nous insérons l'octet 123. [highlight]U8[/highlight] signifie  "valeur non signée sur 8 bits ", mais l'assembleur prend également en charge [highlight]U16[/highlight], [highlight]U32[/highlight] et [highlight]U64[/highlight].
Tu peu également insérer la valeur de caractères ASCII comme ceci:
[highlight]"Bonjours"[/highlight]

[b]const[/b]
Crée de nouveaux noms pour tes registres ou d'autres types d'opérandes comme ceci:
[highlight]const ROTATION = r0[/highlight]
Dans cet exemple, [highlight]ROTATION[/highlight] devient un nom alternatif pour r0. Crée des noms locaux pour tes registres peut rendre ton code plus facile à lire.

[b]Sections[/b]
Inséres un [highlight]@[/highlight] suivi d'une adresse pour amener l'assembleur à insérer des zéros jusqu'à ce qu'il atteigne cette adresse. Par exemple :
[highlight]@0x800[/highlight]

[b]Include[/b]
Tu peux inclure d'autres fichiers d'assemblage, par exemple en incluant "std_lib.asm" depuis le dossier parent :
[highlight]include ../std_lib[/highlight]

L'inclusion d'un autre fichier d'assemblage insérera le résultat de son assemblage à l'endroit où figure l'instruction d'inclusion. Tu peux également utiliser les labels et modifier leur nom dans le fichier inclus, s'ils sont exposés dans leur fichier en étant préfixés par le mot-clé 'pub', comme ceci :
[highlight]pub print:[/highlight]

Pour accéder à un nom ou un label exposé, place le nom du fichier et un point avant le nom, comme ceci:
[highlight]jmp std_lib.print[/highlight]
Cela te permet de créer une bibliothèque de fonctions pouvant être appelées depuis n'importe quel niveau. Il te suffit de placer le fichier de bibliothèque dans le dossier situé au-dessus des niveaux et d'exposer les étiquettes correspondant à chaque fonction.



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

$81923869207578*
Programmation assembleur



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

$57024194971618*
La section [highlight]\[champs][/highlight] définit les différents types de champs pouvant être inclus dans les définitions d'instructions, ainsi que les valeurs qu'ils peuvent prendre. 

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

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

Les champs sont séparés par des lignes vides, et chaque champ commence par un nom de champ sur la première ligne, suivi d'une ou plusieurs valeurs de champ autorisées. Les valeurs sont des séquences de bits, et toutes les valeurs au sein d'un champ doivent avoir la même longueur en bits.

Les champs sont utilisés dans des instructions comme celle-ci:
[box]mov r1, r3[/box]

[b]Default values[/b]
Certaines architectures, comme aarch64, autorisent un "#" facultatif devant les opérandes immédiats. Cela peut être géré à l'aide de champs. Note que les guillemets sont autorisés autour des noms de champs pour cette raison.

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

[b]Noms de champs réservés[/b]
Il y a deux noms réservés:
* [highlight]label[/highlight] fait référence à des labels au sein de l'assembleur (ex: [highlight]Monlabel:[/highlight]).
* [highlight]immediate[/highlight] fait référence à des valeurs immédiates



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

$32103815380062*
Champs



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

$20029422748716*

[b]Opérateurs d'expression[/b]
Le jeu propose un ensemble limité d'opérateurs pour la construction d'opérandes virtuels:
[box]Opérateur       Description                           Exemple       Résultat si %a = -30000
!               not booléen                              !%a           0
&&              and booléen                              %a && 7       1
||              or booléen                               %a || 7       1
\==             égal                                     %a == 7       0
!=              inégal                                   %a != 7       1
<u              non signé inférieur à                    %a <u 7       0
<               signé inférieur à                        %a < 7        1
>=u             non signé supérieur ou égal              %a >=u 7      1
>=              signé supérieur ou égal                  %a >= 7       0
<=u             non signé inférieur ou égal              %a <=u 7      0
<=              signé inférieur à ou égal                %a <= 7       1
>u              non signé supérieur à                    %a >u 7       1
>               signé supérieur à                        %a > 7        0
~               bitwise NOT                              ~%a           29999
&               bitwise AND                              %a & 7        0
|               bitwise OR                               %a | 7        -29993
^               bitwise XOR                              %a ^ 7        -29993
+               addition                                 %a + 7        -29993
-               soustraction                             %a - 7        -30007
*               multiplication                           %a * 7        -210000
/u              division non signée                      %a /u 7       2635249153387074516
/               division signée                          %a / 7        -4285
%               modulo (reste d'une division)            %a % 7        -5
<<              décalage logique à gauche (LSL)          %a << 7       -3840000
>>              décalage logique à droite (LSR)          %a >> 7       144115188075855637
[/box]
Une omission notable est l'absence d'opération de négation. Toutefois, par défaut, si l'opérateur '+' ou  '-' est dépourvu de premier opérande, il utilise la valeur 0 à la place ; cela signifie que ce cas est pris en charge par l'opérateur de soustraction existant.



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

$21043147057012* Opérateurs



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

$64897298154598*
[large]Aperçu[/large]

La page [link="Assembly/Language creation"]Création de langage[/link] ne décrit que les définitions d'instructions de base , cette page vise à aborder des fonctionnalités plus avancées.

Une définition d'instruction se compose des lignes suivantes:

[color=#66ff99]Syntaxe[/color]
[color=#ffe666]Opérandes virtuels[/color] (optionnel)
[color=#ff6680]Assertions[/color] (optionnel)
[color=#66ccff]Code machine[/color]
[color=#9966ff]Description[/color]

Exemple:
[box][color=#66ff99]jmp %offset(label)[/color]
[color=#ffe666]%high_bits = %offset / 4[/color]
[color=#ff6680]assert(%offset % 4 == 0, "Ne peut sauter qu'à des adresses alignées sur 4 octets")[/color]
[color=#66ccff]01 hhhhhh[/color]
[color=#9966ff]# Saute vers %offset[/color][/box]

[large][color=#66ff99]Syntaxe[/color][/large]
Les syntaxes sont constituées d'une liste de [b]littéraux[/b] et d'[b]opérandes[/b], séparés par des [b]espaces[/b].

[b]Littéraux[/b]
Dans l'exemple ci-dessus, le mnémonique [highlight]jmp[/highlight] est un littéral. Les instructions comportant plusieurs opérandes voient généralement ces derniers séparés par des littéraux [highlight],[/highlight].
Utilise [highlight]%%[/highlight] pour utiliser le symbol [highlight]%[/highlight] comme littéral.

[b]Opérandes[/b]
Les opérandes d'instruction commencent par le préfixe [highlight]%[/highlight] et s'écrivent sous la forme [highlight]%name(fields)[/highlight].
* [highlight]name[/highlight] est un identifiant quelconque. 
* [highlight]fields[/highlight] est une liste d'un ou plusieurs champs créés dans la section précédente "Fields" (ou des champs réservés). La liste est délimitée par le caractère barre verticale ([highlight]|[/highlight]).

[b]Espaces[/b]
Les espaces blancs peuvent être des tabulations ou des espaces. Si un seul caractère d'espacement est utilisé, l'espace sera facultatif dans le langage assembleur. Si le caractère d'espacement est suivi d'un autre espace, L'assembleur nécessitera des espaces entre les jetons(tokens).


[large][color=#ffe666]Opérandes virtuels[/color][/large]
Dans l'architecture de l'exemple de saut ci-dessus, Toutes les instructions ont une taille de 4 octets, Ainsi, les deux bits de poids faible de la destination du saut sont toujours censés être à 0. Nous pouvons créer un nouvel opérande virtuel sans ces deux bits de poids faible, comme ceci:
[box]%high_bits = %offset / 4[/box]
Nous utiliserons [highlight]%high_bits[/highlight] au lieu de [highlight]%offset[/highlight] dans la définition du code machine.
Tu trouveras une liste des opérateurs pris en charge [link="Assembly/Language creation/Instructions/Operators"]ici[/link].

Deux opérandes spéciaux sont automatiquement définis, [highlight]$start[/highlight] et [highlight]$end[/highlight]. $start est le décalage du code machine juste avant l'instruction, est celui juste après. Ces fonctions peuvent par exemple servir à calculer des décalages par rapport à l'instruction courante, comme ceci :
[box]%rel_offset = %offset - $end[/box]

[large][color=#ff6680]Assertions[/color][/large]
Les assertions permettent de détecter les erreurs de l'utilisateur. Dans l'exemple ci-dessus, nous les utilisons pour nous assurer que nous sautons vers une adresse alignée sur 4 octets.


[large][color=#66ccff]Code machine[/color][/large]
L'exemple ci-dessus utilise la syntaxe de code machine suivante.
[box]01 hhhhhh[/box]
Note que [highlight]h[/highlight] fait référence à l'opérande virtuel [highlight]%high_bits[/highlight] . Avec cette syntaxe, les bits des opérandes sont toujours représentés par la première lettre de leur nom.

Une autre façon, équivalente, d'écrire la même chose consiste à utiliser le [b]découpage de bits(bit slicing)[/b]:
[box]01 %offset\[8:2][/box]
Le découpage de bits (bit slicing) utilise une syntaxe matérielle standard pour sélectionner une partie d'un champ de bits. La syntaxe est: [highlight]\[last:first][/highlight] où le premier et le dernier sont inclus.

Le découpage de bits (bit slicing) peut être appliqué à plusieurs opérandes et combiné avec la syntaxe un bit par caractère.


[large][color=#9966ff]Description[/color][/large]
La description n'a aucune fonction pour l'assembleur ; elle existe uniquement à des fins de documentation.



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

$27583144414493*
Instructions



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

$29662258275697*
La section [highlight][patterns][/highlight] est l'endroit où nous définissons des macros de remplacement de texte afin de réduire les répétitions dans les définitions d'instructions. La structure des motifs est similaire à celle des instructions :

[color=#66ff99]Signature de motif[/color]
[color=#66ccff]Remplacement de syntaxe[/color]
[color=#9966ff]Remplacement du code machine[/color]


Exemple:
[box][patterns]

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

[instructions]

mov_%s\[[color=#66ff99]size([/color][color=#66ccff]"8"[/color], [color=#9966ff]"00"[/color][color=#66ff99])[/color] | [color=#66ff99]size([/color][color=#66ccff]"16"[/color], [color=#9966ff]"01"[/color][color=#66ff99])[/color]] %a(reg) %b(reg)
0000 [color=#9966ff]%s[/color] %a %b
\# Déplacer vers %a depuis %b

[/box]
Après le remplacement du texte, cela devient :
[box][instructions]

mov_[color=#66ccff]U8[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0000[/color] %a %b
\# Déplacer vers %a depuis %b

mov_[color=#66ccff]U16[/color] %a(reg) %b(reg)
0000 [color=#9966ff]0001[/color] %a %b
\# Déplacer vers %a depuis %b

[/box]
Dans l'exemple ci-dessus, on voit d'abord la déclaration d'un motif. Cette déclaration commence par le mot-clé "pattern" suivi de son nom puis des noms des arguments. Les deux lignes suivantes sont des fragments de texte qui seront insérés respectivement dans les lignes de syntaxe et de code machine.

Dans l'instruction, le nom de variable [highlight]%s[/highlight] est placé dans la ligne de syntaxe. Dans cet exemple, l'analyseur énumère chacune des deux versions capturées par [highlight]%s[/highlight] et instancie une nouvelle instruction pour chacune d'entre elles. Il insère les extraits de syntaxe et de code machine, puis remplace les arguments du motif par les valeurs fournies.



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

$50803475056346*
Motifs(Patterns)



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

$13660841232898*
La section  [highlight]\[Paramètres ][/highlight] définit plusieurs propriétés de configuration pour ton architecture:

[b]name[/b]
[box]name = "Nom de l'architecture"
[/box]Nom de l'architecture.

[b]variant[/b]
[box]variant = "Variante d'architecture"
[/box]Description supplémentaire de l'architecture.

[b]endianness[/b]
Définit l'ordre des octets des instructions.
[box]endianness = big
endianness = little[/box]
Par défaut, le format est big-endian.

Tu peux en savoir plus sur l'endianness [link="Computer concepts/Endianness"]ici[/link].

[box=info]Les composants RAM possèdent leur propre indicateur d'endianness, qui peut inverser l'ordre des octets. C'est simple si la largeur de ton instruction correspond à la largeur en bits du composant mémoire, mais cela peut prêter à confusion si les largeurs diffèrent.[/box]

[b]line_comments[/b]
Spécifie les marqueurs utilisés pour marquer le début d'un commentaire sur une seule ligne. Les commentaires sur une seule ligne commencent au marqueur indiqué et occupent le reste de la ligne.
[box]line_comments = "#"
line_comments = \[";", "//"][/box]
La valeur par défaut de line_comments est [highlight]\[";", "//"][/highlight].

[b]block_comments[/b]
SSpécifie les marqueurs utilisés pour marquer le début et la fin d'un commentaire de bloc. Les commentaires de bloc commencent au premier marqueur et s'étendent jusqu'au dernier. Cela inclut les sauts de ligne ainsi que les marqueurs de début de commentaire supplémentaires (empêchant ainsi l'imbrication des commentaires de bloc).
[box]block_comments = {"/*":"*/"}[/box]
La valeur par défaut de block_comments est [highlight]{"/*":"*/"}[/highlight].



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

$78090021698706*
Paramètres



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

$41184546203403*
[large]Aperçu[/large]

Voici un exemple de définition d'assembleur simple:
[box][fields]
register
r0 000
r1 001
r2 010
r3 011

[instructions]
mov %a(register), %b(register)
00aaabbb
\# Déplacer une valeur de %b vers %a

mov %a(register), %b:U8(immediate)
01000aaa bbbbbbbb
\# Déplacer un octet de %b vers %a

jmp %a(label)
10000000 aaaaaaaa
\# Saute vers %a[/box]

Note que la définition est divisée en deux sections [highlight][fields][/highlight] et [highlight][instructions][/highlight].

[large]la section [fields][/large]
Les champs te permettent de donner des noms à des motifs de bits. C'est généralement utilisé pour les registres. Plus de détails [link="Assembly/Language creation/Fields"]ici[/link].

[large]la section [instructions][/large]
Les définitions d'instructions se composent d'une ligne de [color=#66ff99]syntaxe[/color] , Les définitions d'instructions se composent d'une ligne de [color=#66ccff]code machine[/color] et d'une ligne de [color=#9966ff]description[/color] :

[box][color=#66ff99]mov %a(register), %b(register)[/color]
[color=#66ccff]00aaabbb[/color]
[color=#9966ff]# Déplacer une valeur de %b vers %a[/color][/box]
Lorsque tu saisis des instructions d'assemblage dans ton langage, l'assembleur parcourt cette liste de définitions, trouve la première [color=#66ff99]syntaxe[/color] correspondante et génère le [color=#66ccff]code machine[/color] associé.

[b][color=#66ff99]Ligne de syntaxe[/color][/b]
La ligne de syntaxe est un mélange de chaînes de caractères (string) codées en dur et d'opérandes. Les opérandes commencent toujours par [highlight]%[/highlight] suivi d'un nom qui les identifie sur les autres lignes. Vient ensuite un champ d'opérande, qui peut être un [highlight]label[/highlight],une [highlight]valeur immédiate[/highlight] ou un [highlight]champ[/highlight] personnalisé que tu as défini dans la section [b][fields][/b] .

[b][color=#66ccff]Ligne de code machine[/color][/b]
La ligne de champ de bits correspond à [highlight]0[/highlight] ou [highlight]1[/highlight] ainsi qu'à la première lettre de l'un quelconque des noms d'opérande définis dans la ligne de syntaxe. [highlight]0[/highlight] et [highlight]1[/highlight] sont interprétés littéralement, tandis que les lettres opérandes utilisent un chiffre binaire à la fois issu de la valeur de leur opérande. 

[b][color=#9966ff]Ligne de description[/color][/b]
La description n'a aucune fonction pour l'assembleur, elle existe uniquement à des fins de documentation.

L'assembleur prend en charge bien d'autres fonctionnalités liées aux instructions, que tu peux découvrir [link="Assembly/Language creation/Instructions"]ici[/link].

[large]Autres sections[/large]
Outre [b][fields][/b] et [b][instructions][/b] il existe deux autres sections facultatives, [b][link="Assembly/Language creation/Settings"][settings][/link][/b] et [b][link="Assembly/Language creation/Patterns"][patterns][/link][/b].



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

$67371980949119*
Création de langage



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

$85571962806085*
Assembleur



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

$65852115931553*
Le dimensionnement automatique est une fonctionnalité qui t'offre une plus grande flexibilité lors de la création de composants personnalisés. Par exemple, ce schéma représente un compteur fonctionnant quelle que soit sa taille et dont l'incrément est configurable:
[image="example.png"]

Notes que certaines étiquettes de taille ont une couleur de fond différente. C'est parce qu'ils ont été configurés pour être déduits automatiquement. Tu peux configurer la taille pour qu'elle soit déduite automatiquement à l'aide de ce bouton.
[image="setting.png"]

En règle générale, la plupart des composants peuvent avoir le dimensionnement automatique activé ,et quand c'est le cas, ils s'adapteront à la taille du fil qui mène à l'une de leurs broches d'entrée. La broche à partir de laquelle un composant à dimensionnement automatique prend sa taille diffère pour chaque composant . La broche à partir de laquelle un composant à taille automatique détermine ses dimensions varie d'un composant à l'autre. Par exemple, l'additionneur ci-dessus prendra la valeur la plus élevée de ses deux entrées numériques tout en ignorant tout fil potentiellement connecté à la broche de retenue.

Pour des raisons techniques, cela ne fonctionne pas pour les composants de mémoire. Pour obtenir un registre ou une ligne à retard de taille automatique, tu peux utiliser les versions spéciales dotées d'une broche bleue, comme illustré dans l'exemple ci-dessus. Les broches bleues servent généralement à indiquer les fonctionnalités liées à la taille.



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

$18060272082456*
Dimensionnement automatique



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

$57134685411828*
Une dépendance circulaire se produit lorsque l'entrée d'un composant change en fonction de sa propre sortie. 

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

Ce simulateur n'autorise pas les dépendances circulaires et déclenche une erreur. 

Les broches orange font exception à cette règle car elles n'influencent pas la sortie lors du même cycle . Ils ne peuvent donc pas engendrer de dépendances circulaires.

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



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

$79928695804890*
Dépendance circulaire



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

$25269304368822*
Dans le matériel réel, tous les composants présentent un délai. Ce délai est important car il détermine la vitesse maximale à laquelle un circuit peut fonctionner.

En suivant les câbles de l'entrée à la sortie et en additionnant le délai des composants sur le trajet, tu obtiendras le délai de ce trajet. Le délai d'un circuit est le délai du chemin le plus lent (appelé chemin critique).



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

$82367602514282*
Délai



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

$20065838867866*
En électronique, deux composants délivrant des valeurs différentes sur le même fil provoquent un court-circuit.

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

Cependant, en déconnectant les broches de sortie d'un fil, il est possible que plusieurs broches partagent le même fil (appelé bus). Il est important de noter qu'au maximum une sortie de composant doit rester connectée à chaque cycle, sous peine de court-circuit.

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

Dans ce simulateur, les broches commutables sont grises.



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

$80662783536910*
Court-circuit



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

$43200267887776*
Ouvre la fonderie en cliquant sur ce bouton  dans la barre supérieure gauche.

La fonderie te permet de créer tes propres composants. La logique que tu définis détermine le comportement du composant personnalisé, et la mise en page détermine sa forme. 

Les composants d'entrée et de sortie que tu places deviennent des broches sur le composant personnalisé. 

Les sondes placées dans des composants personnalisés s'afficheront sur la surface du composant personnalisé et pourront afficher les depuis l'intérieur. Les sondes peuvent être connectées à d'autres composants personnalisés, permettant ainsi l'affichage de valeurs imbriquées. Les valeurs ainsi sondées peuvent également être connectées au composant programme.

Pour la fonderie, le gestionnaire de fichiers gère également les composants personnalisés. Le nom des schémas détermine le nom des composants et la structure des dossiers détermine leur emplacement dans le menu.



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

$83185064398279*
La Fonderie



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

$18477347795935*
Le composant clavier enregistre les frappes de votre clavier.

Chaque pression sur une touche génère deux événements : un événement d'enfoncement et un événement de relâchement. Ces événements peuvent ensuite être lus un par un depuis le composant.

[large]Modes de clavier[/large]
Différents pays utilisent des claviers différents,  par exemple, alors que la première rangée de caractères d'un clavier anglais commence par QWERTY, elle commence par AZERTY sur les claviers français. 

Si tu crée un éditeur de texte, l'emplacement physique des touches t'importe peu, tu veux simplement savoir ce qui est inscrit dessus. Dans ce cas, tu dois utiliser le [b]mode localisé[/b].

Si, en revanche, tu souhaite utiliser les touches situées en haut à gauche pour les commandes de jeu, tu n'auras pas envie de gérer le fait que la configuration WASD des claviers anglais correspond à ZQSD sur les claviers français. Tu veux simplement faire référence à l'emplacement physique des touches sur le clavier, et non à ce qui est inscrit dessus. Dans ce cas, tu dois utiliser le [b]mode Emplacement physique[/b].

[large]Mode localisé[/large]
Dans ce mode, les touches sont associées à la valeur ASCII lorsque cela est possible. La touche [highlight]w[/highlight] sur un clavier QWERTY, AZERTY ou tout autre clavier correspondra toujours à [highlight]0x77[/highlight].

[large]Mode d'emplacement physique[/large]
Dans ce mode, les touches sont associées à leur emplacement physique (ligne et colonne). Les lignes comme les colonnes utilisent 4 bits, les emplacements peuvent donc être exprimés de manière concise en hexadécimal. Par exemple, la barre d'espace, située à la 5e ligne et à la 3e colonne, correspond à 0x53 en hexadécimal.

[image="coordinate_mode.png"]

Note que, du côté du clavier situé à droite de la ligne noire, les numéros de ligne sont plus élevés afin de faire tenir toutes les touches dans les limites imposées par le codage sur 4 bits pour les lignes et les colonnes.

Si votre clavier ne correspond pas au schéma, tu peux faire des essais pour voir quelle valeur chaque touche renvoie.



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

$11486015900582*
Le clavier



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

$53269020658041*
L'écran



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

$42610024611500*
Circuits



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

$69772243733094*
L'ASCII est une correspondance entre des nombres sur 7 bits et des caractères (dans ce jeu, l'écran utilise l'ASCII étendu, qui est sur 8 bits).

[b]Code  Valeur  Description[/b]
  0    NUL    
  1    SOH    Début de l'en-tête
  2    STX    Début du texte
  3    ETX    Fin du texte
  4    EOT    Fin de transmission
  5    ENQ    Enquête
  6    ACK    Accusé de réception 
  7    BEL    Cloche
  8    BS     Retour arrière
  9    HT     Tabulation horizontale
 10    LF     Saut de ligne
 11    VT     Tabulation verticale
 12    FF     Saut de page
 13    CR     Retour chariot
 14    SO     Shift out
 15    SI     Shift in
 16    DLE    Échappement de liaison de données
 17    DC1    Contrôle de périphérique 1 (XON)
 18    DC2    Contrôle de périphérique 2
 19    DC3    Contrôle de périphérique 3 (XOFF)
 20    DC4    Contrôle de périphérique 4
 21    NAK    Accusé de réception négatif
 22    SYN    Inactivité synchrone
 23    ETB    Fin du bloc de transmission
 24    CAN    Annuler
 25    EM     Fin du support
 26    SUB    remplacer
 27    ESC    échappe
 28    FS     Séparateur de fichiers
 29    GS     Séparateur de groupe
 30    RS     Demande d'envoi/enregistrement du séparateur
 31    US     Séparateur d'unité
 32    SP     Espace
 33    !      Point d'exclamation
 34    "      Guillemet double
 35    #      Symbole dièse
 36    $      Symbole du dollar
 37    %      Pour cent
 38    &      Esperluette
 39    '      Apostrophe
 40    (      Parenthèse ouvrante
 41    )      Parenthèse fermante
 42    *      Astérisque
 43    +      Plus
 44    ,      Virgule
 45    -      Signe moins ou tiret
 46    .      Point
 47    /      Barre oblique
 48    0       
 49    1       
 50    2       
 51    3       
 52    4       
 53    5       
 54    6       
 55    7       
 56    8       
 57    9       
 58    :      point de suspension
 59    ;      Point-virgule
 60    <      inférieur à
 61    =      Signe égal
 62    >      Supérieur à
 63    ?      Point d'interrogation
 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    \[      Crochet ouvrant
 92    \\      Barre oblique inverse
 93    ]      Crochet fermant
 94    ^      Accent circonflexe 
 95    _      Underscore
 96    `       
 97    a       
 98    b       
 99    c       
100    d       
101    e       
102    f       
103    g       
104    h       
105    i       
106    j       
107    k       
108    l       
109    m       
110    n       
111    o       
112    p       
113    q       
114    r       
115    s       
116    t       
117    u       
118    v       
119    w       
120    x       
121    y       
122    z       
123    {      Accolade ouvrante
124    |      Barre verticale
125    }      Accolade fermante
126    ~      Tilde
127    DEL    Supprimer



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

$75719044675256*
Encodage ASCII



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

$39479426746559*
Les nombres auxquels tu es habitué sont en base 10, ici quand on ajoute un 0 à droite d'un nombre, sa valeur augmente 10 fois.

Le binaire est en base 2, donc faire la même chose va simplement le doubler. En d'autres termes, chaque chiffre représente une puissance de 2. Par exemple avec [color=#c54d5e]base 2[/color] et [color=#e49f44]base 10[/color] en code couleur :

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

Pour représenter 6, nous pouvons simplement ajouter 4 et 2 :

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

L'addition, la multiplication et tout le reste fonctionne comme en base 10, sauf que tu faisais une retenue quand tu atteignais 2 au lieu de 10.



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

$73447955210779*
Binaire



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

$64065714320299*
Ce jeu te demande de construire un ordinateur 8 bits. Concrètement, cela obligerait normalement le joueur à poser 8 lignes de câbles parallèles à de nombreux endroits.
Pour alléger les tâches fastidieuses, on te proposes la notion d'octet, qui n'est qu'un ensemble virtuel de 8 bits.

L'état d'une entrée/sortie ou d'un fil d'octet est représenté par un nombre, au lieu de la couleur rouge ou verte.



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

$68430971305988*
octet



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

$13079267765950*
Les tables de vérité des quatre portes fondamentales sont symétriques. Tu peux les convertir entre elles en [color=#6e9759][b]inversant l'entrée[/b][/color] (flèches verticales) ou en [color=#595f99][b]inversant la sortie[/b][/color] (flèches horizontales) comme l'indique le graphique ci-dessous.

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

Notes
1. On peut passer de n'importe quelle porte logique de base à n'importe quelle autre, au plus, il faut NOT à la fois les entrées et la sortie.
2. Tu peux passer d'une porte OR à une porte NOR en inversant la sortie, pareil avec AND/NAND. En fait NOR signifie NOT OR et NAND signifie NOT AND. Remarque que la forme des composants OR/NOR est identique, à l'exception du petit point à l'extrémité qui signifie NOT. Il en va de même pour AND/NAND.
3. Appliquer NOT à la sortie inverse tous les bits de la dernière ligne de la table de vérité. Appliquer NOT aux entrées reflète la dernière ligne de la table de vérité autour de son centre.



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

$66359790889628*
Les lois de De Morgan



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

$78199387512682*
Par convention, nous affichons les données par ordre croissant d'adresses mémoire, de gauche à droite. Cela garantit que le texte ASCII s'affiche également de gauche à droite lors du stockage des caractères par ordre croissant.le mot francais pour Endianness est [b]boutisme[/b].


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

De plus, la convention d'écriture des nombres veut que les chiffres les plus significatifs soient à gauche, tel que treize s'écrit [color=#ff6680]13[/color] au lieu de [color=#ff6680]31[/color].

Dans ce contexte, la manière la plus évidente de représenter un nombre multi-octets tel que 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] en mémoire est:

[box]          Mémoire (hex)
Adresse:   0  1  2  3
Donnée:     [color=#66ccff]12[/color] [color=#66ff99]34[/color] [color=#ffe666]56[/color] [color=#ff6680]78[/color][/box]

Ceci s'appelle [b]Big Endian[/b](gros-boutiste), parce que les chiffres plus grands (plus significatifs) sont stockés à une adresse plus basse. 

Cependant, d'un point de vue algorithmique, il est difficile de faire croître les nombres dans le sens inverse du texte. Certaines applications, comme la cryptographie, nécessitent des nombres illimités (BigInt), et pour ce faire, il faut pouvoir étendre le nombre de chiffres ou supprimer les zéros de fin. Il est naturel d'ordonner les chiffres de manière à pouvoir agrandir le nombre sans avoir à mettre à jour le pointeur qui pointe vers ce nombre. Tu pourrais bien sûr décider que grandir signifie aller dans la direction opposée, Dans ce cas, tu rencontreras le même problème lors de l'ajout de texte(à moins d'implémenter deux types de tableaux extensibles). 

Il existe d'autres aspects bénéfiques au stockage des nombres en commençant par les bits de poids faible. Par exemple, il est beaucoup plus courant de n'avoir besoin que des bits de poids faible (conversion descendante) d'un nombre que des bits de poids fort. Stocker les nombres en commençant par le chiffre le moins significatif signifie que cela peut être fait sans modifier le pointeur.

La convention informatique naturelle consistant à stocker d'abord les chiffres les moins significatifs est appelée [b]Little Endian[/b](petit-boutiste). Malheureusement, l'affichage en little-endian est généralement rendu encore plus confus car les valeurs sont regroupées par octets, chacun étant affiché dans le sens conventionnel. Donc 0x[color=#66ccff]12[/color][color=#66ff99]34[/color][color=#ffe666]56[/color][color=#ff6680]78[/color] devient:

[box]          Mémoire (hex)
Adresse:   0  1  2  3
Donnée:     [color=#ff6680]78[/color] [color=#ffe666]56[/color] [color=#66ff99]34[/color] [color=#66ccff]12[/color][/box]

Si la convention avait été d'écrire les nombres et le texte de manière à ce qu'ils augmentent dans le même sens, cette page de manuel serait inutile.

Aujourd'hui, tous les processeurs modernes utilisent le format little-endian, qui est devenu la norme, à l'exception notable du protocole TCP/IP qui utilise le format big-endian.



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

$25715726162519*
Endianness



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

$22037524510182*

La manière dont ce jeu représente le négatif est appelée "complément à deux"(two's complement). C'est la méthode standard pour représenter les nombres négatifs dans les ordinateurs modernes. Quelques éléments clés pour comprendre le complément à deux:
 1: Pour passer du négatif au positif, il suffit d'inverser tous les bits et d'ajouter[nbsp]1.
 2: Si le bit de poids fort est [T], la valeur est toujours négative.
 3: Les additionneurs fonctionnent en mode signé et non signé.
 4: Il n'y a qu'une seule façon d'écrire chaque nombre.

Aux débuts de l'informatique, le principal concurrent du complément à deux était le complément à un(one's complement). Son principal avantage est que changer le signe d'un nombre est simple, Tu as juste à appliqué NOT sur chaque bit du nombre. Cependant, 0 possède deux représentations, une positive et une négative, ce qui complique les comparaisons.

Une autre représentation intéressante, qui mérite peut-être qu'on s'y intéresse, est la base −2, dans laquelle le signe de la valeur de chaque chiffre alterne entre positif et négatif.



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

$64907157003500*
Nombres négatifs



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

$16579770195459*
Les tableaux d'entrée et de sortie utilisés tout au long du jeu sont communément appelés tables de vérité.

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

Les termes "entrée" et "sortie" seront souvent représentés par des noms de variables, comme en algèbre. Et au lieu d'utiliser des couleurs, tu verras souvent les valeurs représentées par 0/1 ou Faux/Vrai.



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

$39788153942181*
Tables de vérité



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

$38118080841071*
Certains ordinateurs, comme les calculatrices, sont limités dans les algorithmes qu'ils peuvent exécuter.

Ils ne peuvent effectuer aucun calcul nécessitant une boucle ou une récursion un nombre arbitraire de fois. Techniquement, les machines sans boucles ni récursivité ne peuvent traiter que la logique combinatoire.

Les machines Turing-complètes, en revanche, sont aussi puissantes qu'il est possible de l'être. Une machine de Turing complète peut avoir un processeur lent, mais elle est puissante dans le sens qu'il n'existe aucun algorithme (calculable) qu'elle ne puisse exécuter.



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

$88124920557040*
Turing complete



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

$11499640163947*
Il s'avère qu'on peut construire toute la logique d'un ordinateur à partir de portes NAND ou NOR. Les ordinateurs de guidage Apollo étaient entièrement construits à partir de portes NOR. Conçus dans les années soixante, ils ne disposaient que de 4 Ko de RAM et de 32 Ko d'espace disque, mais ont néanmoins guidé les astronautes vers la Lune.

Les ordinateurs modernes ne sont pas entièrement construits à partir d'une seule porte logique universelle, mais lorsque cela est possible, les portes NAND sont préférées aux portes NOR, car elles présentent un temps de latence plus court et occupent moins d'espace.



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

$24291443495513*
Portes universelles



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

$42755701050268*
Concepts informatiques



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

$62210202128540* Tu vois comme l'entrée n'a pas d'importance ?



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

$33906573915218* Choisis une porte logique dont la sortie est [T] quand ses entrées ne sont pas connectées



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

$18258110894478* Ce niveau débloque ta première page de manuel. Celui-ci est important, assure-toi d'y prêter attention.

$61066799501731* Toujours ON

$85978749941194* Crée un circuit qui donne toujours [T].



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

$68158507707802* La porte And peut être interprétée comme une porte NOT-NOT-AND, ou une porte NOT-NAND.



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

$18221128000007*
Crée le circuit qui correspond au tableau.
[tip]La plupart des niveaux disposent d'indice (l'ampoule) Tu peux cliquer dessus si tu es bloqué.[/tip]

$28388869498626* Pour l'instant, l'éléphant domine tous les autres sujets de test venus de la Terre. Si l'on tient compte de la taille du cerveau, tu t'en sors bien également.

$70892117360845* Porte AND



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

$34539182309616* Un AND plus grand n'est autre que plusieurs AND successifs.



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

$28751026881977* Crée une porte AND à 3 entrées.

$32912994842868* Grande porte AND



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

$10183449965120* Pour vérifier si au moins deux entrées sont [T], nous pouvons les vérifier deux à deux.



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

$83867604619162* Pour cela si les deux entrées d'une paire sont [T], on peut effectuer un AND logique.



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

$34521278233301* Cela reste un exercice laissé au joueur !

$43216513907358* Cette solution n'est pas la plus élégante ni la plus optimale.



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

$43068867747292*
Ce niveau comporte 4 entrées. 
Renvoie [T] lorsque 2 entrées ou plus sont [T].

[tip]Ne te prends pas trop la tête.[/tip]

$81647833476822* Détection des doubles



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

$11603603520594* Déplace une valeur depuis %b vers %a.



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

$17226968214352* La programmation par cartes perforées est fastidieuse. Essayons d'ajouter 5 à l'entrée comme au niveau précédent, mais cette fois en utilisant la programmation assembleur .

$72990407719621* Programmation Assembleur

$73801373825270*
L'objectif d'un langage assembleur est de donner des noms compréhensibles par l'homme aux instructions exécutées par nos machines. 

Par convention, la syntaxe d'une instruction commence par un mot abrégé (appelé "[color=#9966ff]mnémonique[/color]") qui décrit l'instructions, suivi d'une liste de [color=#66ccff]opérandes[/color] donc:
[highlight][color=#9966ff]mov[/color] [color=#66ccff]r1[/color], [color=#66ccff]r2[/color][/highlight]

Aussi par convention, la destination est à gauche. Dans l'exemple ci-dessus, nous déplaçons donc une valeur vers r1 depuis r2 . Si tu apprends ces conventions, tu seras capable de lire des langages assembleur réels.

Clique sur «Edit» sur le composant RAM pour ouvrir l'éditeur d'assembleur. De là, clique sur l'onglet "spec.isa" dans le coin supérieur gauche pour obtenir la liste complète des instructions d'Overture.



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

$36228934755685* place 15 dans reg 0

$41299869859669* ceci est un commentaire

$73562005049347* Déplace l'entrée vers reg 2

$80524429403045* Clique sur l'onglet "spec.isa" en haut à gauche pour afficher toutes les instructions.



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

$38629344681843* {input_value} + 5 devrait donner {expected_value}, et non {actual_value}.

$47165251832545* {input_value} + 5 devrait donner {expected_value}, et non Z.



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

$27941792707668* Ajoute 5 à la valeur d'entrée en utilisant la programmation assembleur.



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

$31456617450268* Déplace une valeur depuis %b vers %a.



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

$12002017150690* Clique sur le bouton «Edit» du composant «Programme» pour commencer la programmation de ton ordinateur avec des cartes perforées. ton ordinateur devrait lire une valeur en entrée, lui ajouter 5 et la restituer.

$23659479615536* Maintenant que tu as construit ton premier ordinateur, il est temps d'apprendre à le programmer.

$35877580485177*
Puisque toi et le dauphin avez tous deux construit un ordinateur, la compétition pour représenter la Terre à la Fédération Galactique se poursuivra jusqu'à ce que l'un de vous se retire.

La prochaine étape consiste à écrire un programme pour résoudre le labyrinthe.

$47348572622406* Programmation De Cartes Perforées



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

$61846111928326* {input_value} + 5 devrait donner {expected_value}, et non {actual_value}.

$81797824381193* {input_value} + 5 devrait donner {expected_value}, et non Z.



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

$65391114076509* Ajoute 5 à la valeur d'entrée en utilisant la programmation binaire



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

$17561499905402* Ce niveau est mon passe-temps favori : convertir des nombres décimaux en binaire sous la pression du temps.

$37988524800638* Course binaire

$78267067157141*
Bascules les bits du panneau de niveau de manière à ce qu'ils correspondent au nombre décimal indiqué dans la question.

Tu dois réussir le niveau 3 pour passer.



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

$16764912826624* Crackeur De Code

$20948899837760*
Dans ce niveau, tu gagnes si tu affiches le code secret auquel je pense. L'absence de résultat entraîne l'échec du niveau, tu pourrais donc simplement essayer tous les nombres.

De plus, je réglerai l'entrée sur 1 après une proposition trop élevée et sur 0 sinon, tu pourrais peut-être t'en servir pour trouver mon code plus rapidement.



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

$32998192994042* La somme requiert le même raisonnement qu'au niveau « Nombre impair de signaux ».

$90884846016283* La Retenue est [T] si et seulement si les deux entrées sont [T].



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

$10776402819741* Nous mesurons l'univers avec des nombres. Notre machine doit donc savoir compter.

$19285770105090*
Traite les entrées comme [b]0[/b] ou [b]1[/b] selon qu'elles sont [F] ou [T]. Additionne-les en binaire, tel que le résultat soit soit [b]0[/b] soit [b]1[/b].

Comme pour une addition normale, si le résultat ne peut pas être décrit avec un seul bit, définis la retenue sur [b]1[/b].

$64470174232265* Demi-additionneur



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

$40415302067949* Soit l'entrée 0 est [T] et l'entrée 1 est [F], soit l'entrée 0 est [F] et l'entrée 1 est [T].

$61125857472821* La table de vérité nous indique que la sortie est [T] si et seulement si



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

$64992550674018* Il s'agit, en fait, simplement d'une porte XOR.



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

$38198768813364* Inverseur de bit

$53559965601096* Crée un inverseur de valeur conditionnel. Lorsque [color=#e49f44][b]Inverser[/b][/color] est sur [T], envoie en sortie l'opposé de [color=#e49f44][b]Valeur[/b][/color]. Sinon, la sortie correspond simplement à [color=#e49f44][b]Valeur[/b][/color] .

$66258723258123* Nous étudions la manière dont les arrière-plans influencent les fonctions cognitives chez les Terriens.

$76209391067704* Ce niveau est exactement le même que le niveau de la porte XOR que tu as résolu précédemment. N'oublie pas : quel que soit l'objectif du niveau , la véritable réponse se trouve dans la table de vérité.



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

$29875779381032* Valeur

$41975883966377* Sortie actuelle

$42809920196772* Inverser

$62797002040657* Sortie attendu



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

$22413958203952* La table de vérité nous indique simplement de construire une porte XOR.

$46480779443140* Commençons par supposer que la contrainte de composant n'existe pas.



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

$45466715038362* Il ne nous reste plus qu'à éliminer la porte OR pour respecter le budget. 

$76027454955517* Un switch est très similaire à une porte AND donc remplaçons-les.



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

$16488212881433* circuit du bas

$42664577834105* Cela signifie que le circuit du bas est légèrement erroné, les deux commutateurs délivrant un état [Z] lorsque les deux entrées sont à [F].

$47029050705615* Sortie incorrecte

$52307576546100* circuit du haut/XOR

$62622482229413* Contrairement à une porte AND, lorsque la broche 'activer'est [F], le switch ne produit pas l’état [F], il ne produit rien du tout.

$80836475394613* Cela permet à leurs sorties de partager les mêmes fils sans court-circuit.



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

$12922292218235* Commutateur de bit(switch)

$25663924496537*

Au lieu de considérer la sortie comme étant déconnectée, on peut la voir comme ne délivrant ni [F] ni [T], mais un troisième état que nous appelons "état Z" [Z].

Relier deux sorties sur un fil produira les états suivants:

Sortie 0 [F][F][F][T][T][T][Z][Z][Z]
Sortie 1 [F][T][Z][T][F][Z][F][T][Z]
    Etat [F][E][F][T][E][T][F][T][Z]

Note que le court-circuit [E] ne peut pas être valablement considéré comme un quatrième état de sortie, puisqu'il rompt le circuit. C'est inclus dans le tableau pour être complet.

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

$88100823584262*
Si des composants délivrent des valeurs différentes sur le même fil, tu obtiens une erreur de court-circuit. 

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

Cependant, certains composants possèdent des broches de sortie grises,  celles-ci ne délivrent aucun signal lorsque le composant n'est pas activé. C'est le cas du composant "commutateur" (switch en anglais) .

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

Lorsque la broche inférieure est à l'état [F], la sortie est désactivée. Dans ce cas, plusieurs sorties peuvent être reliées au même fil sans provoquer d'erreur.

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

Concrètement, il n'est logique de relier plusieurs sorties au même fil que s'il s'agit d'interrupteurs. Pour que cela soit utile, les composants doivent émettre leurs signaux "à tour de rôle".



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

$37690209655811* tu as seulement besoin de trois additionneurs complets.



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

$49335074955899* En ajoutant un bit de plus, nous pouvons simplement utiliser un additionneur complet

$56143546486508* Comme pour les autres composants octet, nous commençons par décomposer l'octet en bits.



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

$57534334907443* Ajoute 7 additionneurs complets, un pour chaque bit



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

$36646953278480* la sortie «Retenue» du bit précédent est l'entrée «Retenue» du bit suivant

$69804974830322* Connecte l'entrée «Retenue» et la sortie «Retenue» du niveau pour compléter le circuit



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

$45190053242926* Retenue d'entrée

$76244671092409* Retenue de sortie



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

$31490345812891* Additionne les deux octets d'entrée. Chaque bit de sortie doit être le résultat de l'addition des bits correspondants des entrées, et potentiellement une retenue.

$45061087867940*
Si le résultat ne tient pas sur 8 bits, définie la retenue de sortie sur [T] (on peut le considérer comme le neuvième bit)
  
Enfin, il y a également une retenue d'entrée. Ceci est utile pour chaîner des additionneurs d'octets afin d'additionner des nombres plus grands. tu peux considérer cette retenue comme l'ajout de 0 [F] ou de 1 [T].

$53076615315445* De plus, ce niveau comporte de nombreux tests. Clique droit sur le bouton Exécuter pour augmenter la vitesse du test.

$62793095496458* Addition d'octet



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

$51758065631068* [color=#E49F44][left]Sortie Retenue        Somme[/left][/color]



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

$86214455922761* rappelons ce que sont ces décalages : des circuits de séparation et de création d'octets.



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

$11228896363898* c'est a dire que un décalage de 3 est équivalent à un décalage de 1 + un décalage de 2.

$11260842500047* nous pouvons implémenter une version de ce décalage appelée décalage de barillet(barrel shifter).

$55175982917102* Dans cette optique,notons que les décalages peuvent être additionnés,



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

$87506885530483* Nous décalons ensuite l'entrée 0 de 1, 2 ou 4 bits en fonction des bits [T] de l'entrée 1.



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

$53539145017840* ASR

$79125097012724*
Le décalage que tu as créé au niveau précédent est connu sous le nom de décalage [b]logique[/b], Décaler logiquement un nombre de 1 vers la droite revient à le diviser par 2 pour les nombres non signés. Pour les nombres signés, si le bit de poids fort est [T], nous remplissons les bits vides avec [T] au lieu de [F]. Ceci est appelé [b]décalage arithmétique vers la droite[/b], souvent écrit [b]asr[/b] en assembleur.

[color=#e49f44]-106 asr 3[/color]
 [T] [F] [F] [T] [F] [T] [T] [F]
Nous donne:
 |[T] [T] [T]|[T] [F] [F] [T] [F]
^                     
Et ici nous insérons [T] au lieu de [F]



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

$67841603404086* La représentation binaire de 164 est [T][F][T][F] [F][T][F][F]



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

$55176290924321* Crée un circuit qui donnera toujours le nombre 164 en sortie.

$55259569122850* Constante Octet



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

$90758832592628* Crée un circuit qui affiche toujours le nombre 164.



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

$15513439442399* Divise les deux entrées et envoie le résultat en sortie. Note que ce niveau est optionnel, parce que c'est très difficile. Si la deuxième entrée (le diviseur) est 0, le résultat doit être 0.

$55155519654685* Diviser



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

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



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

$86943286745277* Divise les deux nombres.



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

$13186595896308* Un XOR de 2 nombres égaux est très beau



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

$85034261531833* Le XOR de 2 nombres est égal à 0 si et seulement s'ils sont égaux

$88637818475024* Ensuite, on vérifie qu'un octet est égal à 0 en vérifiant que tous ses bits sont égaux à [F].



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

$16679981460998* Renvoie [T] en sortie lorsque les deux entrées sont identiques.

$44220989927736* Égalité



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

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

$32432328437519* La valeur {a} n'est pas égale à {b}

$51276780017906* La valeur {a} est égale à {b}



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

$41065065514143* Crée un circuit qui produit une sortie [T] lorsque les deux entrées sont identiques.



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

$14667194911431* Seulement, le dernier bit est considéré séparément pour les nombres signés , ici, il a l'effet inverse.

$19896249626650* Si un seul nombre a [T] comme bit de signe, ce nombre est garanti d'être inférieur.

$41958293329044* Comparer deux nombres signés revient à comparer deux nombres non signés.



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

$82755888644217* Si les bits de signe des entrées diffèrent, nous pouvons simplement les comparer.



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

$52492743864774* Sinon, nous pouvons comparer deux nombres non signés de 7 bits.



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

$12621415211383* Crée un circuit qui active la sortie [T] lorsque la première entrée est inférieure à la seconde. Interpréte les octets comme étant [color=#dd6576]signé[/color].

$57911276445846* Inférieur signé



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

$18672872329218* La valeur {a} n'est pas inférieure à {b}

$60636366241019* La valeur {a} est inférieure à {b}

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



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

$33907970782848* Crée un circuit qui produit une sortie [T] lorsque la première entrée est inférieure à la seconde.



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

$18968293717104* Une possibilitée est de comparer chiffre par chiffre, comme on le fait pour les nombres décimaux.

$45223418140453* Comme 09 < 21 car 0 < 2, donc 1100 > 1001 car 11XX > 10XX



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

$23270172293605* donc pour chaque bit, utilise une chaîne de portes OR pour vérifier si les bits de niveau supérieur sont [T].

$34091176621640* C'est faisable grâce à un XOR d'octets (n'oublie pas, XOR s'active si les entrées ne sont pas identiques).

$38704349429368* Commence par déterminer quels bits diffèrent entre les deux octets.

$45560562333305* mais nous ne devons considérer uniquement le bit différent le plus élevé,

$72421677239233* Nous savons que le nombre qui a le bit différent le plus élevé [T] est le plus grand nombre,



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

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

$73589178770254* Une autre solution consiste à comparer la différence avec 0.



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

$15205448412655* c'est a dire : Input_0 ADD (NEG Input_1)

$19139933016995* Nous n'avons pas de composant de soustraction, seulement addition et négation.

$56709208304109* Donc on transforme , par exemple, 1100 - 1001 en 1100 + (-1001)



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

$21199347421587* Pour les représenter sous forme signée, nous devons travailler avec des octets de 9 bits.

$46518640933018* Mais nous avons des entrées non signées de 8 bits.



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

$11293872851403* Nous pouvons créer un composant personnalisé 9 bits

$17291563256662* Ou bien nous pouvons décomposer NEG en NOT et ADD_1 pour manipuler



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

$90593296729801* Simplifie le circuit



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

$39605373706887* Inférieur non-signé

$68842379350661* Crée un circuit qui active la sortie [T] lorsque la première entrée est inférieure à la seconde. Interpréte les octets comme étant [color=#dd6576]non-signé[/color].



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

$50702714470018* La valeur {a} n'est pas inférieure à {b}

$54835419299907* La valeur {a} est inférieure à {b}

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



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

$88632565567686* Crée un circuit qui produit une sortie [T] lorsque la première entrée est inférieure à la seconde.



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

$75806240403820* rappelons ce que sont ces décalages : des circuits de séparation et de création d'octets.



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

$12195819154781* c'est a dire que un décalage de 3 est équivalent à un décalage de 1 + un décalage de 2.

$28136552692253* nous pouvons implémenter une version de ce décalage appelée décalage de barillet(barrel shifter).

$88850298427736* Dans cette optique,notons que les décalages peuvent être additionnés,



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

$22456794338741* Nous décalons ensuite l'entrée 0 de 1, 2 ou 4 bits en fonction des bits [T] de l'entrée 1.



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

$17566441654249* Décalage



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

$26791208073532*
La tâche à ce niveau consiste à décaler la première entrée vers la droite de la valeur donnée par la deuxième entrée.

$36654581830314* LSR

$57629598331916*
Décaler une valeur d'un rang vers la droite signifie simplement déplacer tous les bits d'un octet d'une position vers la droite.

Cette opération est appelée [b]décalage logique à droite[/b]  et est souvent abrégée en [b]lsr[/b] en langage assembleur.

Par exemple [b]180 lsr 1[/b][left]
[left]
           [T][F][T][T][F][T][F][F] Décale ceci de 1:
           [F][T][F][T][T][F][T][F][/left]
[/left]
et [b]180 lsr 3[/b][left]
[left]
           [T][F][T][T][F][T][F][F] Décale ceci de 3:
           [F][F][F][T][F][T][T][F][/left]
[/left]

$83781539475221* En plus de te donner un composant de décalage à droite, tu obtien également un composant de décalage à gauche.



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

$84095392269624* Modulo

$87605997307596* Renvoie le modulo des deux entrées en sortie. Si la deuxième entrée (le diviseur) est 0, Le résultat devrait être identique à la première entrée (le dividende).



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

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



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

$76653207214085* Renvoie le reste de la division des deux valeurs d'entrée.



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

$37740515704094* Ce niveau est très similaire à "Bit Switch".

$71057700033977* Mais avec A est à la place de l'entrée 0 et B à la place du NOT de l'entrée 0



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

$63172000393911* Sélectionner



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

$44523532982427* Lorsque l'entrée du sélecteur de bits est [F], envoie A en sortie, sinon envoie B.

$66984132947598*
Même s'il n'a pas réussi nos tests, nous avons décidé de garder le chien. Contrairement à la plupart des Terriens, il est tout en poils et sait obéir à des ordres simples.

Nous pourrions vous associer tous les deux, car vous compensez bien vos lacunes respectives.

$75861961518456* Multiplexeur



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

$15140861344476* Sélectionne {select}



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

$28574225028041* Sélectionne A ou B



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

$88766421259023* NAND octet de deux nombres binaires est un NAND appliquée bit à bit entre ces deux nombre.



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

$11980470862173* NAND octet

$52274910421610*
Effectue une opération NAND sur chaque bit des octets d'entrée et envoie le resultat en sortie.

For example:
\#Entrée 0 [T][T][F][F][F][T][F][F]
\#Entrée 1 [F][F][F][F][T][T][F][F]
\#Sortie  [T][T][T][T][T][F][T][T]

$66454601163361* Ne t'inquiète pas : si tu ne parviens pas à assembler un ordinateur, tu seras soit relâché dans la nature, soit placé dans un zoo disposant de beaucoup d'espace.



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

$55051011788323* NOT octet d'un nombre binaire est un NOT appliquée bit à bit à ce nombre binaire



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

$54090032127372* "NOT" chaque bit de l'octet d'entrée.

$60317070264440* Par conséquent, le nombre de bras d'une créature est manifestement le principal indicateur de l'intelligence. Savais-tu qu'il existe, sur ta planète, des créatures marines dotées de quatre fois plus de bras que toi et qui obtiennent de meilleurs résultats aux tests ?

$65498108564418* NOT octet

$70777086019982* La fabrication et l'utilisation d'outils jouent un rôle clé dans les premiers stades de l'évolution de l'intelligence.

$79214241606407* Notre modèle précédent, selon lequel la taille du cerveau était le principal prédicteur de l'intelligence, était naïf.



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

$66692685876410* XOR octet de deux nombres binaires est un XOR appliquée bit à bit entre ces deux nombre.



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

$41472172986798* XOR octet

$70973830134418* Crée un circuit qui effectue un XOR bit à bit sur deux octets.



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

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



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

$62779271315005* Crée un circuit qui effectue un XOR bit à bit entre deux octets.



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

$22440157378882* Ajouter une majuscule

$36850349097673*
Les données d'entrée de ce niveau sont des phrases encodées en ASCII ([link="Computer concepts/ASCII encoding"]see manual[/link]). Chaque mot est séparé par un espace dont la valeur numérique est 32. Remplace la première lettre de chaque mot par sa version majuscule.

Les caractères autorisés sont les lettres minuscules de a à z et l'espace.



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

$37137490280093* Tu n'as pas lu le caractère {character} de la chaîne.

$52976618691411* La sortie aurait dû être {char}, et non {output}.



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

$21808795465233* Circonférence

$46884494321384*
Dans ce niveau, on te donne un rayon et tu calcules la circonférence.

Voici l'équation: 2×π×r

r est l'entrée.
Et tu peux simplifier π par 3.

Envoie le résultat en sortie une fois calculé.



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

$18136442036625* Que donne 2π × {radius}?



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

$24129473753872* lis l'entrée

$47357954866257* *En supposant que π ≈ 3



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

$38150072401115*
Pour terminer ce niveau, lis les données jusqu'à ce que tu voies le nombre 37. 

Ensuite, envoie en sortie le nombre de fois où tu as lu l'entrée.

$38613585637577*
Bonne nouvelle pour toi : le dauphin a déjà abandonné.

Il avait du mal à programmer avec ses nageoires. 

Nous poursuivrons toutefois les tests, afin de voir jusqu'où les humains peuvent aller.

$40525671378957*
L'objectif de ce niveau est de t'apprendre les sauts et les labels. 

Un saut(jump) est une instruction qui écrase le compteur. 

Écraser le compteur signifie que nous « sautons » à une instruction située ailleurs dans notre programme, au lieu de simplement passer à la suivante.

$47703565240245* Sauts conditionnels(jump)

$65712025748767*
Si tu utilises un nombre fixe comme destination de saut, tu devras le mettre à jour à chaque fois que tu ajoutes ou supprimes du code.

Tu peux en revanche utiliser une fonctionnalité appelée [color=#66ccff]label[/color] pour marquer un emplacement dans le programme qui se met à jour automatiquement lorsque tu modifie quoi que ce soit, comme ça:

[box][left]
[color=#66ccff]my_label[/color]:     [color=#aaaaaa]; Ceci est un label[/color]
[color=#9966ff]imm[/color] [color=#66ccff]my_label[/color]  [color=#aaaaaa]; Charge le décalage du label[/color]
[/left][/box]
  



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

$35642914965530* Saute au byte 5 du programme

$50319416070023* Définit r0 à 5

$66946505646203* Tu peux charger son décalage comme ceci

$67381454058237* ceci est un label

$78380513477546* Clique sur l'onglet "spec.isa" pour voir les autres instructions de saut



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

$39953782121467* La dernière entrée n'était pas 37 !

$75138288162938* Tu as lu l'entrée {read_count} fois, et non {output}.



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

$65261628219716* édite l'assembleur sur la RAM



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

$15352671410916* avec 8 étant le nombre de bits et log2 la position du premier bit [T].

$75683304945175* Sauf lorsque l'Input vaut 0, cela revient à trouver 8 - 1 - log2(Input),

$83745112465243* touver le logarithme en base 2 des nombres binaires est un sujet largement exploré en informatique.



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

$40521556880682* Une des possibilités est de diviser le problème

$46035077948196* Quel est le logarithme en base 2 d'un nombre binaire non nul de 2 bits (c'est-à-dire 1, 2 ou 3) ?



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

$32041142528569* Par rapport à (2 − 1) = 1, il y a respectivement 1 et 0 zéro en tête.

$88044062357651* Que dirais-tu d'un nombre sur 4 bits ?

$88309764896321* Si le nombre est inférieur à 2, log2 vaut 0 ; sinon, il vaut 1.



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

$24472621996685* Si le nombre est inférieur à 4, nous pouvons réduire le problème sur 2-bit.

$42632561737634* Dans les deux cas, le problème passe de 4 bits à 2 bits.

$87709120049440* Sinon, le premier bit [T] se trouve quelque part parmi les 2 bits de poids fort.



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

$12591714876491* Il ne manque plus que le cas où l'entrée est égale à 0.

$82513296271559* Applique les mêmes étapes pour réduire le problème de 8 bits à 4 bits.



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

$27675083487752* Cette solution n'est pas la plus élégante ni la plus optimale.

$62535209440079* Cela reste un exercice laissé au joueur !

$81301599100070* La méthode la plus simple consiste à isoler le cas 0.



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

$18890527031365* Compter les zéro en tête

$30557055303267*
Crée un circuit qui part du bit de poids fort et compte le nombre de bits consécutifs à [F]

La réponse à ceci, par exemple, est 3, puisqu'il y a 3 bits [F] en tête:
[F][F][F] [T][F][T][F][T]



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

$10248302990519* Il y a {count} zéros en tête dans {input_value} ({binary_value})

$46565705342966* Il y a un zéro en tête dans {input_value} ({binary_value})



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

$85604588212035* Compte les zéros en tête



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

$74290091312759* ici, un simple ajustement permet d'écraser la valeur enregistrée



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

$22938387275450* Il suffit d'ajouter 1 au fil de boucle de la ligne à retard,

$81327009436542* mais utiliser un composant additionneur ici, c'est du gaspillage !



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

$24866509692444* Ecraser



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

$42949183679479*
Crée un compteur qui s'incrémentera de 1 à chaque cycle.

De plus, il devrait exister une option permettant de remplacer la valeur du compteur par une valeur donnée.

tu disposes de deux entrées : un bit et un octet.

L'entrée binaire doit basculer entre le comptage et l'écrasement avec la valeur de l'octet.

$51274378991709* Compter est une capacité si fondamentale que même les insectes le font. À partir de là, les espèces peuvent évoluer pour comparer des quantités et effectuer des opérations arithmétiques.  Et avant même de s'en rendre compte, on voit des grands singes construire des ordinateurs.

$68850421394935* Compteur



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

$27837193789838* La sortie devrait être {memory}.

$30050502504940* Ajoute 1

$69821998974515* remplacer par {num}



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

$16305942415014* Action

$57018164959250* Prochaine sortie souhaitée



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

$20653200546136* Le circuit pour le bit 1 est le même que dans « Nombre impair de signaux ».

$39788606928520* pour le bit 2, le même circuit que dans « Double Trouble », sauf lorsque les 4 bits sont activés.



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

$79041418443903* La sortie 0 est la même que dans « Nombre impair de signaux ».



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

$90442785399123* La sortie 2 est [T] si et seulement si tous les signaux sont [T].



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

$12139411441713* La sortie 1 est [T] si et seulement si au moins 2 signaux, mais pas les 4, sont [T].

$83417330967064* La partie « au moins 2 », nous l'avons déjà traitée dans le niveau "Détection des doubles".



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

$14499217305520* Compter les signaux

$83123268362253*
Le composant de sortie de ce niveau est un compteur binaire où les trois premières broches correspondent à 1, 2 et 4.
Utilise le compteur binaire pour afficher le nombre de signaux.

[tip]La solution pour ce niveau n'est pas très élégante et nécessite davantage de composants.[/tip]



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

$55345008240214* Décodeur 1 bit

$64947954189801* Crée un composant capable de commuter un signal entre deux broches.



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

$40303102766749* Sortie 0

$56552908891774* Sortie 1



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

$44276233109848* Décodeur 2 bits

$46223188985873* Avec 2 bits d'entrée, il existe 4 combinaisons. crée un circuit qui sélectionne une sortie pour chacune des 4 combinaisons. Pas plus ni moins d'un bit ne doit être [T] à la fois.



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

$44918705544255* Désactivé



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

$28695849165746* Avec 3 bits d'entrée, il existe 8 combinaisons. Crée un circuit qui sélectionne une sortie pour chacune des 8 combinaisons. De plus, il existe une entrée de désactivation. Lorsqu'elle est [T], toutes les sorties doivent être [F].

$43603044118584* Décodeur 3 bits



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

$10870388349665* La sortie {cycle} devrait être [T] et les autres sorties [F].

$18073111523064* Toutes les sorties devraient être [F] puisque le bit de désactivation est [T].



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

$20191487800946* bit attendu

$23128720321555* désactivé

$23707304171214* Assure-toi que la sortie est toujours [F] lorsque le bit de désactivation est [T].



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

$21613887420121* Ce circuit simple dont l'entrée dépend de sa propre sortie est une boucle NOT

$57091568089512* regarde ce fil rouge en erreur

$64834808154176* C'est une erreur dans les autres niveaux, mais le but de celui-ci



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

$13967626449720* Certains sont même trompeurs, comme cet exemple, qui peut faire sens d'un point de vue purement logique.

$71118235828147* La dépendance circulaire peut être complexe, impliquant de nombreux câbles et composants différents.



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

$24156270270079*
Crée une «dépendance circulaire». Il s'agit d'un circuit où l'entrée d'un composant dépend de sa propre sortie. Dans une situation de dépendance circulaire, Il n'est pas possible de déterminer la sortie d'un composant, car il faudrait d'abord déterminer l'entrée, qui dépend de la sortie et ainsi de suite (d'où le terme « circulaire »).

Cet état n'est normalement pas autorisé dans les autres niveaux, mais dans ce niveau, l'objectif est de le causer, pour comprendre de quoi il s'agit avant d'aller plus loin.

$25862237357880* Dépendance circulaire

$57043666310618* Je ne suis pas sûr que cela profite aux élèves, mais les enseignants adorent ça.

$60783049086609* Dans notre système éducatif, nous enseignons traditionnellement en amenant les élèves à faire une erreur par un piège, pour ensuite les taquiner.



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

$28070798445412* crée un circuit qui délivre le même signal en sortie qu'en entrée, mais avec un retard(délai) de 2 cycles.

$66914768639545* Ce niveau introduit le composant de ligne à retard(délai). il prend son entrée et la restitue un cycle plus tard.

$81657957055974* Ligne a retard(délai)



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

$13944257184132* Dans ce niveau, un octet (groupe de 8 bits), est fourni. nous devons donc les diviser et les fusionner.

$16215081868720* Jusqu'à présent, nous avons travaillé uniquement avec des bits, un signal [T] ou [F].



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

$29000872588470* Doubler un nombre en binaire revient à décaler la position du bit d'une unité.



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

$46697878992908* Double le nombre

$78449227663032*
Ce niveau introduit les valeurs d'octets, qui sont représentés par des nombres compris entre 0 et 255. Les octets sont composés de 8 bits, chaque bit représente un chiffre binaire du nombre. On te donne deux nouveaux composants, l'un d'eux prend un octet et le divise en bits, tandis que l'autre fait l'inverse.

En utilisant ces composants, trouves comment doubler le nombre d'entrée (jusqu'à 127).



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

$24718289227251*
Bienvenue à la fonderie, Les circuits que tu crées ici pourront être utilisés comme composants dans d'autres niveaux.
Le circuit que tu crée définit le comportement du composant et la disposition définit sa forme.

$62612312608874* Puisque ce niveau est un outil et non un défi, tu peux aller à la carte des niveaux et continuer quand tu le souhaites..

$72171231322685* La Fonderie

$88436914545275* Il est possible d'ajouter, de renommer ou de supprimer des composants à l'aide du menu Schémas.



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

$50970897346580* La somme requiert le même raisonnement qu'au niveau « Nombre impair de signaux ».



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

$54848313056941* La Retenue est [T] si et seulement si les deux entrées sont [T].



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

$13880107359455* Cela reste un exercice laissé au joueur !

$18497022543669* Cette solution n'est pas la plus élégante ni la plus optimale.



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

$12555311310864* Entrée 0

$13755587162128* Entrée 2

$34717193596171* Retenue

$41149959264274* Entrée 1

$50183740481245* somme



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

$34381936755276*
Au niveau précédent, nous avons additionné 2 entrées, cette fois, nous en avons 3. Une fois encore, additionnes les entrées en binaire, tel que le résultat soit soit [b]0[/b] soit [b]1[/b].

Comme pour une addition normale, si le résultat ne peut pas être décrit avec un seul chiffre, définis la retenue sur [b]1[/b].

$42735906141201* Additionneur complet



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

$40317306745068* Somme attendue

$49855734765642* Retenue attendue

$51965136043073* Retenue actuelle

$84617036256734* Somme actuelle



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

$11327399415058* Ce niveau est mon deuxième passe-temps favori : convertir de l'hexadécimal en binaire sous la pression du temps.

$45399195121692* Course hexadécimale

$65517909958697*
Lorsqu'il s'agit de nombreuses données binaires, le langage peut devenir difficile à lire. Hexadécimale (base 16) représente chaque combinaison de 4 bits avec son propre caractère:

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]

Prenons l'exemple d'un système où l'hexadécimal est plus clair : comparons la représentation du plus grand nombre sur 16 bits:
[left]
              Binary:      1111111111111111
              Decimal:     65535
              Hexadecimal: FFFF
[/left]
Il n'est pas facile de déterminer si le binaire comporte un chiffre manquant ou si le nombre décimal est correct, L'hexadécimal, en revanche, est immédiatement clair. (une fois qu'on s'habitue à la représentation bien sûr).

$87098190175913*
Ajuste les bits dans le panneau de niveau pour que leur somme corresponde au nombre hexadécimal de la question.

Tu dois réussir le niveau 3 pour passer.



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

$26182817405385*
Félicitations, tu as été enlevé.

Nous te testons à bord de notre vaisseau spatial.

Construis un ordinateur fonctionnel et ton espèce pourra rejoindre la Fédération Galactique.

$44716420394020* Débuts Modestes

$76679675871478* Ce premier test évalue ta compréhension des circuits. Tu disposes ici d'une entrée et d'une sortie reliées par un fil. Active l'entrée dans le menu de gauche pour compléter le circuit.



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

$35186537961257* Ce niveau a pour but de s'assurer que tu maîtrises la logique booléenne avant de passer à la suite. Maîtriser ce domaine te sera très utile pour la suite.

$39180730338379* Tu vas être testé sur plusieurs circuits différents ici. Lorsque tu clique sur le bouton « Exécuter », ton circuit sera testé et tu recevras une marque verte s'il est correct, ou une marque rouge dans le cas contraire. Le niveau est terminé lorsque 4 des 5 indicateurs dans l'encadré historique ci-dessous sont verts.

$39721874026332* Excellent travail. Maintenant que tu maîtrises bien la logique booléenne, Il est temps de travailler à la construction de ton premier ordinateur. Mais tu dois d'abord apprendre les notions de mémoire et d'arithmétique binaire. Le chemin vers la maîtrise est aussi long qu'il est satisfaisant.

$57679157572023* Examen de logique



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

$32183772878666* Histoire



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

$10423837492124* [left][b]Tourner à gauche[/b][/left]

$18756407685566* [left][b]Tourner à droite tant qu'un mur est en face[/b][/left]

$51767168505953* [left][b]répéter[/b][/left]

$60076150664554* En suivant toujours le côté gauche (ou droit) du labyrinthe, tu finiras par atteindre la sortie.

$63325960964451* [left][b]Un pas en avant[/b][/left]

$66501964970865* Le pseudo-code d'un tel algorithme ressemble à ceci :



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

$19088384441761*
Lis les entrées pour déterminer ce que le robot voit devant lui. ce sera toujours un de ses résultats :
0 Rien
1 Mur


$56722492138232* Excellent travail. tu as terminé le labyrinthe et maîtrises désormais parfaitement l'assemblage d'Overture. Mais Overture est trop basique, c'est bon pour apprendre, mais il lui manque de nombreuses fonctionnalités. Ton prochain projet sera de construire Symphony, un ordinateur plus puissant doté de RAM, d'un écran, d'un clavier et te permettant de réutiliser du code grâce à des fonctions. En chemin, tu devras construire de nouveaux composants, en apprendre davantage sur la pile et d'autres choses.

$84960209408475*
Dans ce niveau, tu contrôles un robot. Écris un algorithme qui le guide du départ jusqu'à la porte située à la sortie du labyrinthe.

Voici les trois commandes que tu peux envoyé en sortie:
0 Tourner à gauche
1 Avancer
2 Tourner à droite

Tu peux également utiliser les touches fléchées pour manipuler le robot manuellement.

$90660848232877* Le labyrinthe



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

$23027113131109* représente ce nombre modulo 2 (pair ou impair), les 3 bits de poids faible modulo 8, et ainsi de suite.

$35037773638556* De même, en décimal, 4321 modulo 100 est également simple

$40190253854900* En binaire, calculer le modulo 4 d'un nombre revient à n'utiliser que ses deux bits de poids faible.

$44666331884152* En effet, les bits de poids fort représentent 4, 8, 16, etc., et sont divisible par 4 sans reste.

$47075416850998* Ceci est vrai en général pour le modulo d'une puissance de 2, le bit de poids faible d'un nombre

$79521133202800* (La réponse est 21, les chiffres de plus grande valeur sont ignorés, car 100 est une puissance de 10)

$81555476661504* Il te suffit maintenant de trouver comment obtenir les deux derniers chiffres d'un nombre



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

$46388374967041*
Dans ce niveau, tu as un nombre en entrée et tu dois renvoyer ce nombre modulo 4.

Le défi est que tu n'as que 8 cycle pour obtenir le résultat souhaité.

Note: Tu n'as pas besoin de modifier ton matériel, Il te suffit de trouver l'astuce pour calculer rapidement le modulo 4.

$71000564779980*
Notre semaine compte quatre jours. Nos jours de semaine s'appellent le Jour Zéro, le Jour Un, le Jour Deux et le Jour Trois. J'ai entendu dire que certains Terriens numérotent incorrectement leur Jour Deux ?
  
Cela ne me surprend pas vraiment.

$76392666043520* Quoi qu'il en soit, la nouvelle année approche et nous voulons que tu calcules le jour de la semaine correspondant à l'anniversaire de chacun. Nous te fournirons la date et il te suffira de renvoyer le jour de la semaine en moins de 8 cycles d'horloge.

$78836302049950* Mod 4



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

$13853243145042* Tu dois donner le résultat avant le cycle 8!

$59240995307159* lis d'abord l'entrée.

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



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

$44500958231665* Multiplie deux nombres. Si le résultat ne tient pas dans 8 bits, ignore les bits supplémentaires.

$54529139494347* Multiplier



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

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

$46804407616321* L'octet de poids faible de {a} * {b} est {result}

$83214947196979* Multiplie deux nombres



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

$77112891598455* Multiplie deux nombres



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

$36846418389807* Toutes les espèces animales de la Terre traversent la même épreuve, pour voir si tu possédes l'intelligence nécessaire pour apprendre à construire un ordinateur.

$39082333495604* Porte NAND

$50880631203389* Correct! Tu as débloqué la porte NAND. À partir de ce bloc de construction fondamental, tu construiras tout le reste dans ton ordinateur.

$65167079914703* Cette première section porte sur la "logique booléenne". La logique booléenne décrit les formes d'opérations les plus simples que les ordinateurs peuvent effectuer. En fait, ces opérations sont à la base de tous les autres calculs dans l'ordinateur.

$68865507501612* Ce circuit contient une "porte NAND" que je veux que tu l'examines. Je veux que tu documentes son comportement en remplissant la "table de vérité" dans le panneau que tu vois ci-dessous. Seules les deux premières lignes de la table de vérité sont remplies. Ta tâche est d'expérimenter avec les entrées du circuit, d'observer ce que fait la porte NAND et de remplir la dernière ligne de la table de vérité.



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

$16731935541997*
Ce niveau introduit le « complément à deux », la représentation la plus courante des nombres négatifs.
  
Ici, le bit de poids fort est inversé. Pour les octets, cela signifie que le 8e bit passe de 128 à -128..

Tu dois terminer le niveau 2 pour réussir.

$20753698232132* Nombres négatifs

$87951492143019* Pour connaître la différence entre deux choses, il faut soustraire. Pour soustraire, il faut d'abord des nombres négatifs.



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

$19817843844200* Nim

$47072576894526* De plus, les schémas sont partagés entre les différents niveaux d'architecture, tu peux donc résoudre ce problème avec Overture ou Symphony. Clique sur l'icône de fichier en haut à gauche pour changé de schémas.

$53912339443439*
Dans ce niveau, tu dois battre l'IA à un jeu de cartes simple. Voici sont les règles: 

Il y a 12 cartes sur la table et chaque joueur, à son tour, doit piocher entre 1 et 3 cartes. Le premier joueur à piocher la dernière carte (le joker) perd.

Lire l'entrée t'indiquera le nombre actuel de cartes. L'envoi de 1, 2 ou 3 en sortie sélectionnera ce nombre de cartes. L'adversaire réagit immédiatement, tu peux donc lire l'entrée immédiatement après ta sortie pour obtenir le résultat de son action.



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

$27262056315410* Perdu!

$29769682738867* Tu ne peux prendre que 1, 2 ou 3 cartes.

$42147812867053* Tu as gagné!

$49299754864790* Appuie sur Entrée pour prendre {card_count} cartes

$64085588225039* Appuie sur Entrée pour voir ce que fait l'adversaire

$85502688597126* Utilise les touches fléchées pour prendre des cartes

$90440029783715* Tu as pris la dernière carte



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

$79378464416004* Utilise les touches fléchées pour prendre des cartes



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

$18962231551900* si et seulement si l'entrée 0 ET l'entrée 1 sont toutes deux [F].

$68908249643417* La table de vérité indique que la porte NOR est [T].



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

$14349743750598* La porte AND peut être interprétée comme une porte NOT-NOT-AND, ou une porte NOT-NAND.



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

$37240300421781*
La plupart des créatures sur Terre sont agressives et incapables de se concentrer.

Pour réussir, tu dois apprendre à penser de manière logique, sans pour autant détruire les choses.

$56653221050913* Crée le circuit qui correspond au tableau.

$72918877035793* Porte NOR



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

$26513163439009* Le seul composant dont nous disposons est la porte NAND.



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

$20946507323050* Lorsque les deux entrées sont [T], la sortie est [F].

$88952480145102* Lorsque les deux entrées sont [F], la sortie est [T].



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

$16394937100308* Porte NOT

$56423993638708* Au niveau précédent, tu as établi la table de vérité décrivant le circuit. Dans ce niveau, tu construis le circuit correspondant à cette table de vérité.

$64052600264884*
Construis une porte NOT à l'aide de portes NAND.

En utilisant: [b]une porte NAND[/b]
\#Entrée 0: [F][T][F][T]
\#Entrée 1: [F][F][T][T]
\#Sortie:  [T][T][T][F]

construis: [b]une porte NOT[/b]
\#Entrée: [T][F]
\#Sortie:  [F][T]

$80163590000700* Maintenant que tu as déverrouillé la porte NAND, il est temps pour toi de construire toi-même un circuit.



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

$17243045715726* Tu peux déterminer si deux entrées ont un nombre impair de [T] avec un seul composant.



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

$39747324204871* Et si, au lieu de les associer à On/Off, on les imaginait comme pairs/impairs ?

$80670337048058* Jusqu'à présent, le [F] était considéré comme désactivées et le [T] comme activées.



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

$28104365880572* nombre pair + nombre pair = nombre pair

$49444546097133* nombre impair + nombre impair = nombre pair

$57603105454008* Avons-nous un composant qui a ce comportement ?

$59534613718377* nombre impair + nombre pair = nombre impair



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

$47175212977659* C'est vers la porte XOR qu'il faut se tourner



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

$44190469254011* Nombre impair de signaux

$63242509760527* En utilisant un maximum de 3 composants, envoies [T] en sortie uniquement quand un nombre impaire d'entrée est sur [T]



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

$36609687959808* {count} sur 3

$40553112323959* Tu ne peux pas utiliser plus de 3 composants dans ce niveau.



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

$74552564780850* Composants utilisés



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

$69947751578736* L'entrée n'est qu'une distraction.

$75667038547709* L'information provient du nombre de cycles, et c'est là que la ligne à retard excelle.



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

$14188568517859* La ligne à retard peut boucler sur elle-même

$88356074900046* pour créer un signal basé sur le nombre de cycles



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

$17699211754487* Dans un niveau précédent, tu as appris que nous n'autorisons pas les dépendances circulaires. Tu dois maintenant apprendre l'unique exception.

$54648226811178* Cycles Impaire

$60625429879527*
Les broches orange n'affectent jamais la sortie au cours du même cycle. Ils ne provoquent donc jamais de dépendances circulaires.
  
  [image="delay_line.png"]

$75292456030647*
La ligne à retard peut dépendre de sa propre sortie. En effet, son entrée n'influence pas le reste du circuit avant le prochain cycle.
  
[image="delay_line.png"]

$85913836277587* Envoie en sortie [F] sur les cycles pairs et [T] sur les cycles impairs.



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

$28460985244857* L'un des composants dont tu as besoin est un décalage



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

$49063245216494* Ce niveau utilise le composant LSL (Left Shift/décalage à gauche) précédemment implémenté.



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

$12296593054599* Encodage one-hot

$17817215316423*
L'entrée détermine quelle sortie doit être [T]. Si l'entrée est 7, envoie [T] à la 7e sortie et [F] à toutes les autres.

N’utilise pas plus de 3 composants. De plus, tu ne peux utiliser aucun des décodeurs que tu as construits précédemment.



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

$60812617177494* N’utilise pas plus de 3 composants.

$74562193652628* La sortie sur la broche {pin} est incorrecte.



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

$29061908449874* si et seulement si les deux entrées ne sont pas toutes deux [F]

$49190016957852* La table de vérité indique que la porte OR est [T]



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

$46797361496226*
Crée le circuit qui correspond au tableau.
[tip]Double-clique sur un composant pour le déplacer avec les fils connectés.[/tip]
  

$81822607191994* Porte OR



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

$67313804184537* Un OR plus grand n'est autre que plusieurs OR successifs.



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

$29275887429601* Crée une porte OR à 3 entrées.

$68089739910654* Grande Porte OR



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

$15378963142694* Entrée 2



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

$58396790216558* Déplace une valeur depuis %b vers %a.



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

$25938996008186* avec la source à la place des entrées et la destination à la place des sorties

$87908319845833* Ce niveau est similaire à « The Bus ».



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

$66937784075495* Nous utilisons ensuite des décodeurs pour trouver la source et la destination activées.



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

$13757092116124*
La [color=#ff6680]source[/color] et la [color=#e49f44]destination[/color] peuvent être l'un des six registres, que nous nommerons respectivement de REG 0 à REG 5. 
  
De plus, ce niveau possède un composant d'entrée dédié, qui peut être la [color=#ff6680]source[/color] et un composant de sortie, qui peut être la [color=#e49f44]destination[/color].

$36376879506769* Il est enfin temps de construire ton premier ordinateur. Je vais t'apprendre à construire l'architecture [color=#e49f44]Overture[/color], une véritable machine Turing complète, un véritable ordinateur à tous égards.

$61875924861326* Dans ce niveau, tu dois créer un circuit capable de déplacer une valeur depuis une [color=#ff6680]source[/color] vers une [color=#e49f44]destination[/color].

$79626649565563* Registres

$87179643828952* Voici les séquences binaires pour chaque [color=#ff6680]source[/color] et [color=#e49f44]destination[/color].



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

$18540192543555* Le registre {reg_i} devrait avoir la valeur {value}.

$51132330915663* La sortie n'est pas activée.

$75546240775660* Sortie attendue : {value}.

$85392755740261* La sortie ne doit pas être activée.



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

$77115196290575* Construis le circuit du registre



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

$57911760722636* Déplace une valeur depuis %b vers %a.



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

$17602708328746*
Il est temps d'intégrer le circuit "unité arithmétique et logique(ALU)" que tu as réalisé précédemment au circuit de registre. Le circuit ALU a été sauvegardé à la fonderie et peut maintenant être ajouté comme composant. Si tu as oublié à quoi sert chaque broche, consulte le circuit dans la fonderie.

Utilise le décodeur que tu as construit pour déterminer s'il faut effectuer un déplacement entre les registres ou des calculs ALU. Voici à nouveau les 4 modes différents:
[left]      
            [F][F] Immédiat
            [F][T] ALU
            [T][F] Move
            [T][T] Condition
[/left]

Pour ce niveau, tu n'as à te soucier que du mode déplacement et du mode ALU. En mode ALU, prends les registres [color=#e49f44]REG 1[/color] et [color=#e49f44]REG 2[/color] comme entrées et stocke le résultat dans le registre [color=#e49f44]REG 3[/color].

[tip]N'oublie pas que le composant décodeur 3 bits possède un bit de désactivation.[/tip]

$76398546711745* ALU



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

$27417572090527* La sortie est désactivée.

$45837083894306* Sortie attendue :{value}.

$67011612338355* Le registre {reg_i} devrait avoir la valeur {value}.

$84026509534190* La sortie ne doit pas être activée.



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

$49706182840588* Intégre l'unité arithmétique et logique (ALU) au circuit.



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

$50864238070873* Déplace une valeur depuis %b vers %a.



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

$23614311904581* Valeurs immédiates

$63109056149876*
Nous avons besoin d'un moyen de transférer directement les chiffres de notre programme vers les registres. Pour cela, nous utilisons le mode immédiat (lorsque les deux bits de poids fort sont [F][F]).

En mode immédiat, l'octet entier est interprété comme un nombre que nous stockons dans le registre 0. Cela signifie que nous pouvons
stocker n'importe quelle valeur comprise entre 0 et 63.



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

$17793323757435* Sortie attendue :{value}.

$63497936956369* La sortie ne doit pas être activée.

$73489311755739* Le registre {reg_i} devrait avoir la valeur {value}.

$82564442776805* La sortie est désactivée.



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

$57764930098721* Ajoute des valeurs immédiates au circuit



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

$26930827349244* Déplace une valeur depuis %b vers %a.



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

$10102035559374* Programme

$58149108600515* Le composant d'entrée d'instructions a été supprimé. Il a été remplacé par un composant RAM contenant le programme. La RAM possède un "port de chargement" qui lui est connecté. Lorsque la broche d'activation du port de charge est activée, Il enverra en sortie une valeur provenant de la RAM, d'après l'adresse donnée. Chaque cycle, utilise le compteur pour charger l'instruction suivante depuis la mémoire du programme.



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

$19443898128380* La sortie ne doit pas être activée.

$49097812105667* Le registre {reg_i} devrait avoir la valeur {value}.

$50052313044113* La sortie est désactivée.

$73023200204536* Le compteur devrait avoir la valeur : {expected_value}.

$88140381331491* Sortie attendue : {value}.



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

$62678678871254* Ajoute un programme au circuit



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

$37075142107851* Reg 2

$38743609381557* Reg 1

$40362507068221* Reg 4

$57061942907076* Reg 5

$79357977314471* Reg 3

$82470056393191* Reg 0



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

$27747401844990* Tu as réussi ! Je te prenais pour une étrange créature simiesque et sans poils, mais tu as bel et bien construit un véritable ordinateur ! Incroyable.

$59169726539090* Turing Complete

$77166984247940* Jusqu'à présent, tous les programmes possibles étaient limités à une exécution séquentielle octet par octet.

$85320707451673* Auparavant, seul le code pouvait influencer la mémoire , désormais, c'est la mémoire qui doit influencer le code. Grâce à l'ajout de la logique conditionnelle, notre ordinateur peut exécuter n'importe quel algorithme et calculer tout ce qui est calculable. Comme tous les ordinateurs non théoriques, cette machine ne sera limitée que par sa mémoire finie.

$89085328104477*
La dernière chose qu'il nous faut ajouter est un mécanisme permettant de modifier le compteur de programme par le biais d'instructions lorsque certaines conditions sont remplies.

Lorsque les deux bits de poids fort sont [T][T], nous sommes en mode conditionnel. En mode conditionnel, la valeur du registre 3 est comparée aux conditions définies par les 3 bits de poids faible de l'instruction. Si la condition est vraie, nous écrasons le compteur avec la valeur de REG 0.
Modifier le compteur de manière conditionnelle signifie que nous pouvons ignorer des instructions en fonction de conditions ou exécuter des instructions dans une boucle.

Conditions:[left]
                    [F][F][F] Jamais
                    [F][F][T] Toujours
                    [F][T][F] Si [color=#e49f44]REG 3[/color] = 0
                    [F][T][T] Si [color=#e49f44]REG 3[/color] ≠ 0 
                    [T][F][F] Si [color=#e49f44]REG 3[/color] < 0
                    [T][F][T] Si [color=#e49f44]REG 3[/color] ≥ 0
                    [T][T][F] Si [color=#e49f44]REG 3[/color] ≤ 0 
                    [T][T][T] Si [color=#e49f44]REG 3[/color] > 0
[/left]        
Ces conditions correspondent au composant de condition qui a été enregistré dans la fonderie.



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

$17521915837347* La sortie ne doit pas être activée.

$33411257451562* Sortie attendue : {value}.

$36308361121667* La sortie n'est pas activée.



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

$65145204616501* Ajoute les conditions au circuit.



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

$18505654344513* Saute vers r0.

$21095867785396* AND r1 et r2 et stocke le résultat dans r3.

$24147817394058* Saute vers r0 si r3 est plus petit que 0.

$26704206992933* NAND r1 et r2 et stocke le résultat dans r3.

$33850592701591* SUB r1 et r2 et stocke le résultat dans r3.

$42577908074742* Déplace %a vers r0.

$43876958520450* Saute vers r0 si r3 n'est pas 0.

$45432635426071* Déplace une valeur de %b vers %a.

$46599288949396* Saute vers r0 si r3 est 0.

$48758564562305* Saute vers r0 si r3 plus petit ou égal à 0.

$58823897430160* OR r1 et r2 et stocke le résultat dans r3.

$64808551937719* Saute vers r0 si r3 est plus grand ou égal à 0.

$71072332861445* Ne fait rien.

$75067212691206* NOR r1 et r2 et stocke le résultat dans r3.

$75524550463342* ADD r1 et r2 et stocke le résultat dans r3.

$88048573834702* Saute vers r0 si r3 est plus grand que 0.



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

$15531830527231* r3

$17025449350330* r5

$42538649427331* Programme

$47858891143005* r2

$57877356797542* DoneCount

$59383212597903* r0

$76878335565401* r4

$78214997465973* Compteur

$89909032864119* r1



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

$35331465118106* Overture

$59797408403606*
Le seul but de ce niveau facultatif est de te permettre d'expérimenter à quel point tu peux optimiser Overture. Contrairement aux niveaux précédents, ce niveau ne t'oblige pas à exécuter exactement une instruction par cycle.
  

$59818810946218* Par défaut, ce niveau vérifie uniquement que tu envoies les valeurs correctes en sortie. Tu peux également choisir de faire vérifier l'état des registres, ce qui est très utile pour le débogage, mais cette option est facultative. Pour faire vérifier l'état de tes registres, envoie le nombre d'instructions terminées à chaque cycle au composant nommé "DoneCount".

$84590049728141* Note que si tu remplaces le type de mémoire vive par de la DRAM, tu peux définir la profondeur de pipeline de la mémoire. Par exemple, si tu régles la profondeur sur 2, les opérations de lecture et d'écriture nécessiteront deux cycles d'horloge, mais la latence de la mémoire sera divisée par 3.



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

$24524168624111* Le compteur devrait indiquer {expected_value}.

$35224907301551* Le registre {reg_i} devrait avoir la valeur {value}.

$45858569181521* Tu as lu {.input_index} entrées, mais tu étais censé en lire {.emulator_input_index}.



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

$22306447815263* Optimiser Overture



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

$17808301775724* Ce niveau est similaire à "Multiplexer"

$69085851994491* Les résultats des opérations NAND, OR, AND et NOR permettent de remplacer l'entrée A/B.



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

$76898193108851* Le switch à activer peut alors être trouvé à l'aide d'un décodeur.



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

$16562043259074* Unité arithmétique et logique (ALU) 1

$31234606133949*
crée un dispositif capable d'appliquer OR, NAND, NOR ou AND sur deux octets d'entrée. La troisième entrée sera l'instruction. Une instruction, c'est simplement le nom donné au nombre qui détermine ce qu'il faut calculer.

Instructions:

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



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

$30599543511275* Une extension utilisant un décodeur 3 bits au lieu d'un décodeur 2 bits

$61118397217284* A SUB B est comme A ADD (NEG B)



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

$20519420764551* Unité arithmétique et logique (ALU) 2

$39134024311972*
Ajoute l'addition et la soustraction à ton circuit.

Instructions:

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



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

$53936374688885* Opcode



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

$30858693828450* Alors, connectons tout ça au bus

$41615813866999* Les parties « Jamais » et « Toujours » sont les plus faciles.

$73479968135998* Maintenant, pour vérifier si la valeur est égale à 0, nous devons vérifier que tous les bits sont à [F].



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

$71744044447857* Pour vérifier que tous les bits sont à [F], nous décomposons la valeur en bits et appliquons une porte NOR à grande échelle.

$78036114842982* Ensuite, pour une valeur inférieure à 0, nous vérifions si un nombre binaire est négatif.



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

$16809493892244* Pour vérifier si un nombre binaire est négatif, il suffit de vérifier si le bit de signe est [T].

$70638453446538* Les autres conditions ne sont que des combinaisons de valeur = 0 et valeur < 0



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

$19520914707885* [left]valeur ≥ 0 signifie NOT (valeur < 0)[/left]

$44207156733924* [left]valeur ≤ 0 signifie (valeur < 0) ou (valeur = 0)[/left]

$75072852663289* [left]valeur > 0 signifie NOT (valeur ≤ 0)[/left]



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

$71466914240996*
Ce niveau dispose d'une entrée de valeur et d'une entrée de condition sur 3 bits.

Les 3 bits sélectionnent la condition comme indiqué ci-dessous. Vérifie la valeur par rapport à la condition sélectionnée et envoie en sortie [T] si la condition est remplie et [F] si elle ne l'est pas.

[left]
             Bit code:     Turn [T] when:
              [F][F][F]       Jamais
              [F][F][T]       Toujours
              [F][T][F]       Si valeur = 0
              [F][T][T]       Si valeur ≠ 0
              [T][F][F]       Si valeur < 0
              [T][F][T]       Si valeur ≥ 0
              [T][T][F]       Si valeur ≤ 0
              [T][T][T]       Si valeur > 0
[/left]

$83283206082997* Conditions



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

$74974087807935* TOUJOURS

$80507287196650* JAMAIS



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

$11886599003881* valeur

$38979555213581* Description

$43384041502940* valeur

$81487261104241* Condition



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

$15645900189277* Déplacer(move)

$60698949860454* ALU

$90597971391617* immédiat



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

$44644153822563* Le circuit que tu as construit au niveau "Registres" peut copier des valeurs entre les registres, alors que la "partie arithmétique" peut effectuer différentes opérations sur 2 entrées. Mais tu dois pouvoir faire les deux dans le même circuit. Pour ce faire, construis un 'décodeur' qui déterminera le mode de fonctionnement de notre ordinateur en fonction des 2 bits que nous n'avons pas encore utilisés.

$62355105651643*
Pour distinguer les instructions de 4 types différents, les deux bits de poids fort seront utilisés pour déterminer le MODE actif, comme suit:

[left]
                [F][F][Z][Z][Z][Z][Z][Z] Immédiat
                [F][T][Z][Z][Z][Z][Z][Z] ALU
                [T][F][Z][Z][Z][Z][Z][Z] Move
                [T][T][Z][Z][Z][Z][Z][Z] Condition
[/left]
Ici, [Z] signifie n'importe quelle valeur.

Détermines le MODE actuel à partir de l'entrée, puis envoies [T] à la sortie correspondante.

$81732613304305* Décodeur d'Instructions



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

$23393810721136* ALU

$41856942338650* Condition

$67613074322431* Move

$71705253055197* Valeur Immédiate



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

$35299017249605* Mode souhaité

$55162862394836* Instruction



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

$46932595269557* Aperçu du hub



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

$78694087261378* Aperçu du hub



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

$32597308066943* Tout d'abord, plaçons nos 4 octets de mémoire dans le niveau.



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

$73686127519870* Ensuite, nous devons décider de la cellule mémoire à partir de laquelle charger/enregistrer

$86131527203527* C'est là qu'un décodeur devient utile.



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

$51243843817679* Grâce à la sortie [T] du décodeur, la cellule mémoire correspondante peut être chargée.

$78963222298606* N'oublie pas un autre switch pour n'émettre que lorsque LOAD est [T].



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

$51887730294248* Câble cela et Il ne reste plus qu'à activer la cellule mémoire appropriée

$65959445914539* La valeur à enregistrer dans une cellule provient d'une seule entrée



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

$10655955073336* Charger

$46688176903674* Addresse



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

$14374127314134* Petite boîte

$68663841862704*
Dans ce niveau, tu dois construire un circuit capable de 
stocker ou charger des données à partir de 4 octets de mémoire différents.

Tu disposes d'un bit qui détermine si tu dois charger. Un autre bit détermine si tu dois stocker et il vient avec une valeur correspondante.
De plus, tu disposes de 2 bits d'adresse. 

Avec 2 bits, il existe 4 combinaisons, une pour chaque octet de mémoire de ce niveau.

[tip]La barre d'espace permet de faire pivoter les composants.[/tip]

$76851096880864* Peut-on faire tenir 4 octets de mémoire dans cet espace limité ?



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

$29258463778822* La sortie était Z, mais elle aurait dû être {expected_value}.

$45179662026844* La sortie aurait dû être Z.

$48251194975794* La sortie était {actual_value}, mais elle aurait dû être {expected_value}.

$52597500133853* Sauvegarder {text_value} vers {text_add}

$55086379351729* charger {text_state} depuis {text_add}



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

$22107475451139* [left]charger ??? vers ??[/left]

$27304327624610* [color=#E49F44][b]valeur[/b][/color]

$27457656265551* [color=#E49F44][b]Sauvegarder [/b][/color]

$57378010777762* [left]Sauvegarder ??? depuis ??[/left]

$62207646058430* [color=#E49F44][b]charger [/b][/color]

$62589960113273* [color=#E49F44][b]Addresse[/b][/color]

$71008031461945* [color=#E49F44][b]  Valeur   [/b][/color]

$85306375920893* [color=#E49F44][b] Addresse  [/b][/color]



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

$18488351703350* Savais-tu comment nous, robots déterministes, pouvons être créatifs et produire des pensées originales ? La réponse réside dans les générateurs de nombres aléatoires.

$83969937380086* Générateur De Nombres Aléatoires

$90664310835282*
Dans ce niveau, tu ne disposes que d'une seule entrée, que nous appelons la graine(seed) initiale. La graine est soumise aux étapes suivantes pour produire un nombre pseudo-aléatoire.

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

Enfin, envoie le résultat en sortie et utilise-le comme graine de l'itération suivante.



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

$77825640575531* La prochaine graine(seed) devrait être {result}, et non {output}.



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

$58382627590046* Le bac a sable



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

$73980120059844* Nous créons simplement la version binaire du niveau « Sauvegarder avec grâce »



=== campaign/saving_bytes/meta.txt ===

$41663630841312* Sauvegarde d'octets

$87293777622656*
Crée un circuit qui peut sauvegarder un octet.

Quand l'entrée "SAUVEGARDER" est [T], sauvegarde l'octet d'enrée.

Envoie la valeur stockée vers la sortie.



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

$60269032570207* Sortie attendue : {expected_output}.



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

$14624167685294* Dans ce niveau, Tu dois utiliser 1 ligne à retard(Delay Line)

$52905927349424* Les entrées sont les deux entrées de niveau ET la sortie de la ligne à retard, car la sortie joue un rôle dans l'entrée.

$61760299843073* Considére l'entrée de la ligne à retard comme la sortie de ta table.

$83682732712729* Établis une table de vérité pour déterminer les valeurs à insérer dans la ligne à retard

$90057665917240* Une fois que tu auras établi une table des exigences de niveau, la résolution du problème devrait être beaucoup plus facile.

$90652401745526* Au total, tu dispose de 3 « entrées » pour cette table, ce qui te donne 8 combinaisons.



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

$16548183735739* cependant, sa mémoire dure un seul cycle, boucler sur elle-même permet de rafraîchir en continue

$64973475823722* Le seul composant dont nous disposons et qui possède une « mémoire » est la ligne à retard,



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

$11101940160071* Lorsque la broche Action est [T] ou en mode Sauvegarde, nous souhaitons la remplacer par la valeur

$19959785727663* Mais cela provoquera un court-circuit.



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

$10919459809145* On utilise donc un multiplexeur pour déterminer la valeur à écrire sur la ligne à retard



=== campaign/saving_gracefully/label.txt ===

$88860903896097* Sauvegarder



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

$13114757255411*
Dans ce niveau, tu as 2 entrées.
Lorsque la première entrée est [T], mets à jour la valeur stockée.
La deuxième entrée est la nouvelle valeur destinée à mettre à jour la valeur stockée.
Renvoie toujours en sortie ce qui est actuellement stocké.

$39874917169400* Sauvegarder avec grâce

$61501859914469*
La ligne à retard ne nous permet de stocker une valeur que pendant 1 cycle . Mais parfois, un composant capable de stocker une valeur pendant de longues périodes est utile.

Nous voulons que tu construises un tel composant.



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

$10654649810679* Sauvegarde

$63465863198591* Valeur



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

$71529804454649* Crée une version octet des demi-additionneurs, puis additionne l'entrée et 1.



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

$75346310834154* Le signal [T] étant constant, on peut simplifier le circuit à cet endroit



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

$50044461577278* Le dernier résultat du AND n'est pas utilisé, nous pouvons donc le supprimer sans risque.



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

$34375498293137* Ce niveau introduit un système de notation de l'efficacité, basé sur le temps et l'énergie.

$38383835706006*
Pour résoudre ce niveau, ajoute 1 au nombre en entrée et envoie le résultat en sortie.

Si le résultat ne tient pas sur 8 bits, ignores le bit qui ne tient pas.

Fais le avec au maximum 40 portes et 10 délais.

$40775045205647*
Le coût des composants que tu as débloqués dépend de ton score dans les niveaux où tu les as débloqués.

Si tu souhaites améliorer le coût d'un composant, tu peux revenir en arrière et optimiser ta solution au niveau qui le débloque.

En fait, pour réussir ce niveau, ta porte XOR dois coûter 3 portes et avoir un délai de 2.

$59781832788691*
Chacune des portes de base (NAND, NOR, AND, OR) ont un délai d'une unité, ce qui signifie qu'ils prennent une unité de temps pour s'executer.

Cependant, différentes parties d'un circuit peuvent se dérouler simultanément, il suffit donc d'attendre le chemin le plus lent, appelé « chemin critique ».

Clique sur le sablier en haut à droite pour afficher le chemin critique.

$70169388789757*
Ces équations sont égales, mais pas identiques:

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

Elles produisent le même résultat, mais le parallélisme permet à l'une d'être plus rapide que l'autre.

$72877144436007*
Chacune des quatre portes logiques de base consomme une unité d'énergie par unité de temps.

Le coût énergétique total de ta solution correspond donc au délai du chemin critique multiplié par le nombre de portes logiques fondamentales utilisées.

$78375324732864*
L'énergie utile, appelée exergie, est finie . Si nous la consommons entièrement, nous en serons au stade de la mort thermique de l'univers. C'est pourquoi l'efficacité est importante.

Dans notre société, nous trouvons l'inefficacité laide et l'efficacité belle.

En fait, nous mesurons la beauté en unités d'énergie.

$85893273691863* Beauté objective



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

$15039285047182* La sortie devrait être {expected}.

$46433606967015* Ajoute 1 à {cycle}



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

$85765173996083* Incrémente l'entrée de 1



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

$81345258398584* La table de vérité indique que la sortie est [T]

$87387306821265* si et seulement si l'entrée 0 est [T] ET l'entrée 1 est [F]



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

$11961528105462* Renvoie [T] uniquement au deuxième cycle.

$69913560783046* Deuxième Cycle



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

$59964726775903* en inversant ses bits (NOT octet) puis en ajoutant un.

$77523753173621* On peut obtenir le négatif d'un nombre binaire



=== campaign/signed_negator/hint_solution.txt ===

$49596217848125* Cela reste un exercice laissé au joueur !

$55687805352825* Cette solution n'est pas la plus élégante ni la plus optimale.



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

$15862778001173*
En prenant l'entrée comme signée (où le 8ème bit vaut -128), Crée un composant qui prend un nombre et inverse le signe.
Par exemple, 4 NEG deviendrait -4. -9 NEG devient 9.

$54237470041206* Négateur signé



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

$10529708471093* Entrée



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

$23043475637417* Dans ce niveau, ta tâche consiste à trier 16 nombres. Lis l'entrée 16 fois une par une, trie les et renvoie les en sortie de la plus petite à la plus grande.

$53593011909329* Une délicieuse commande

$79528307974753* Nous mettons à jour l'encyclopédie galactique de l'alimentation en y intégrant les aliments humains. Comme nous n'avons pas d'alphabet, les entrées de l'encyclopédie sont classées par ordre de déliciosité.



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

$25018662661467* L'index {index} dans la liste triée devrait être {expected}, et non {output}.



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

$17745932940157* Devait lire l'adresse {expected_value} en mémoire principale, et non {actual_counter}. La mise à jour du compteur a dù échouer au dernier cycle.

$21000091589999* La sortie devrait être {expected_output}, et non {output_value}.

$22469925230320* L'adresse mémoire persistante {i} est censée avoir la valeur {expected_value}, et non {value}

$29078414770160* Le registre 'zr' doit toujours être zéro (adresse 0 dans l'ensemble de registres/Register File).

$60841927788704* Le composant Temp n'aurait pas dû être activée depuis l'exécution de la dernière instruction time_0.

$70740757119887* {register} (l'adresse de registre {address}) devrait avoir la valeur {expected_value}, et non {actual_value}

$74663212299349* L'adresse mémoire principale {i} est censée avoir la valeur {expected_value}, et non {value}.

$85916420035294* La sortie aurait dû être activée.



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

$29798404581087* Stack(pile)

$68315222097089*
Le défi de ce niveau consiste à implémenter une structure de programmation courante appelée "stack" (pile en français). Tu es censé le faire en assembleur. Une pile permet de faire deux choses:
[left]
[color=#66ccff]PUSH[/color] - Ajouter un nombre à la pile(stack)
[color=#66ccff]POP[/color]  - enlever le dernier nombre ajouté de la pile
[/left]

On peut comparer la structure de données de type pile à une pile physique d'assiettes dans un restaurant bondé. Le lave-vaisselle [color=#66ccff]push[/color](empile) des assiettes sur la pile et le chef va les [color=#66ccff]pop[/color](dépiler).

Lis l'entrée de ce niveau pour obtenir l'opération suivante. 
Une entrée non-0 correspond à une opération d'empilement (push), dans ce cas, stocke la valeur afin de pouvoir la dépiler(pop) ultérieurement. 
Une valeur de 0 correspond à une opération de dépilement(pop), retire et envoie en sortie le dernier nombre que tu as enregistré.

$90806029597852*
Puisque la pile est si utile pour la programmation, les instructions "push" et "pop" seront ajoutées au niveau suivant de Symphony. Ces deux instructions sont synonymes de deux autres instructions et utilisent toutes deux le registre "sp" (abréviation de pointeur de pile) pour suivre la pile.

"push" est un synonyme de:
[box][left]
sub sp, sp, 4
store_32 [sp], %value
[/left][/box]

"pop" est un synonyme de:
[box][left]
load_32 %destination, [sp]
add sp, sp, 4
[/left][/box]

Tu remarqueras peut-être que "push" soustrait "sp" de sorte que la pile s'étend vers le bas à partir des adresses les plus élevées. Cela te laisse la possibilité d'utiliser les adresses basses comme bon te semble.



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

$35910734851012* {expected_value} est censée se trouver en haut de la pile, et non {actual_value}.

$77129086767196* Tu n'as pas donné en sortie la dernière valeur extraite.



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

$35820332981557* Implémente les opérations de pile pour Symphony.



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

$28617596738571*
Il est parfois utile de réutiliser une section de code. Nous appelons ces sections des "fonctions". Pour réutiliser du code, saute au début de la fonction et retourne à l'origine de l'appel une fois la fonction terminée. Ont dit "appeler" une fonction lorsqu'on saute vers elle, et revenir de la fonction est un "retour". 
  
Mais pour que cette section de code soit réellement réutilisable, le saut de retour devra pouvoir renvoyer vers différents emplacements, selon l'endroit d'où la fonction a été appelée.

On pourrait stocker la valeur du compteur dans un registre avant d'appeler la fonction et utiliser cette valeur lors du retour. Cependant, si cela était fait de cette manière, une fonction ne pourrait pas appeler une autre fonction, car cela écraserait l'adresse de retour d'origine.

Supposons que la fonction A appelle la fonction B, qui appelle la fonction C. Lorsque nous voulons revenir de C, Nous n'avons besoin que de l'adresse de retour pour B et, pour B, nous n'avons besoin que de l'adresse pour A. En général, quelle que soit la fonction que nous examinons et la manière dont elles s'appellent les unes les autres, La dernière adresse de retour que nous avons ajoutée est toujours la première dont nous aurons besoin à nouveau. C’est exactement le comportement de la pile.

$41513122622358* Fonctions

$42088257134737* Ce niveau est uniquement là pour te permettre d'observer le fonctionnement des fonctions, il n'y a pas de test. Assure-toi d'avoir lu et parcouru l'assembleur jusqu'à la fin pour comprendre comment tout fonctionne. Ce sera nécessaire pour les niveaux futurs.

$56028205797304* Comme les fonctions modifient probablement la valeur des registres, il peut être judicieux d'empiler les valeurs pour les sauvegarder, puis de les dépiler pour les restaurer. Il n'est pas important que cela soit fait à l'intérieur ou à l'extérieur de la fonction appelée, Il est toutefois de bonne pratique d'établir une convention à cet effet (appelée "convention d'appel"), de sorte que toutes les fonctions soient compatibles entre elles.

$64240772623662*
Dans ce niveau, les instructions "call" et "ret" ont été ajoutés à ta liste d'instructions. Ces deux termes sont des synonymes complexes.

"call" est utilisé pour entrer dans une fonction. Elle empile l'adresse de l'instruction suivante sur la pile(stack) (en lisant le compteur et en ajoutant un décalage)et passe ensuite au début de la fonction.

"ret" est utilisé pour revenir depuis une fonction. elle retire l'adresse de retour de la pile(pop) et effectue un saut vers l'adresse de retour.



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

$10902022971046* À l'exception de r1 et r2, une fonction doit retourner tous les registres à valeur d'origine

$11016773181609* La dernière multiplication a déjà placé le résultat dans r1

$14412657671278* On empile r3 et r4 nous pouvons donc les utiliser dans la fonction, et les restaurer avant de les renvoyer

$18457350783754* La première entrée est 2

$21553876748933* Accumulateur

$21707356398727* Charge les deux nombres donnés à par le niveau

$27088227324511* Le membre de droite restant de la multiplication

$27592840036827* La deuxième entrée est 5

$30769341721428* Côté gauche de la multiplication

$32724600358227* Restaurer la valeur d'origine

$33479507858734* Calcule 2 à la puissance 5

$42717933764735* r1 et r2 sont utilisés comme arguments, r1 étant le résultat de la fonction.

$42740851915963* Puissance restante

$43461252553161* Convention d'appel :

$59000482794872* La sortie attendue est 32

$63878589013500* Continue à multiplier jusqu'à ce que la « puissance restante » soit égale à 0.

$65068280556611* Restaurer la valeur d'origine

$68500361393623* Donne des noms aux registres pour faciliter la lecture.

$70634976221207* On empile r3 nous pouvons donc l'utiliser dans la fonction, mais nous devons le restaurer pour le renvoyer



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

$51514522389782* Observe comment fonctionnent les appels de fonction



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

$68182570848466* L'objectif de ce niveau est simple, Réduis le délai de Symphonie à 175 ou moins. Reviens en arrière sur les niveaux précédents et améliore tes scores si nécessaire.

$69806637130600* Symphony rapide



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

$17052191264122* Réduire la latence de Symphony



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

$36086882016175*

La plupart des instructions prennent 2 arguments et produisent 1 résultat (comme ADD, OR etc). 

[color=#e49f44]Symphony[/color] utilise 4 octets par instruction et peut encoder les trois dans chaque instruction, qui sont stockées dans le composant RAM appelé "Mémoire principale". Cela signifie que nous pouvons par exemple additionner deux registres quelconques et stocker le résultat dans n'importe quel autre registre.

$62556352127349* Spaghettis au Fil

$70083014183793* Enfin, il est temps pour toi de commencer à construire l'architecture [color=#e49f44]Symphony[/color]!

$83483553172261*
Maintenant que tout cela est expliqué, implémente l'instruction NAND.

Voici comment les instructions sont codées:

[left]
                      [color=#ff9800]M[/color] = Mode
                      [color=#ff6680]O[/color] = Opcode
                      [color=#ffe666]D[/color] = Registre de destination 
                      [color=#66ff99]A[/color] = Argument A
                      [color=#66ccff]B[/color] = Argument B
                      [color=#bbbbbb]0[/color] = Inutilisé / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#bbbbbb]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

Utilise le décodeur pour séparer les registres de destination et d'argument. Sois prudent: Les ports de chargement et de stockage acceptent l'adresse en octets, mais chaque registre occupe 4 octets. Cela signifie que tu dois fournir l'adresse du registre, et non son index.
De plus, à ce niveau le [color=#ff9800]Mode[/color] est toujours 1 et l'[color=#ff6680]Opcode[/color] est toujours 0. Cela signifie que nous effectuons un NAND entre le premier argument et le second, et que nous stockons le résultat dans le registre de résultat. Pour l'instant, tu peux utiliser une porte NAND 32 bits à la place de l'ALU.

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

$88649654188267*
Voici les noms des 16 registres de [color=#e49f44]Symphony[/color]:

[left]
                            0  zr
                            1  r1
                            2  r2
                            3  r3
                            4  r4
                            5  r5
                            6  r6
                            7  r7
                            8  r8
                            9  r9
                            10 r10
                            11 r11
                            12 r12
                            13 r13
                            14 sp
                            15 flags
[left]

La lecture de « zr » renverra toujours 0 ; toute écriture dans « zr » sera donc ignorée. Nous pouvons exploiter ce principe pour simplifier notre matériel. "sp" et "flags" sont des registres normaux qui ont simplement des noms différents. Ils seront réservés ultérieurement à des fins spécifiques.

Au lieu d'utiliser des registres individuels, utilise le composant RAM fourni, nommé "Register File" souvent appelé "ensemble de registres" en francais .



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

$34545926188340* Devait lire l'adresse {expected_value} en mémoire principale, et non {actual_counter}. La mise à jour du compteur a dù échouer au dernier cycle.

$35453700742253* Le composant Temp n'aurait pas dû être activée depuis l'exécution de la dernière instruction time_0.

$40674051088628* Le paramètre d'écran 3 est censé être {expected_value}, et non {value}.

$55420494010123* L'adresse mémoire principale {i} est censée avoir la valeur {expected_value}, et non {value}

$56149980430079* La sortie aurait dû être activée.

$68153781027719* L'adresse mémoire persistante {i} est censée avoir la valeur {expected_value}, et non {value}.

$74043498193765* La sortie devrait avoir la valeur {expected_output}, et non {output_value}.

$81124009043205* Le registre 'zr' doit toujours être zéro (adresse 0 dans l'ensemble de registres(Register File)).

$84654787309709* {register} (l'adresse de registre {address}) devrait avoir la valeur {expected_value}, et non {actual_value}



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

$21345632528660* Construis les fondations de l'architecture Symphony 



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

$34652721020070* Les fils gris implémentent le mode IO(Entrée/Sortie)



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

$66929200224494*
À ce niveau, nous ajoutons à [color=#e49f44]Symphony[/color] un moyen de lire des valeurs en entrée et de les envoyer en sortie .

Une fois de plus voici comment les instructions sont codées:

[left]
[color=#ff9800]M[/color] = Mode
[color=#ff6680]O[/color] = Opcode
[color=#ffe666]D[/color] = Registre de destination
[color=#66ff99]A[/color] = Argument A
[color=#66ccff]B[/color] = Argument B
[color=#bbbbbb]0[/color] = Inutilisé / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#bbbbbb]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

Tout comme avec [color=#e49f44]Overture[/color] Il existe 4 modes:

0 IO
1 ALU
2 JUMP
3 RAM

Cependant, à ce niveau, tu n'as à te soucier que du mode IO et ALU. En mode ALU, exécute l'instruction NAND comme au niveau précédent. Exécute l'une des instructions suivantes, en fonction de l'opcode:

0 nop (Ne rien faire)
1 in  (Envoie l'entrée vers [color=#ffe666]le registre de destination[/color])
2 out (Envoie l'[color=#66ccff]argument B[/color] en sortie)

$85119202720349* Symphony IO(Entrée/Sortie)



=== campaign/symphony_2_io/ui.txt ===

$76620689360899* Ajoute le mode IO(Entrée/Sortie) à Symphony



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

$23277299590423* Remplace la porte NAND par le composant ALU

$90347458725803* Les nouveaux fils orange transmettent l'opcode à l'ALU.



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

$13069282666558*
Ajoute l'unité arithmétique et logique (ALU) que tu as construite au niveau précédent au circuit. Le fonctionnement de chaque instruction est encodé dans l'[color=#ff6680]Opcode[/color].

[left]
[color=#ff9800]M[/color] = Mode
[color=#ff6680]O[/color] = Opcode
[color=#ffe666]D[/color] = Registre de destination
[color=#66ff99]A[/color] = Argument A
[color=#66ccff]B[/color] = Argument B
[color=#bbbbbb]0[/color] = Inutilisé / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#bbbbbb]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

$78613176066303* Intégration de l'ALU



=== campaign/symphony_3_alu/ui.txt ===

$54189071002426* Ajoute l'ALU à Symphony



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

$61996387838431* Les fils violets implémentent le mode valeur immédiate



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

$46968415562883* Valeurs immédiates symphony

$74993560224545*
Mets à jour l'architecture pour qu'elle ressemble à ce diagramme:

[image="fr_symphony_diagram_2.png"]


$85471608475185*
Il est parfois utile de charger une valeur directement depuis le programme plutôt que depuis les registres. Une valeur directement encodée dans une instruction est appelée valeur immédiate. Avec [color=#e49f44]Symphony[/color], nous pouvons remplacer l'argument B par une valeur immédiate dans n'importe quelle instruction. Cela se fait en positionnant le quatrième bit à 1 et en codant la valeur dans les deux derniers octets comme suit:

[left]
               [color=#ff9800]M[/color]  = Mode
               [color=#ff6680]O[/color]  = Opcode
               [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Mode immédiat
               [color=#ffe666]D[/color]  = Registre de destination
               [color=#66ff99]A[/color]  = Argument A
               [color=#66ccff]B[/color]  = Argument B (éventuellement une valeur immédiate)
               [color=#bbbbbb]0[/color]  = Inutilisé / zero
[/left]

Encodage de l'instruction si l'argument B n'est pas une valeur immédiate:
[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]

Encodage de l'instruction si l'argument B est une valeur immédiate:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]



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

$90023711394112* Ajoute les valeurs immédiates à Symphony



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

$39122914366346* Sauts(jump)

$57225943470132*
Ce sont les [color=#ff9800]Modes[/color] de [color=#e49f44]Symphony[/color]:

0 IO
1 ALU
2 JUMP
3 RAM

Dans ce niveau, nous implémentons le mode JUMP. Comme toujours, l'encodage des instructions est le suivant:

[left]
                [color=#ff9800]M[/color]  = Mode
                [color=#ff6680]O[/color]  = Opcode
                [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Mode immédiat
                [color=#ffe666]D[/color]  = Registre de destination
                [color=#66ff99]A[/color]  = Argument A
                [color=#66ccff]B[/color]  = Argument B (valeur immédiate possible)
                [color=#bbbbbb]0[/color]  = Inutilisé / zero
[/left]

Encodage de l'instruction si l'argument B n'est pas une valeur immédiate:
[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]
Encodage de l'instruction si l'argument B est une valeur immédiate:
[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]

En mode JUMP, la valeur du registre spécifié par [color=#66ff99]argument A[/color] Ce sont les drapeaux(flags) et ils doivent être comparés à la condition, qui est l'[color=#ff6680]opcode[/color]. Pour les comparer, utilise le composant personnalisé "cond" que tu as créé précédemment.

Si les drapeaux(flags) correspondent à la condition, écrase la valeur du compteur avec [color=#66ccff]argument B[/color].



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

$88550064597726* Ajoute les saut(jump) à Symphony



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

$78759770178685* Les fils violets controlent l'interaction avec la mémoire principale.



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

$41276257356528* RAM

$43585926436336* Note que les ports fonctionnent de haut en bas. Un port de chargement lira après un port de stockage s'il est placé plus bas, mais avant s'il est placé plus haut. Cela a son importance lorsque les ports chargent et stockent à la même adresse. En général, tous les ports attendent les ports de stockage situés au-dessus d'eux et ont donc une dépendance à leur égard. À ce niveau, les ports de chargement doivent être situés au-dessus des ports de stockage, sinon tu obtiendras une dépendance circulaire.

$65386575947998*
À ce niveau, nous implémentons le mode RAM. Pour l'instant, il y a six [color=#ff6680]opcodes[/color] dans ce mode:
[left]
                          [color=#ff6680]0[/color] load_8
                          [color=#ff6680]1[/color] load_16
                          [color=#ff6680]2[/color] load_32
                          [color=#ff6680]3[/color] [color=#bbbbbb]réservé[/color]
                          [color=#ff6680]4[/color] store_8
                          [color=#ff6680]5[/color] store_16
                          [color=#ff6680]6[/color] store_32
                          [color=#ff6680]7[/color] [color=#bbbbbb]réservé[/color]
[/left]
Les instructions "load" doivent charger la valeur à partir de la mémoire du programme à l'adresse [color=#66ccff]argument B[/color] et stocker le résultat dans le registre de [color=#ffe666]destination[/color].

Les instructions "store" doivent stocker la valeur dans le register [color=#66ff99]argument A[/color] de la mémoire du programme à l'adresse [color=#66ccff]argument B[/color].

Le suffixe numérique détermine la largeur, en bits, du nombre de bits à écrire ou à lire en mémoire, donc l'instruction 'load_8' devrait charger 8 bits de données & un 'store_16' devrait stocker 16 bits de données commençant à cette adresse.

$69462908463194*
Dans ce niveau, nous ajoutons le chargement et le stockage dans la même mémoire que celle utilisée pour le programme. Nous souhaitons pouvoir lire et écrire des mots de 32 bits, des mots de 16 bits et des octets de 8 bits ; il faut donc ajouter 3 ports de chargement et 3 ports de stockage supplémentaires au composant RAM.

Insère les nouveaux composants de port fournis entre le port de chargement "Instructions" et le composant RAM "Mémoire principale".

$73426457129430*
Une fois de plus, ce sont les [color=#ff9800]Modes[/color] de [color=#e49f44]Symphony[/color]:

[left]
                            [color=#ff9800]0[/color] IO
                            [color=#ff9800]1[/color] ALU
                            [color=#ff9800]2[/color] JUMP
                            [color=#ff9800]3[/color] RAM
[/left]
And the encoding looks like this:
[left]
               [color=#ff9800]M[/color]  = Mode
               [color=#ff6680]O[/color]  = Opcode
               [color=#9966ff]0[/color]/[color=#9966ff]1[/color] = Mode immédiat
               [color=#ffe666]D[/color]  = Registre de destination
               [color=#66ff99]A[/color]  = Argument A
               [color=#66ccff]B[/color]  = Argument B (éventuellement une valeur immédiate)
               [color=#bbbbbb]0[/color]  = inutilisé / zero
[/left]

Encodage de l'instruction si l'argument B n'est pas une valeur immédiate:
[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]
Encodage de l'instruction si l'argument B est une valeur immédiate:
[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]



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

$51703376131802* Ajoute les instructions de chargement(load) et de stockage(store) à Symphony



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

$28652182390799* Les nouveaux fils violets controlent l'interaction avec la mémoire persistante



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

$23620554597332*
À ce niveau, nous ajoutons un autre composant RAM, mais pour stocker les données entre les redémarrages.

Ajoute ensuite deux nouvelles instructions mémoire, « pload » et « pstore », qui doivent fonctionner comme les variantes 32 bits des instructions de chargement et de stockage du niveau précédent, mais en accédant à la Ram "mémoire persistante" au lieu de la mémoire du programme.

Voici tous les [color=#ff6680]opcodes[/color] en mode mémoire:
[left]
                        [color=#ff6680]0[/color] load_8
                        [color=#ff6680]1[/color] load_16
                        [color=#ff6680]2[/color] load_32
                        [color=#ff6680]3[/color] pload
                        [color=#ff6680]4[/color] store_8
                        [color=#ff6680]5[/color] store_16
                        [color=#ff6680]6[/color] store_32
                        [color=#ff6680]7[/color] pstore
[/left]

$76705374584193* Mémoire persistante



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

$89678353617146* Ajoute de la mémoire persistante à Symphony



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

$28545157055801* Empile %a. Cette instruction est synonyme de : sub sp, sp, 4 store_32 [sp], %a

$34859363394334* Déplace une valeur vers %a.

$40508048121543* Applique Not sur une valeur et stocke le résultat dans %a.

$48332460366102* Retour depuis le dernier appel de fonction. Écrase le registre des drapeaux(flag register). Cette instruction est synonyme de :   load_32 flags, [sp]   add sp, sp, 4   jmp flags

$53941960758392* Déplace la valeur depuis %b vers %a.

$54469754973269* Retire %a de la pile. Cette instruction est synonyme de:   load_32 %a, [sp]   add sp, sp, 4

$55357258069734* applique Not sur %b et stocke le résultat dans %a.

$57504570243305* Rend la valeur négative et la stocke dans %a.

$57788320241950* appel %a. Écrase le registre des drapeaux (flag register). Cette instruction est synonyme de :   counter flags   add flags, flags, 20   sub sp, sp, 4   store_32 [sp], flags   jmp %a

$72894099288447* Rend la valeur %b négative et la stocke dans %a.



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

$48843089545173* Les nouveaux fils gris assurent l'interaction avec les périphériques IO(Entrée/Sortie) 



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

$67457044658869*
Pour ce niveau, tu dois placer trois nouveaux composants d'IO : l'écran, l'horloge et le clavier.

Relie également l'écran au composant RAM nommé "Mémoire principale".



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

$10169473219025* 1 seconde = 1_000_000_000 nanoseconde = 0x0000_0000_3B9A_CA00

$11549850182703* coordonnée y

$16841324702501* Robot

$22405816552972* direction

$23344524651761* mise à jour cycle suivant

$25470599373421* dessine un fantôme sur la nouvelle position

$25474902303790* incrémente la direction

$26430777268618* robot vers le bas

$28230914387367* pièce 

$29369794309677* TODO: manipuler les pièces et les objets vides différemment

$31647601023268* Table d'adresses de saut du Sprite

$33327526977497* fantôme

$33450896282702* Substitut(placeholder)

$34042928458359* modulo 3

$35647670060017* vide

$36791496238134* 2 * longueur de l'instruction = 8

$37230877526029* fantôme à droite

$37647180126584* dessine le robot sur sa nouvelle position

$38695844571056* débordement(overflow)

$40959483784712* robot à droite

$45301848117435* fantôme vers le bas

$50069163371185* fantôme vers la gauche

$50501450979711* robot vers le haut

$55263046326109* heurter un mur -> annuler le mouvement

$55673115734516* remplissage pour préserver l'alignement sur 32 bits

$61792431057747* coordonnée x 

$62236058044269* [remplissage]

$64851396075477* 2 * longueur de l'instruction = 8

$67744627518982* pièce

$69893421560125* robot vers la gauche

$72366220861688* fantôme vers le haut

$73803385159414* La première valeur est donc 0.

$75937352730902* 0.5 seconde = 500_000_000 nanoseconde = 0x0000_0000_1DCD_6500



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

$18975134592059* La sortie aurait dû être activée.

$26871980917450* L'adresse mémoire persistante {i} est censée avoir la valeur {address}, et non {value}.

$29202969341865* mauvaise valeur de temps en sortie (As-tu pensé à mettre en cache le temp dans l'instruction time_0 ?)

$29909286517152* Le registre 'zr' doit toujours être zéro (adresse 0 dans l'ensemble de registres/Register File).

$30816527015736* La sortie aurait dû être {expected_output}, et non {output_value}.

$31400969059429* {register} (l'adresse de registre {address}) devrait avoir la valeur hexadécimale {expected_value}, et non {actual_value}

$41024505081324* tu devrais lire l'adresse {counter_value} de la mémoire principale, et non {actual_counter}. La mise à jour du compteur a dù échouer au dernier cycle.

$42960087865089* Le paramétre d'écran {i} est censé être {expected_value}, et non {value}

$46474751521062* Lis l'écran à la "Mémoire principale". (utilise le petit bouton rouge dans le coin de l'écran).

$78917660933958* L'adresse mémoire principale {i} est censé être {address}, et non {value}



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

$63394282539727* Ajoute les instructions IO(Entrée/Sortie) à Symphony



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

$11626177279992* saute vers %a si la première valeur était supérieure (non signée) à la seconde (lecture des résultats à partir des 'flags').

$12835125621741* Stocke la valeur de %b dans le paramètre d'écran %a.

$13110303123442* Stocke %value à l'adresse %adr dans la mémoire persistante.

$13576771671264* Décalage logique de %b à gauche de %c bits et stocke du résultat dans %a.

$15915531259935* Envoie %a vers la sortie.

$16685334571248* Décalage logique de %b à droite de %c bits et stocke du résultat dans %a.

$18254089726214* Envoie %a vers la sortie.

$19953421010778* stocke %value à l'adresse %adr de la mémoire principale.

$23349431010010* Additionne %b and %c et stocke du résultat dans %a.

$23396316982953* Charge l'addresse %adr depuis la mémoire principale et stocke du résultat dans %dest.

$26183125927881* saute vers %a si la première valeur était inférieure (non signée) ou égale à la seconde (résultats de lecture à partir de 'flags')

$27219499692147* Charge l'adresse %adr depuis la mémoire principale et la stocke dans %dest.

$27868418224252* Charge l'entrée clavier et la stocke dans %a.

$28652904157569* Soustrait %b et %c et stocke le résultat dans %a.

$29562677483890* Stocke %value à l'adresse %adr de la mémoire principale.

$30574433901064* Applique un OR entre %b and %c et stocke le résultat dans %a.

$31763492459833* Saute vers %a si la première valeur était inférieure (non signée) à la seconde (résultats de lecture à partir de 'flags').

$37102964808364* Compare %a et %b et stocke le résultat dans le registre 'flags'.

$37333076617857* Applique un NOR entre %b et %c et stocke le résultat dans %a.

$39857449355186* Stocke la valeur de %b dans le paramètre d'écran %a.

$40732211165530* Applique un OR entre %b et %c et stocke le résultat dans %a.

$42626144645228* Décalage arithmétique de %b à droite de %c bits et stocke le résultat dans %a.

$44524771082050* charge une entrée clavier et la stocke dans %a..

$46087142860391* Applique un NOR entre %b et %c et stocke le résultat dans %a.

$46967848572964* Applique un XOR entre %b et %c et stocke le résultat dans %a.

$47442552951774* Stocke %value à l'adresse %adr de la mémoire principale.

$51030225266712* Additionne %b and %c et stocke du résultat dans %a.

$53499765587663* Saute vers %a si la première valeur était plus grande (signée) ou egal à la seconde(résultats de lecture à partir de 'flags').

$54565380946620* Compare %a et %b et stocke le résultat dans le registre 'flags'.

$54577249258785* Décalage logique de %b à gauche de %c bits et stocke du résultat dans %a.

$55551510150818* Décalage arithmétique de %b à droite de %c bits et stocke le résultat dans %a.

$57200935026773* Charge l'adresse %adr depuis la mémoire principale et la stocke dans %dest.

$59344052643304* Stocke %value à l'adresse %adr dans la mémoire persistante.

$61040780958703* Stocke %value à l'adresse %adr de la mémoire principale.

$66785854415645* Applique un XOR entre %b et %c et stocke le résultat dans %a.

$67019902294705* Décalage logique de %b à droite de %c bits et stocke le résultat dans %a.

$67178948469318* Saute vers %a si si la valeur n'était pas égale (résultats de lecture à partir de 'flags').

$67376584796076* Charge la valeur du compteur et stocke le résultat dans %a.

$67495552371225* Soustrait %b et %c et stocke le résultat dans %a.

$68219187873304* Charge les quatre octets de poids fort de la valeur de temp et stocke le résultat dans %a.

$69550893885320* Stocke %value à l'adresse %adr de la mémoire principale.

$69632418904622* Charge l'adresse %adr depuis la mémoire principale et la stocke dans %dest.

$71317192057126* Saute vers %a si la première valeur était plus grande (signée) que la seconde (résultats de lecture à partir de 'flags').

$71637103729391* Saute vers %a si la première valeur était plus petite (signée) que la seconde (résultats de lecture à partir de 'flags').

$72280171778920* Charge l'adresse %adr depuis la mémoire persistante et la stocke dans %dest.

$72551400437977* Charge les quatre octets de poids faible de la valeur de temp et stocke le résultat dans %a.

$73559051740347* Stocke %value à l'adresse %adr de la mémoire principale.

$74148826866592* Saute vers %a.

$75302656449127* Applique un NAND entre %b et %c et stocke le résultat dans %a

$77040234358389* Saute vers %a si la première valeur était plus petite (signée) ou égale à la seconde (résultats de lecture à partir de 'flags').

$77232719678109* Charge l'adresse %adr depuis la mémoire principale et la stocke dans %dest.

$82087388048746* Saute vers %a si la première valeur était supérieure (non signée) ou égale à la seconde (résultats de lecture à partir de 'flags').

$85679146831122* Applique un AND entre %b et %c et stocke le résultat dans %a

$85822609095465* Charge l'adresse %adr depuis la mémoire principale et la stocke dans %dest.

$86705346481666* Applique un NAND entre %b et %c et stocke le résultat dans %a

$86713121915282* Applique un AND entre %b et %c et stocke le résultat dans %a

$88180305667389* Saute vers %a si les valeurs étaient égales (résultats de lecture à partir de 'flags').

$88272577071256* Ne fait rien.

$89257021109854* Charge l'adresse %adr depuis la mémoire persistante et la stocke dans %dest.

$90876214388280* Saute vers to %a.



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

$18099138932731* Mémoire persistante

$28246040923235* L'ensemble de Registres

$35059654572638* temp

$41903613959902* Mémoire Principale

$79162322081640* clavier

$80985404567327* écran



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

$20456965663323* Alias ​​d'Instructions

$41535895646297*
Comme les niveaux précédents, ce niveau introduit de nouvelles instructions. Cependant, dans ce niveau, tu ne dois pas ajouter de matériel supplémentaire, mais plutôt modifier la spécification d'assemblage afin de réutiliser le matériel d'instructions existant pour les nouvelles instructions.

Clique sur l'onglet "spec.isa" dans le coin supérieur gauche de la fenêtre Assembleur et étudie comment les instructions sont mises en œuvre. Ajoute ensuite les trois nouvelles instructions suivantes:

[b]mov[/b]
"[b]mov[/b]" est l'abréviation de "move"(déplacer) et prend deux opérandes. Il déplace la valeur du second opérande vers le premier.

[b]neg[/b]
"[b]neg[/b] est l'abréviation de "negate"(négation) et prend deux opérandes. Il inverse le signe de la valeur du second opérande et stocke le résultat dans le premier.

[b]not[/b]
"[b]not[/b]" prend deux opérandes. Il effectue une opération NOT sur la valeur du second opérande et stocke le résultat dans le premier

Une fois ces instructions ajoutées, le code assembleur sera valide et son exécution terminera le niveau.



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

$71972143734450* Valeur hexadécimale



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

$44683006232656* La première instruction aurait dû déplacer la valeur hexadécimale 0x1235 vers r1.

$67087756287234* r3 aurait dû avoir la valeur hexadécimale 0x1234

$83123414679662* r2 aurait dû avoir la valeur hexadécimale 0xffffedcb.



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

$13320201556243* Crée la spéc ISA pour les nouvelles instructions



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

$52048822283735*
Il s'agit d'une copie de l'ALU d'Overture . Il est temps de le mettre à jour en 32 bits et d'ajouter quelques nouvelles instructions.

Instructions:

[color=#87a8c8]0 NAND
1 OR
2 AND
3 NOR
4 ADD
5 SUB
6 XOR
7 LSL
8 LSR
9 ASR
10 CMP[/color]

L'opération cmp est celle pour laquelle tu as déjà créé un composant personnalisé au niveau précédent.

$71902120982324* ALU de Symphony



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

$69427874681706* Implémente l'ALU de Symphony



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

$37729390402296* Drapeaux De Comparaison (flags)

$64818361855764*
Dans ce niveau, tu compares deux entrées 32 bits de trois manières différentes. Chaque résultat est une valeur binaire appelée "drapeau"(flag).

Flags:
Definit le bit 0 à 1 si les entrées sont égales.
Definit le bit 1 à 1 si la première entrée est inférieure (non signée) à la deuxième entrée.
Definit le bit 2 à 1 si la première entrée est inférieure (signée) à la deuxième entrée.

Pour apprendre à créer des composants 32 bits, ouvres d'abord le niveau "Compteur Symphonie" si tu ne l'as pas déjà fait.



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

$55730459238598* Résultat attendu: {a}{b}{c}.



=== campaign/symphony_cmp/ui.txt ===

$73310930628112* Implémente les drapaux(flags) de Symphony



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

$13327132168076* Résultat

$17010689474441* Condition

$25959617344671* Drapeaux



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

$20911185106374*
Dans ce niveau, la première entrée contient des flags et le deuxième argument contient une condition. Nous devons vérifier si les flags correspondent à la condition. Compare les trois bits d'entrée du flag deux à deux avec les trois premiers bits de l'entrée de condition. Si les deux éléments de l'une des trois paires sont vrais, la condition est remplie.

Enfin, le quatrième bit de la condition inverse le résultat. Ainsi, si la condition est remplie, mais que le quatrième bit est à [T], la sortie est [F].

$90224867995967* Correspondance Des Conditions



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

$33181499064044* Le résultat ne doit jamais être à l'état Z.

$73051402798264* Le résultat correcte est {U1 result}



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

$41164574218692* Compte

$42019997838216* écrasé

$48990052180226* valeur



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

$56387381898532* Compteur De Symphony

$76860406179468*
Pour modifier la largeur de mot du composant, tu devras utiliser un outil de réglage de la taille près du panneau de gauche. (ressemble à une flèche bidirectionnelle et à un nombre).

Clique droit sur l'outil de Taille pour spécifier la largeur cible.
Un clic gauche sur les composants lorsque l'outil est actif permet de définir la largeur de mot du composant.
Les nouveaux composants octet auront cette largeur de bits par défaut.

$77897142643435*
Crée un compteur 32 bits qui s'incrémente de 4 , mais qui peut être redéfini avec une valeur spécifique.

Connecte également la sonde mémoire fournie à un composant 32 bits contenant la valeur de la mémoire du compteur.



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

$54301125260332* La mémoire est censée être {expected_memory}, et non {memory_value}

$70376380014778* La sortie ne devrait jamais être à l'état Z

$84451713761977* La sortie devrait être {expected_memory}



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

$81792554779622* Crée un compteur 32 bits qui s'incrémente de 4 à chaque cycle.



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

$16402377924132* est valeur immédiate

$24747841106265* Argument B

$26207217884026* Opcode

$26325060783055* Argument A

$40584554497383* valeur immédiate

$48212238534381* Instruction

$48506758479060* Mode

$67128656777473* Destination



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

$13883461694525* Décodeur d'Instructions Symphony

$41138026161536*
Utilise l'indexeur statique pour résoudre ce niveau. 

L'indexeur statique est un composant spécial qui permet de décaler certains bits d'un fil, sans délai ni coût de portes logiques. Modifier le chiffre sur le composant décalera les bits (Un nombre positif se déplace vers la droite). Clique ensuite sur le composant pour définir la largeur de sortie.

$71911284169222*

Crée un circuit qui divise les instructions de Symphony en leurs différentes parties. Cela te sera très utile par la suite.

Il existe deux encodages pour les instructions Symphony, selon que l'on utilise des valeurs immédiates ou non:

[left]
[color=#ff9800]M[/color] = Mode
[color=#ff6680]O[/color] = Opcode
[color=#9966ff]I[/color] = valeurs immédiates
[color=#ffe666]D[/color] = Registre de destination
[color=#66ff99]A[/color] = Argument A
[color=#66ccff]B[/color] = Argument B (éventuellement une valeur immédiate)
[color=#bbbbbb]0[/color] = Inutilisé / zero
[/left]

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]0[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#bbbbbb]0000[/color][color=#66ccff]BBBB[/color] [color=#bbbbbb]00000000[/color]

[color=#bbbbbb]0[/color][color=#ff9800]MM[/color][color=#9966ff]1[/color][color=#ff6680]OOOO[/color] [color=#ffe666]DDDD[/color][color=#66ff99]AAAA[/color] [color=#66ccff]BBBBBBBB BBBBBBBB[/color]
  



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

$15174125339458* Opcode devrait être {opcode}, et non {actual_opcode}.

$31544476297744* La destination devrait être {dest}.

$31942264008156* Arg B devrait être {b}.

$45701446129480* La valeur immédiate devrait être {immediate_value}.

$63089562267538* 'Is immediate'(est une valeur immédiate) devrait être {immediate}.

$64926808682290* Le mode devrait être {mode}.

$82638458430252* Arg A devrait être {a}.



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

$51036929729507* Implémente le récepteur de Symphony 



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

$42863588667057* Utilise des switches pour placer les entrées sur le même fil.



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

$88955803760495* L'entrée sélective est simplement un multiplexeur.



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

$55189990966587* Modifie le multiplexeur pour qu'il partage son entrée, au lieu de sa sortie, pour la sortie sélective.

$86286155471986* Le fil violet au milieu est le bus.



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

$25477689162292* Sortie sélectionnée

$25535487507842* A

$43340511034957* Entrée sélectionnée

$43474590938240* Y

$47236089523392* X

$65041743851294* B



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

$10949534274977* Le bus

$25369396405852*
Ce niveau comporte des entrées de 2 octets et des sorties de 2 octets. Ton objectif est de déplacer un nombre d'une entrée vers une sortie.
  
Le premier bit d'entrée détermine l'entrée de départ. Le second bit d'entrée détermine la sortie de destination.

À chaque cycle, une seule sortie doit recevoir la valeur, l'autre sortie devant recevoir Z (aucune valeur). Ceci sera indiqué par "-" sur la sortie.



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

$28173496384607* La sortie Y devrait être {val}.

$46672500255781* La sortie X devrait être Z.

$65293894030728* La sortie X devrait être {val}.

$69214136994673* Transférer la valeur de {source} à {destination}

$75577618213381* La sortie Y devrait être Z.



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

$31341803878224* Crée un circuit qui transmet la valeur d'une entrée spécifiée à la sortie spécifiée.



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

$23374750315066* Dans le jeu "Tours de Hanoï", tu dois déplacer une pile de disques d'une cheville à une autre. Le problème est qu'un seul disque peut être déplacé à la fois, seul le disque supérieur d'une pile peut être déplacé, et un disque plus grand ne peut jamais être placé sur un disque plus petit.

$29450953142176* Tour de Hanoï

$62636370223849*
Incroyable, tu as terminé tous nos tests ! Vois tout le chemin parcouru depuis la porte NAND.

Les humains sont véritablement dignes de rejoindre la Fédération galactique.

$72724057674158*
Les 4 premières entrées te donneront les résultats suivants, dans l'ordre:
disk_nr - Le numéro de disque le plus élevé de la pile (de 2 à 4)
source - le numéro de l'endroit depuis lequel on bouge
destination - Où se déplacer
spare - Le troisième endroit, ni la source ni la destination

Contrôle l'aimant avec les sorties suivantes:
[left]
        0 - Déplace l'aimant à l'endroit 0
        1 - Déplace l'aimant à l'endroit 1
        2 - Déplace l'aimant à l'endroit 2
        5 - Activer ou désactiver l'aimant ON/OFF
[/left]

Manipule l'aimant manuellement en utilisant les flèches directionnelles pour le déplacer et la touche Entrée pour activer/désactiver.

$81427576809439*
Ce niveau est difficile, mais c'est une bonne occasion pour toi d'utiliser des fonctions. En fait, la solution suivante pour ce niveau contient une "fonction récursive", ce qui signifie une fonction qui s'appelle elle-même.

[b]Algorithme de la Tour de Hanoï:[/b]
[box][left]func move(disk_nr, source, dest, spare) {
    if disk_nr is 0 {
        déplacer le disque de la source vers la destination
    } else {
        move(disk_nr - 1, source, spare, dest)
        déplacer le disque de la source vers la destination
        move(disk_nr - 1, spare, dest, source)
    }
}[/left][/box]

[tip]N'oublie pas d'empiler les valeurs des registres pour les stocker quand tu es dans une fonction qui va les modifier.[/tip]



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

$39419617008574* Oups, Tu as mis un disque plus grand sur un plus petit!



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

$89305883777750* Tu vois que la sortie de la porte XNOR est exactement l'inverse de celle de la porte XOR ?



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

$29396170535219* Crée la porte XOR inversé, également appelée XNOR.

$50956872142719* Porte XNOR

$85674599929809* La dernière fois que nous sommes venus, la plupart des Terriens étaient des reptiles géants. Aucun d'entre eux n'était assez intelligent ou poli pour rejoindre la Fédération Galactique.



=== campaign/xor_gate/hint_0.txt ===

$15534865654723* Entrée 0

$17025412277453* Entrée 1

$59092390409834* Sortie attendue

$62308032073140* Soit l'entrée 0 est [T] et l'entrée 1 est [F], soit l'entrée 0 est [F] et l'entrée 1 est [T].

$84782011304318* La table de vérité nous indique que la sortie est [T] si et seulement si



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

$16623524168613* Cela reste un exercice laissé au joueur !

$30671593085518* Cette solution n'est pas la plus élégante ni la plus optimale.



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

$22122562689406* Sortie

$45326245069696* Entrée



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

$21287008524643* Porte XOR

$30005674935190* On l'appelle aussi porte XOR. Ce niveau est difficile, ne te décourage donc pas si tu n'obtiens pas la réponse immédiatement.

$50002893048555* Au niveau précédent, tu as construit un circuit qui était [T] lorsque nous étions au deuxième cycle. Ce niveau crée un circuit qui est [T] lorsque nous sommes au deuxième OU au troisième cycle.



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

$38271404408184* Sortie actuelle



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


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


# Default new input pin name for custom compoennts
$14951951489108* Entrée



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


# com_mux's output pin
$10003014068713* Sortie


# Component category name, at most 6 glyphs, the rest is cut off!
$10078663735607* Entrées


# com_concatenator_8's input pin
$10080083255838* Mot 3


# com_clz's output pin
$10092537578053* Résultat


# com_splitter_bit_4's output pin
$10111764008386* Bit 2


# com_level_output_4_pin's name
$10190739202646* Sortie


# com_ctz's description
$10231593934948* Compte les zéros à partir du bit le plus faible jusqu'au premier 1


# com_xor_word's output pin
$10269927015049* Résultat


# com_static_indexer_config's name
$10289043699917* Indexeur Statique Automatique


# com_lsr's input pin
$10335381544532* Décale de


# com_halt's name
$10351143139905* Arrêt


# com_nand_word's input pin
$10425218359878* Entrée 0


# com_splitter_bit_8's description
$10488114435022* Sépare un octet en 8 bits


# com_splitter_bit_8's output pin
$10491931394044* Bit 3


# Component category name, at most 6 glyphs, the rest is cut off!
$10495775939951* IO


# com_probe_wire_bit's input pin
$10499689720024* Valeur


# Component category name, at most 6 glyphs, the rest is cut off!
$10507478984775* Dev


# com_splitter_bit_4's name
$10524104374521* Séparateur


# com_cc_output's name
$10557704838301* Connecteur de sortie


# com_segment_display's name
$10582128204153* Affichage 7 segments


# com_switch_word's name
$10611658692685* Commutateur d'octet(switch)


# com_xnor_bit's description
$10614106399129*
[T] quand les entrées sont identiques


# com_not_word's description
$10624873506476* Inverse chaque bit


# com_counter's output pin
$10629272823895* Compte


# 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* Entrée


# com_maker_bit_8's input pin
$10716205698752* Bit 5


# com_decoder_3's input pin
$10755367544042* Entrée


# com_delay_line_word_config's output pin
$10757852071445* Sortie


# com_rol's input pin
$10762061266647* Valeur


# com_decoder_2's output pin
$10762093809413* Bit 1


# com_nor_word's input pin
$10770218762282* Entrée 0


# com_concatenator_2's description
$10776829749898* Concatène deux valeurs,la largeur de sortie est la somme des largeurs de toutes les entrées


# com_cc_output's description
$10781578424003* Connecteur de sortie


# com_ror's description
$10802217509530* Rotation à droite des bits d'une entrée


# com_add's output pin
$10815269647822* Retenue de sortie


# com_not_bit's description
$10844421681709*
Inverse l'entrée


# com_nand_word's description
$10859914201083* Applique NAND à chaque bit de deux valeurs


# com_full_adder's output pin
$10918445419498* Résultat


# com_static_value's output pin
$10920459933396* Valeur


# com_mod's description
$10934212906097* Modulo entre 2 entrée


# com_level_input_word's name
$10943344093513* Entrée


# com_keyboard's name
$10965596602414* Clavier


# com_less_s's output pin
$11019209691112* Résultat


# com_asr's name
$11034107377099* Décalage arithmétique à droite


# com_maker_word_2's description
$11048127331082* Fusionne deux valeurs de (n/2) bits en une seule valeur de n bits


# com_register_word_config's input pin
$11057152094224* Taille


# com_concatenator_8's input pin
$11115698874478* Mot 0


# com_maker_bit_4's name
$11119510732154* Créateur


# com_nand_bit's name
$11130919681688* NAND


# com_static_indexer_config's output pin
$11132082500971* Résultat


# com_mux's description
$11168613697835* Alterne entre 2 valeurs


# com_full_adder's input pin
$11264799740288* Entrée 0


# com_level_input_switched's name
$11278573510238* Entrée commuté


# com_not_word's name
$11286216680410* NOT


# com_maker_word_2's output pin
$11293966912554* Résultat


# com_decoder_2's output pin
$11297026031742* Bit 2


# com_level_output_word's name
$11300749636961* Sortie


# com_full_adder's input pin
$11312161634667* Entrée 1


# com_delay_line_word_config's late input pin
$11320392055125* Entrée


# com_mod's output pin
$11329013865174* Résultat


# com_or_word's input pin
$11335506036805* Entrée 1


# com_level_input_word's description
$11342065742485* Entrée de mot


# com_splitter_word_4's output pin
$11345730126879* Mot 0


# com_static_indexer_config's input pin
$11349557191063* Entrée


# com_maker_word_8's output pin
$11351867388170* Résultat


# com_mod's input pin
$11352468367638* Dividende


# com_concatenator_8's input pin
$11366501215506* Mot 2


# com_level_gate's name
$11417416554850* Composant de niveau


# com_splitter_word_8's input pin
$11440186157356* Entrée


# com_level_input_4_pin's name
$11447837612693* Entrée


# com_inc's description
$11449663590476* Incrémente l'entrée de 1


# com_splitter_word_8's output pin
$11465347976002* Mot 3


# com_level_output_switched's input pin
$11520072088720* Activer


# com_asr's output pin
$11521973612539* Résultat


# com_splitter_bit_8's output pin
$11548514728473* Bit 0


# com_switch_bit's name
$11574334638147* Commutateur


# com_nand_word's input pin
$11578787451669* Entrée 1


# com_div's input pin
$11611913368782* Diviseur


# com_switch_word's output pin
$11625195403324* Sortie


# com_maker_bit_8's input pin
$11634467729625* Bit 4


# com_neg's input pin
$11637742665554* Entrée


# com_clz's name
$11678932883790* Compte les zéros de tête


# com_ram's name
$11710093917097* RAM


# com_decoder_2's name
$11727998752868* Décodeur 2 Bits


# com_maker_bit_2's input pin
$11752209410617* Bit 1


# com_and_word's description
$11791872137683* AND chaque bits de deux valeurs


# com_mul's output pin
$11838813794006* Résultat


# com_off's name
$11860786587357* OFF


# com_splitter_bit_8's name
$11904470559153* Séparateur


# com_nor_word's output pin
$11938328576163* Résultat


# com_delay_line_bit's output pin
$11945697622944* Sortie


# com_and_word's input pin
$11977039914327* Entrée 0


# com_neg's description
$12021716182809* Inverse l'entrée


# com_splitter_bit_2's input pin
$12046095993506* Entrée


# com_screen's name
$12046117430308* Écran


# com_cc_level_output's description
$12051024347384* Un mot de sortie qui sera convertit en connecteur d'entrée/sortie si la solution du niveau est enregistrée comme composant


# com_splitter_bit_4's input pin
$12060097589370* Entrée


# com_xnor_word's name
$12087865653212* XNOR


# com_ror's name
$12093087039542* Rotation à droite


# com_delay_line_bit's name
$12121899638400* ligne a retard(délai)


# com_nor_word's name
$12175906806727* NOR


# com_neg's output pin
$12196354295621* Résultat


# com_level_output_1_pin's name
$12242923444593* Sortie


# com_level_output_counter's name
$12247325526438* Compteur


# com_maker_word_4's output pin
$12262460678043* Résultat


# com_probe_memory_bit's name
$12318534735397* Sonde mémoire (bit)


# com_concatenator_2's input pin
$12329350771997* Mot 2


# com_concatenator_8's input pin
$12341255296823* Mot 1


# com_verilog_output's name
$12353364840899* Sortie Verilog


# com_probe_wire_asm's late input pin
$12365938365321* Entrée


# com_splitter_word_4's description
$12370556827575* Divise une valeur de (4n) bits en quatre valeurs de n bits


# com_concatenator_4's input pin
$12371272172145* Mot 1


# com_concatenator_8's input pin
$12384635971036* Mot 5


# com_decoder_3's output pin
$12390018918095* Bit 7


# com_asr's input pin
$12408847893200* Décale de


# com_register_word's late input pin
$12420839132846* Valeur à enregistrer


# com_constant's description
$12424468899005* Valeur constante


# com_concatenator_8's description
$12443053648819* Concatène 8 valeurs, la largeur de sortie est la somme des largeurs de toutes les entrées


# com_keyboard's output pin
$12465282633818* Valeur de touche


# com_level_input_1_pin's output pin
$12465938629713* Entrée


# com_concatenator_8's output pin
$12478474747295* Résultat


# com_probe_memory_word's description
$12492235992906* Affiche une valeur sur ton composant personnalisé ou dans l'éditeur de programme


# com_mux's input pin
$12520768681157* Valeur 1


# com_switch_word's input pin
$12550214308917* Valeur


# com_maker_word_8's input pin
$12592072659210* Mot 1


# com_maker_bit_2's name
$12602955212919* Créateur


# com_maker_word_8's input pin
$12616927929524* Mot 3


# com_static_indexer_config's input pin
$12633414511976* taille


# com_delay_line_word's late input pin
$12644592179746* Entrée


# com_register_bit's name
$12678278048629* Registre


# com_mux's input pin
$12687047365426* Valeur 0


# com_and_bit's description
$12719674432950*
[T] quand les deux entrées sont [T]


# com_splitter_word_2's name
$12723870092766* Séparateur


# com_counter's description
$12736827510023* Incremente chaque cycle, à moins d'être écrasée


# com_level_input_1_pin's name
$12746117288689* Entrée


# com_off's description
$12749460799924* Toujours [F]


# com_less_s's description
$12765625016236* Vérifie si la premiere entrée vaut moins que la seconde


# Component category name, at most 6 glyphs, the rest is cut off!
$12778241216484* Bit


# com_switch_word's input pin
$12784430582183* Activer


# com_lsl's input pin
$12849468178655* Valeur


# com_static_indexer_config's input pin
$12869119410565* Décallage


# com_nand_bit's description
$12903183841172*
[T] sauf si les deux entrées sont [T]


# com_and_word's name
$12926911335769* AND


# com_lsr's name
$12931148241340* Décalage à droite


# com_splitter_word_4's input pin
$12938882109013* Entrée


# Component category name, at most 6 glyphs, the rest is cut off!
$12972244522540* Écrans


# com_halt's description
$12990744955549* Interrompt l'exécution avec un message personnalisé


# com_or_bit's description
$13013154620359*
[T] quand n'importe laquelle des entrées est [T]


# com_level_output_8_pin's name
$13087193858087* Sortie


# com_maker_bit_8's input pin
$13104890311933* Bit 1


# com_rol's input pin
$13135722015590* Pivote de


# com_decoder_3's output pin
$13138546420646* Bit 6


# com_store_port's name
$13159020985209* Connecteur de stockage


# com_level_delay_gate's name
$13161432526100* Composant de niveau et de délai


# com_level_output_3_pin's description
$13174121812559* Sortie de 3 bits


# com_maker_word_4's input pin
$13236424504117* Mot 2


# com_xor_word's description
$13236921580268* XOR chaque bit de deux valeurs


# com_level_output_2_pin's name
$13255344581755* Sortie


# com_level_gate's description
$13259215761047* Utilisé pour céer les cartes des niveaux


# com_cc_input's description
$13263310288543* Connecteur d'entrée


# com_delay_line_word_config's input pin
$13271299225650* Taille


# com_level_input_1_pin's description
$13272198916233* Entrée d'un bit


# com_register_word's late input pin
$13298317818150* Activer la sauvegarde


# com_concatenator_4's input pin
$13331778821779* Mot 0


# com_verilog_input's output pin
$13351141217116* Entrée


# com_nor_bit's name
$13375115196253* NOR


# com_maker_word_8's input pin
$13378739117488* Mot 6


# com_less_u's name
$13502755965496* Plus petit que < (non-signé)


# com_splitter_word_2's output pin
$13510688527850* Mot 1


# com_ror's input pin
$13521735131997* Pivote de


# com_register_word's description
$13576980017857* Petit composant mémoire


# com_splitter_word_2's output pin
$13625849577132* Mot 0


# com_splitter_bit_8's output pin
$13666042416530* bit 2


# com_keyboard's output pin
$13705122401876* Attente d'événement


# com_splitter_bit_2's name
$13766521376720* Séparateur


# com_maker_bit_4's input pin
$13826250945595* Bit 3


# com_ctz's input pin
$13829181406158* Entrée


# com_equal's input pin
$13859686951415* Entrée 0


# com_add's name
$13973952772642* Additionneur


# com_xnor_bit's name
$14079327237795* XNOR


# com_lsl's output pin
$14132199132916* Résultat


# com_less_u's input pin
$14201184715010* Entrée 0


# com_maker_bit_4's input pin
$14237744302250* Mot 0


# com_keyboard's output pin
$14338437722935* Touche enfoncée


# com_maker_bit_8's description
$14338505460996* Fusionne 8 bits en un octet


# com_level_input_2_pin's description
$14340334686746* Entrée de 2 bits


# com_decoder_3's name
$14375716460090* Décodeur 3 Bits


# com_verilog_input's description
$14408471620057* Entrée Verilog


# Component category name, at most 6 glyphs, the rest is cut off!
$14422565604875* multi


# com_probe_wire_word's name
$14427436420428* Sonde de fil


# com_not_bit's name
$14453052824732* NOT


# com_inc's name
$14456039381703* Incrémente


# Component category name, at most 6 glyphs, the rest is cut off!
$14485213322089* Verilog


# com_nor_word's description
$14517798310461* NOT chaque bits de deux valeurs


# com_maker_bit_2's description
$14531866237078* Fusionne 2 bits en une valeur de 2 bits


# com_splitter_word_8's output pin
$14592399073683* Mot 7


# com_splitter_bit_4's output pin
$14645527447275* Mot 0


# Component category name, at most 6 glyphs, the rest is cut off!
$14686892562446* Mémoire


# 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* Créateur de mot


# com_xor_bit's name
$14832952840086* XOR


# com_register_bit's output pin
$14834136969633* Sortie


# com_maker_bit_2's input pin
$14834270613682* Mot 0


# com_segment_display's input pin
$14849689592952* Valeur


# com_maker_bit_4's input pin
$14852108377004* Mot 2


# com_level_output_2_pin's description
$14875690243444* Sortie de deux bits


# com_maker_bit_8's output pin
$14889574903079* Sortie


# com_mul's input pin
$14896244080868* Entrée 0


# com_mul's input pin
$14913258317738* Entrée 0


# com_probe_wire_word's input pin
$14914933156268* Valeur


# com_level_input_switched's input pin
$14935676453720* Activer


# com_maker_bit_8's input pin
$14944669923906* Bit 7


# com_div's name
$14959426271423* Divise


# com_verilog_output's description
$14973155280765* Sortie Verilog


# com_less_u's output pin
$15024221028085* Résultat


# com_mux's input pin
$15091015683874* Selectionne 0 / 1


# com_asr's description
$15194709458499* Décale les bits vers la droite, tout en maintenant le signe du nombre


# com_probe_wire_bit's description
$15206117280094* Affiche une valeur sur ton composant personnalisé ou dans l'éditeur de programme


# com_splitter_word_8's description
$15228522216068* Divise une valeur de (8n) bits en huit valeurs de n bits.


# com_maker_word_4's input pin
$15232070727738* Mot 1


# com_lsl's name
$15268915597774* Décalage à gauche


# com_inc's output pin
$15310910823919* Résultat


# com_splitter_word_4's output pin
$15360783001914* Mot 2


# com_less_s's name
$15403981009644* Plus petit que < (signed)


# com_maker_word_4's description
$15410415450178* Fusionne quatre valeurs de (n/4) bits en une seule valeur de n bits.


# com_splitter_word_2's description
$15417695246232* Divise une valeur de 2n bits en deux valeurs de n bits.


# com_mux's name
$15422378975821* Mux


# com_less_s's input pin
$15432695156488* Entrée 0


# com_concatenator_4's description
$15492861320167* Concatène 4 valeurs, la largeur de sortie est la somme des largeurs de toutes les entrées


# com_decoder_3's output pin
$15527856774069* Bit 2


# com_rol's description
$15557725551789* Rotationne les bits d'une entrée à gauche


# com_splitter_word_4's output pin
$15566912320742* Mot 1


# com_cc_level_output's name
$15625973306519* Sortie


# com_not_word's output pin
$15635980858172* Résultat


# com_level_output_8_pin's input pin
$15649241608462* Sortie 6


# com_equal's description
$15668435514829* Vérifie si deux valeurs sont égales


# com_maker_word_4's input pin
$15693531522415* Mot 0


# com_splitter_bit_4's output pin
$15744234453408* Bit 3


# com_concatenator_8's input pin
$15759275278695* Mot 4


# com_ror's input pin
$15762072154176* Valeur


# com_xnor_word's description
$15789912406647* XNOR chaque bit de deux valeurs


# com_static_value's output pin
$15833633678405* Taille en bits


# com_maker_word_8's description
$15845204308823* Fusionne 8 valeurs de (n/8) bits en une seule valeur de n bits.


# com_constant's name
$15858905835416* Constante


# com_on's name
$15896157427528* ON


# com_decoder_2's output pin
$15898724303882* Bit 3


# com_concatenator_4's name
$15908922745328* Concaténateur


# com_or_word's input pin
$15962339721851* Entrée 0


# com_probe_wire_word's description
$15969687819995* Affiche une valeur sur ton composant personnalisé ou dans l'éditeur de programme


# com_clz's input pin
$15988469904002* Entrée


# com_register_word's name
$16007777261800* Registre


# com_time's name
$16011300295966* Horloge


# com_splitter_word_4's output pin
$16099286786157* Mot 3


# com_static_indexer's description
$16103423834548* Décale la valeur d'un fil d'une quantité fixe sans aucun délai ni coût en porte. Les valeurs positives décalent à droite, les negatives à gauche


# com_lsr's input pin
$16105779236896* Valeur


# com_less_s's input pin
$16118461327893* Entrée 1


# com_splitter_word_8's output pin
$16120663256468* Mot 4


# com_level_output_word's description
$16148744080822* Mot de sortie qui sera convertit en connecteur d'entrée/sortie si la solution du niveau est enregistrée comme composant


# com_maker_word_2's input pin
$16178897760565* Mot 1


# com_splitter_bit_8's input pin
$16196769003341* Entrée


# com_on's description
$16212935718484* Toujours [T]


# com_mod's name
$16223673009720* Modulo


# com_level_output_4_pin's input pin
$16259545926196* Sortie 0


# com_ror's output pin
$16261916666444* Résultat


# com_level_output_3_pin's name
$16269858195218* Sortie


# com_static_eval's name
$16294314784377* Évaluateur statique


# com_less_u's input pin
$16307028951926* Entrée 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16316545288606* Logique


# com_load_port's name
$16380513614754* Connecteur de charge


# com_counter's late input pin
$16380665909610* Écraser


# com_splitter_bit_4's description
$16428357982878* Divise une valeur de 4 bits en 4 bits.


# com_load_port's description
$16440979564796* Ajoute une broche de charge à un composant mémoire


# com_concatenator_4's output pin
$16450922709110* Résultat


# com_lsl's description
$16482114876737* Décale les bits d'une entrée à gauche


# com_mul's name
$16549841656852* Multiplie


# com_add's output pin
$16559516323162* Résultat


# com_splitter_word_4's name
$16563671560208* Séparateur


# com_level_input_3_pin's description
$16604606953092* Entrée de trois bits


# com_maker_word_4's name
$16610055905190* Créateur de mot


# com_decoder_3's output pin
$16637198920534* Bit 1


# Component category name, at most 6 glyphs, the rest is cut off!
$16656763610465* Sorties


# com_xor_word's input pin
$16674052164634* Entrée 0


# Component category name, at most 6 glyphs, the rest is cut off!
$16684378975952* Personnalité


# com_decoder_1's description
$16685462633615* Bascule entre deux sorties


# Component category name, at most 6 glyphs, the rest is cut off!
$16744990871521* Niveaux


# com_rol's name
$16755142829250* Rotation à gauche


# com_segment_display's description
$16761198694928* Bon pour l'affichage de nombre


# com_keyboard's description
$16766452660421* Enregistre les pressions de touche de ton clavier physique


# com_decoder_3's input pin
$16773243310913* Désactiver


# com_level_input_switched's description
$16797889673362* Charge les entrées du niveau


# com_and_word's output pin
$16806711173957* Résultat


# com_cc_level_input's name
$16810631435170* Entrée


# com_and_3_bit's description
$16839706221116* Porte AND à 3 entrées


# com_xor_word's name
$16843812162355* XOR


# com_xor_bit's description
$16856280609387*
[T] quand les entrées sont différentes


# com_level_input_2_pin's name
$16870364449392* Entrée


# com_static_eval's description
$16874064281189* Calcule une valeur avant la simulation (elle sera constante pendant la simulation)


# com_probe_memory_bit's description
$16875362121056* Affiche une valeur sur ton composant personnalisé ou dans l'éditeur de programme


# Component category name, at most 6 glyphs, the rest is cut off!
$16900787805858* Mot


# com_switch_bit's description
$16917313833836* Commute un bit


# com_concatenator_8's name
$16974631589430* Concaténateur


# com_cc_level_output's input pin
$17030391013189* Sortie


# com_splitter_bit_8's output pin
$17053062486634* Bit 4


# com_or_word's name
$17053670145576* OR


# com_xnor_word's output pin
$17089816656649* Résultat


# 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* Valeur statique


# com_store_port's description
$17240636780043* Ajoute une broche de sauvegarde à un composant mémoire


# com_mod's input pin
$17244932190980* Diviseur


# com_or_bit's name
$17247779246257* OR


# com_splitter_bit_2's output pin
$17293853955838* Bit 1


# com_switch_word's description
$17345192339084* Commute un octet


# com_delay_line_word's name
$17407828844862* Ligne à retard(délai)


# com_splitter_word_8's output pin
$17425893786880* Mot 6


# com_concatenator_2's name
$17495243848605* Concaténateur


# com_nor_bit's description
$17510848535619*
[T] quand aucune des entrées n'est [T]


# com_maker_bit_8's input pin
$17515061804367* Bit 0


# com_full_adder's description
$17559382166174* Additionne 3 bits et fournis la somme et la retenue


# com_or_3_bit's description
$17576327690867* porte OR à 3 entrée


# com_maker_word_8's name
$17581447274882* Créateur de mot


# com_register_word_config's name
$17630501850089* Registre Automatique


# com_level_output_3_pin's input pin
$17644027370563* Sortie 2


# com_splitter_bit_8's output pin
$17664445405251* Bit 5


# com_full_adder's name
$17669928463861* Additionneur complet


# com_register_bit's description
$17670626909848* 1 bit de mémoire


# com_maker_word_4's input pin
$17742753106024* Mot 3


# com_register_bit's late input pin
$17744526831576* Activer


# com_concatenator_2's output pin
$17758165407719* Résultat


# com_counter's late input pin
$17764401720104* Écraser la valeur


# com_equal's input pin
$17767800149691* Entrée 1


# com_static_value's description
$17781742628050* Défini facilement la valeur ou la taille de composants personnalisés


# com_add's input pin
$17802619460312* Retenue d'entrée


# com_cc_input's name
$17814826739168* Connecteur d'entrée


# com_add's input pin
$17820183531095* Entrée 0


# com_splitter_bit_4's output pin
$17862413256378* Bit 1


# com_equal's output pin
$17864898529357* Résultat


# com_maker_bit_4's input pin
$17897455882076* Bit 1


# com_store_port's input pin
$17908666907710* Valeur à conserver


# com_concatenator_8's input pin
$17908668221433* Mot 7


# com_maker_bit_8's input pin
$17957417956069* Bit 3


# com_level_output_switched's input pin
$17979647868788* Sortie


# com_load_port's output pin
$17988237627670* Sortie


# com_nand_word's name
$17989404583269* NAND


# com_store_port's input pin
$18001316449428* Adresse


# com_counter's name
$18007194288764* Compteur


# com_splitter_word_8's name
$18008204445107* Séparateur


# com_add's input pin
$18009367936916* Entrée 1


# com_div's input pin
$18043895181775* Dividende


# com_maker_bit_2's output pin
$18060429242565* Sortie


# com_probe_wire_asm's late input pin
$18082830776248* Adresse


# com_not_word's input pin
$18100827224098* Entrée


# com_and_word's input pin
$18149321315676* Entrée 1


# Component category name, at most 6 glyphs, the rest is cut off!
$18160228892566* IO


# com_keyboard's input pin
$18168295822085* Lire la suite


# com_store_port's input pin
$18196820862263* Activer


# com_delay_line_bit's description
$18206009264853* Conserve l'entrée pendant 1 cycle


# com_decoder_3's output pin
$18208851966397* Bit 3


# com_decoder_1's name
$18250587600120* Décodeur 1 Bit


# com_level_output_2_pin's input pin
$18282543476901* Sortie 0


# com_level_output_4_pin's description
$18308856504509* Sortie de 4 bits


# com_level_output_switched's description
$18319747827404* Sortie pour les resultat de niveau


# com_level_output_1_pin's description
$18342586404936* Sortie d'un bit


# com_maker_word_2's input pin
$18365137610205* Mot 0


# com_neg's name
$18379907297327* NEG


# com_load_port's input pin
$18399493738021* Activer


# com_register_bit's late input pin
$18405644304073* Valeur


# com_full_adder's output pin
$18410639135888* Retenue de sortie


# com_concatenator_2's input pin
$18414950181373* Mot 1


# com_splitter_word_8's output pin
$18425501753807* Mot 0


# com_add's description
$18429814030509* Additionne deux entrées


# com_splitter_bit_8's output pin
$18437214963047* Bit 7


# com_delay_line_word_config's description
$18447417990806* Conserve l'entrée pendant 1 cycle


# com_full_adder's input pin
$18480011054605* Retenue en entré


# com_probe_memory_word's name
$18495107507052* Sonde mémoire


# com_time's output pin
$18510923212418* Nanosecondes depuis le premier janvier 1970


# com_maker_bit_4's output pin
$18538545767544* Sortie


# com_splitter_word_8's output pin
$18541722201520* Mot 2


# com_asr's input pin
$18563543025377* Valeur


# com_splitter_bit_2's description
$18566798809283* Splits a 2-bit value into 2 bits


# com_register_word_config's late input pin
$18592599175225* Valeur à enregistrer


# com_or_word's output pin
$18599325743999* Résultat


# com_nand_word's output pin
$18604301487974* Résultat


# com_mul's description
$18631919890554* Multiplie deux entrées


# com_less_u's description
$18645721548287* Vérifie si la premiere entrée vaut moins que la seconde


# com_maker_word_8's input pin
$18747558269936* Mot 7


# com_maker_bit_8's name
$18747779812970* Créateur


# com_time's description
$18774996925434* Nano secondes depuis le 1er janvier 1970


# com_maker_bit_4's description
$18837875001662* Fusionne 4 bits en une valeur de 4 bits


# com_clz's description
$18865460617183* Compte les zéros à partir du bit le plus significatif jusqu'au premier 1


# com_and_bit's name
$18912167455465* AND


# com_concatenator_4's input pin
$18970466583796* Mot 2


# com_decoder_3's output pin
$19041825668970* Bit 0


# com_level_output_counter's description
$19047791955795* Sortie de trois bits


# com_maker_word_8's input pin
$19068496076705* Mot 2


# com_load_port's input pin
$19069820293504* Adresse


# com_concatenator_8's input pin
$19112189486457* Mot 6


# com_lsl's input pin
$19120200575252* Décale de


# Component category name, at most 6 glyphs, the rest is cut off!
$19169839564869* Sondes


# com_level_input_4_pin's description
$19187328896214* Entrée de quatre bits


# com_register_word_config's description
$19209488297941* Version du registre à taille automatique


# com_maker_bit_8's input pin
$19209724501083* Bit 2


# com_ctz's name
$19218324472471* Compte les zéros de queue


# com_splitter_word_8's output pin
$19229992367375* Mot 5


# com_div's description
$19251828025705* Divise 2 entrées


# com_decoder_2's output pin
$19275565166747* Bit 0


# com_verilog_output's input pin
$19276197821142* Entrée


# com_concatenator_4's input pin
$19277763516215* Mot 3


# com_xnor_word's input pin
$19329533997829* Entrée 0


# com_nor_word's input pin
$19354802063529* Entrée 1


# com_equal's name
$19369982838671* Égal


# com_lsr's description
$19394421220436* Décale les bits d'une entrée à droite


# com_div's output pin
$19403575811053* Résultat


# com_or_word's description
$19406015796751* OR bit à bit sur deux valeurs


# com_delay_line_word_config's name
$19421095581293* Ligne à retard(délai) Automatique


# Component category name, at most 6 glyphs, the rest is cut off!
$19451948914812* Math


# com_level_output_switched's name
$19513138880387* Sortie commuté


# com_probe_wire_bit's name
$19521764791439* Sonde de fil (bit)


# com_maker_word_8's input pin
$19579002124406* Mot 4


# com_inc's input pin
$19579388993928* Entrée


# com_xnor_word's input pin
$19579585753615* Entrée 1


# com_or_3_bit's name
$19630419947500* OR à 3 connecteur


# com_splitter_word_2's input pin
$19630801846451* Entrée


# com_and_3_bit's name
$19664974941910* AND à 3 connecteur


# com_register_word_config's late input pin
$19717901345023* Activer la sauvegarde


# com_xor_word's input pin
$19719622211817* Entrée 1


# com_maker_word_8's input pin
$19740232065347* Mot 0


# com_lsr's output pin
$19748092068880* Résultat


# com_maker_word_8's input pin
$19779691531031* Mot 5


# com_verilog_input's name
$19796166910463* Entrée Verilog


# com_static_indexer's name
$19804933576629* Indexeur statique


# com_ram's description
$19814732518166* Composant mémoire large


# com_cc_level_input's description
$19864966939331* Une entrée qui sera convertie en entrée personnalitée si la solution est enregistrée dans la fonderie


# com_ctz's output pin
$19883191600386* Résultat


# com_splitter_word_8's output pin
$19903808503639* Mot 1


# com_rol's output pin
$19903955254861* Résultat


# com_screen's description
$19974317694842* Écran configurable


# com_push_button's name
$20020953885936* Bouton-poussoir


# com_level_output_3_pin's input pin
$21084166025569* Sortie 1


# com_level_input_word's output pin
$21448308897245* Entrée


# com_level_input_2_pin's output pin
$24473197268827* Entrée 0


# com_probe_wire_asm's description
$27381538627533* Désassemblera l'entrée conformément à la spécification ISA de l'architecture


# com_level_output_word's input pin
$27680966493404* Sortie


# com_level_output_4_pin's input pin
$29217965518477* Sortie 1


# com_static_eval's output pin
$29937009351190* interprété comme taille


# com_level_input_4_pin's output pin
$36196915566111* Entrée 3


# com_level_output_8_pin's input pin
$38015555977208* Sortie 3


# com_level_output_4_pin's input pin
$39260627694444* Sortie 3


# com_level_output_8_pin's input pin
$39299381405096* Sortie 0


# com_level_output_3_pin's input pin
$39908016538045* Sortie 0


# com_delay_line_word's output pin
$40182352594863* Sortie


# com_level_output_8_pin's description
$41781588125341* Sortie 4 bits


# com_level_input_3_pin's output pin
$42291627335021* Entrée 2


# com_delay_line_bit's late input pin
$43397945955203* Entrée


# com_level_output_2_pin's input pin
$44555908976270* Sortie 1


# com_level_input_4_pin's output pin
$45891070331034* Entrée 1


# com_level_output_1_pin's input pin
$50802766489958* Sortie


# com_probe_wire_asm's name
$53494192640542* sonde de désassemblage


# com_delay_line_word's description
$53901484249817* Conserve l'entrée pendant 1 cycle


# com_screen's input pin
$55023356915123* Index de paramètre


# com_level_input_2_pin's output pin
$55925432534232* Entrée 1


# com_push_button's description
$57617462098732* envoie [T] en sortie tant que le bouton est enfoncé


# com_register_word's output pin
$58518173140953* Valeur


# com_cc_level_input's output pin
$59388037506003* Entrée


# com_decoder_3's description
$61176454433312* Bascule entre huit sorties en fonction d'une broche d'entrée de 3 bits


# com_level_output_8_pin's input pin
$62385154489080* Sortie 2


# com_screen's input pin
$63216408139965* Activer


# com_level_delay_gate's description
$64425234668581* Utilisé pour créer la carte des niveaux. Dispose d'une broche supplémentaire qui délivre le meilleur délai du niveau.


# com_level_output_8_pin's input pin
$64999131838438* Sortie 4


# com_level_input_3_pin's output pin
$65765566466116* Entrée 0


# com_level_input_switched's output pin
$69212597107829* Entrée


# com_level_input_4_pin's output pin
$70142958857584* Entrée 2


# com_level_output_8_pin's input pin
$72375982885383* Sortie 1


# Component category name, at most 6 glyphs, the rest is cut off!
$75263091584586* Auto


# com_level_input_3_pin's output pin
$79311371309532* Entrée 1


# com_level_input_4_pin's output pin
$81933801309767* Entrée 0


# Component category name, at most 6 glyphs, the rest is cut off!
$82535571951563* Divers


# com_level_output_counter's input pin
$84023157447564* Sortie 0


# com_register_word_config's output pin
$84598344098990* valeur


# com_static_indexer_config's description
$85065774878853* Version avancée de l'indexeur statique. Le décalage et la taille de la sortie sont déduits de la taille des fils connectés aux broches d'entrée


# com_level_output_counter's input pin
$86331851878040* Sortie 1


# com_decoder_2's description
$86848277190736* Bascule entre quatre sorties en fonction d'une broche d'entrée de 2 bits.

$87754378235471* Sortie


# com_level_output_4_pin's input pin
$87954408093587* Sortie 2


# com_screen's input pin
$88137790657923* valeur


# com_level_output_8_pin's input pin
$88250281919265* Sortie 5


# com_static_eval's output pin
$89594489498667* interprété comme valeur


# com_level_output_counter's input pin
$89669851602178* Sortie 2


# com_level_output_8_pin's input pin
$90233476470983* Sortie 7



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

$12097260550100* La valeur {num} est hors de la plage pour {field}

$15585581119466* L'instruction  '{instruction_name}' ne comporte pas de définition de champ de bits

$15728875852508* Échec de lecture pour {file}

$18981788561705* Espace blanc attendu ici

$19131785861372* Inclusion récursive de : 

$19581803133960* '{syntax}'  attendu après  '{partial_instruction}'

$21828993759952* Instruction inconnue

$23413102374088* Instruction invalide

$30066682696902* l'assertion {source} n'a pas correspondu

$33085034295813* Un nombre ou un symbole est attendu.

$35071857261934* Un espace blanc était attendu après 'as'

$35210741057769* ligne incompréhensible

$37770431994640* Instruction invalide

$39195841380612* Le label {name} est déjà déclarée

$42442531119863* {constant_name} est déjà déclarée

$45433710484419* La taille est attendu avant le nombre, comme: U64 {number}

$47300717145684* '=' manquant après  'const'

$48895355188042* un littéral numérique est attendu après '@'

$51460031660101* Impossible d'assembler l'instruction sur la résolution du label {name}: {err}

$51466436379956* Ne peut effectuer qu'un remplissage vers l'avant, l'adresse actuelle est : {address}

$53378617686677* La valeur {num} est hors de la plage pour {field}

$57794055991905* Erreur lors de l'évaluation de l'assertion {assertion}: {err}

$58979769991732* Nouvelle ligne attendue après 'include'

$59248806788382* Impossible de faire référence au label privé {name}

$60515742509356* Un nombre est attendu après la déclaration de taille

$60631582636278* label non définie {name}

$62050046600010* Le nom de fichier  {name}  ne peut pas être utilisé comme alias référençable, déclarer un autre alias en utilisant le mot-clé 'as', par exemple 'include .A as A'

$66273157704409* Il manque un opérande '{field_type}' ici

$66575346967082* Le fichier n'existe pas: 

$67922577781529* Seuls les multiples positifs de 8 bits sont pris en charge pour le moment

$68530592279217* Un nom d'opérande valide était attendu, mais '{operand_name}' a été trouvé parmi {all_operand_names}

$69537550553443* Au moins un espace blanc est attendu après '{partial_instruction}'

$71714150108621* Erreur lors de l'évaluation de l'opérande %{operand_name}: {err}

$76017808702292* La largeur de l'instruction '{instruction_name}' est de {width} bits, mais seuls les multiples de 8 sont pris en charge.

$79977943868423* '{field_string}' n'est pas un '{field_type}'

$80097289956044* un espace est attendu entre la taille et le nombre, comme U{size} {number}

$82512572175623* Fin inattendue de l'instruction après {partial_instruction}

$83023561541280* Nom de label attendu ici

$83649060120708* Les nombres signés ne sont pas pris en charge

$84557608492963* Code inconnu trouvé après l'instruction: 

$86607635528717* Constante non définie {field_string}

$87525828760679* Échec de la résolution du motif ({err}): {resolved_pattern}

$90294506138532* La valeur de définition doit être soit un nombre, soit un champ.



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

$14037712136328* Opérande  {op} introuvable

$15525193700799* préfixe de l'opérateur non reconnu

$16677833364088* Identifiant non reconnu: %{operand}

$17795651801484* Attendue ':'

$18996202754936* Attendue ')'

$21791372106633* Attendue '('

$36919792698704* Pointeur d'instruction non disponible

$49919016022369* Adresse non reconnue : ${identifier}

$50863314907270* Attendue ')'

$62520916869207* Attendue ','

$76203559781109* Attendue ']' ou ':', obtenu  '{sep}'

$86940018019179* Identifiant invalide: %{operand}



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

$11703098452145* Nom du paramètre inconnu {name}

$11824708197936* Un nom de champ/motif valide était attendu, obtenu '{operand_name}'

$15904571494199* Syntaxe de tranche(slice) attendue après la référence de champ/motif dans le motif binaire

$16564670893367* un nom de motif est attendu ici

$18247681204565* ')' attendu après l'assertion

$18304638469397* Une chaîne de caractères non vide est attendue pour commencer les commentaires de ligne.

$19678805612580* Les références de champs répétées ne correspondent pas

$20574862674671* Nouvelle ligne attendue après le champ virtuel

$20981379307111* Les bits fixes dans  %{operand} ne correspondent pas

$23037984432484* ':' attendu après la condition 'when'

$24713798894610* La limite supérieure prévue ne devrait pas dépasser 32767

$25123045290962* l'en-tête [instructions] était attendu ici

$25249187420360* Le nom d'une option ou le début de la section suivante était attendu.

$25285447732570* La limite supérieure attendue ne peut être inférieure à la limite inférieure.

$26426549472884* Trop d'opérandes virtuels

$27111936748508* Une parenthèse fermante était attendue après le type de modèle

$28197258085607* Syntaxe de tranche attendue après la référence de champ/motif dans le motif binaire

$29837913233106* Nouvelle ligne attendue entre les instructions

$31223930569837* La limite supérieure attendue ne peut être inférieure à la limite inférieure.

$32763965727763* Les bits d'extension de signe ne correspondent pas

$33105996916812* Les motifs ne peuvent invoquer que ceux définis avant eux.

$33504435568130* Impossible d'interpréter l'opérande virtuel %{variable_name}: {err}

$33645913580119* Trop de types de champs, au maximum {max_field_types} sont autotisés

$33890983338825* Liste de chaînes de caractères(string) attendue

$35053289858864* Trop de motifs, au maximum  {max_patterns} sont autorisés

$35468867558322* Nouvelle ligne attendue après l'en-tête de section

$39427635035157* Paramètre dupliqué '{name}'

$40392382190976* modèle binaire attendu pour {field_name}

$40815956642962* Syntaxe de tranche(slice) attendue après une référence à un nombre en base 16 dans un motif binaire

$42160516340132* '(' ou '[' attendu après le nom de l'opérande, par exemple : {variable_name}(immediate), {variable_name}[pattern()]

$42907704133778* ')' attendue après la liste des paramètres de motif

$43708359021513* Le motif doit comporter un corps.

$45247724910259* Valeur de l'opérande hors de la plage des entiers non signés sur {n} bits

$45267257140327* Nouvelle ligne attendue après l'en-tête de section

$45631078896174* La limite supérieure prévue ne devrait pas dépasser 32767

$47258389995911* ',' est attendue entre les paramètres du motif.

$48321097736953* Le nombre hexadécimal attendu ne doit pas dépasser 32767 chiffres

$48639756889210* La largeur de l'instruction ne peut pas être 0.

$48942522553057* Syntaxe de tranche(slice) attendue après la référence de champ/motif dans le motif binaire

$50971737349470* Les opérandes de type motif ne sont pas encore pris en charge en désassemblage

$51752498682665* Le nom de champ '{field_name}' n'est pas défini

$52261961290701* Syntaxe de tranche(slice) inversée après une référence à un nombre en base 16 dans un motif binaire

$52710717731997* saut de ligne attendu ici après la déclaration de syntaxe

$55289908013299* L'opérande virtuel {variable_name} a masqué un autre opérande sur la ligne de syntaxe

$55444523984237* Une parenthèse fermante était attendue après le type de champ.

$55537815420873* ',' ou ')' est attendu après l'argument de motif

$55929094649794* un tableau de chaînes de caractères(string) était attendu

$56352157276583* Valeur de l'opérande hors de la plage des entiers signés sur {n} bits

$57773886232356* Un nom était attendu pour le type de champ

$58295598661589* La description dans les motifs doit rester vide

$59115040206693* Une chaîne de caractères non vide est attendue pour commencer les commentaires de bloc

$59388744207582* un saut de ligne est attendu à la fin du motif binaire

$59877879891546* Impossible d'interpréter l'expression de condition  'when': {err}

$61352853872444* Seuls les champs immédiats de largeur 0 à {max_field_size} sont autorisés

$61772889138477* '(' est attendue avant la liste des paramètres du motif

$62103010038950* Nouvelle ligne attendue après l'en-tête de section

$62334191081955* Syntaxe de tranche(slice) attendue après une référence à un nombre en base 16 dans un motif binaire

$62712568576067* Nom du type de champ en double : {name}

$63072912015761* Nouvelle ligne attendue avant le corps du motif

$63246722572594* Syntaxe de tranche(slice) attendue après la référence de champ dans le motif binaire

$63957561177031* Motif '{pattern_name}' avec {argument_count} paramètres non défini

$64093416909416* Un identifiant est attendu après '%'

$67219559926029* Les noms de champs ne peuvent pas contenir d'espaces

$67707174963301* Un identifiant est attendu après '%'

$68066163358870* Espace blanc attendu après 'when'

$68462760531745* Le motif binaire de {field_name} a une longueur de {actual} bits, attendu {expected} bits.

$68533544457789* L'opérande {variable_name} sur la ligne de syntaxe a masqué un autre opérande.

$68587613470552* Nom de la valeur du champ attendu

$70205284263092* Une chaîne de caractères(string) non vide est attendue pour terminer les commentaires de bloc.

$70814401439344* La limite supérieure attendue ne peut être inférieure à la limite inférieure

$72400465574342* Seules les longueurs de champ allant jusqu'à  {max_field_width} bits sont prises en charge

$72620639818015* Nouvelle ligne attendue après l'en-tête de section

$72958581072457* Un nom est attendu pour le motif

$73627734748417* Mot-clé 'pattern' attendu avant le nom du motif

$75146029145419* Un nom est attendu pour le paramètre de motif

$76494975412451* Un nom d'opérande valide est attendu, mais '{operand_name}' a été trouvé parmi {all_operand_names}

$77234329031993* Syntaxe de tranche(slice) attendue après la référence de champ/motif dans le motif binaire

$77449878176461* Un identifiant est attendu après '%'

$77851254343918* Aucun opérande ne commence par le caractère '{c}'.

$78591996283483* un nom de champ ou à une valeur immédiate dimensionnée est attendu ici

$79195048703101* Un '=' est attendu ici

$79975911393070* Syntaxe de tranche(slice) attendue après la référence de champ/motif dans le motif binaire

$81691406697268* Limite supérieure attendue dans la syntaxe de tranche après la référence de champ dans le motif binaire

$82876816015252* Trop de chemins d'options d'opérandes pour le désassemblage automatique, au maximum {num_path} sont autorisés

$83804207975330* La limite supérieure prévue ne devrait pas dépasser 32767

$85972591916322* Nouvelle ligne attendue après la définition de l'affectation

$87843223218582* La largeur de l'instruction est de {width} bits, mais seuls les multiples de 8 sont pris en charge

$90809893168338* L'opérande immédiat doit comporter une contrainte de taille, par exemple  %a:U8(immediate), %b:S1(immediate|label)



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

$10198498286711* Séquence d'échappement inachevée

$11064758781325* '"', ''', ou '`' attendus au début du contenu des cellules du tableau d'interface utilisateur

$12492443144951* ',' attendu ou fin du tableau

$13040813748160* une clef est attendu

$19807940646400* {expected} etait attendu, obtenu {actual}

$22378976352410* ligne {num}: 

$22452670489981* nombre littéral attendu

$25983481845150* '{symbol}'est attendu, EOF(fin du fichier) obtenu

$27682737127628* Un guillemet ouvrant est attendu (parmi ", ' ou `)

$29112746104375* booléen attendu ici.

$33400766069212* parenthèse ouvrante attendu (une de '(', '[' ou '{{'), obtenu '{open}'

$33551107641907* Int littéral trop grand

$36313699368590* séquence d'échappement octale invalide

$43326454052643* U attendu pour non-signé ou S pour signé ici

$44942745729831* Séquence d'échappement hexadécimale invalide

$49180229055343* une valeur est attendue

$51855228989260* Littéral entier non signé invalide

$56457570130031* Caractère d'échappement invalide '{nc}'

$64743950507593* Valeur de liste attendue

$64926004981217* Littéral entier invalide

$66187706284192* ':' attendu après la clef

$71666516845083* Un nombre littéral non signé est attendu.

$72110029133381* {prefix} attendu

$73113688099439* L'un des éléments suivants est attendu {expected}

$73973243772156* littéral de nombre signé attendu

$75565287060042* Fin de fichier inattendue lors de l'analyse d'une chaîne de caractères

$77089554485217* indication de taille attendu ici

$82386938622647* Caractère attendu après le caractère d'échappement '\\'



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

$12246885387560* variable {name}


# Assembly label
$17885987456433* label

$18299156828551* immédiat signé de {n}-bit

$74639900282369* immédiat non-signé de {n}-bit



=== model/translations.nim ===

$11567406591202* 1 octet

$14036822471924* Il y a {days} jours

$16391754618645* {size} KB

$17901039729248* Il y a {months} ​​mois

$18300496139706* Il y a un mois

$18683857303458* {size} octet

$21685594109067* Tout à l' heure


# Million
$22896492410578* M

$42553566189409* Il y a {minutes} minutes


# Quadrillion
$49300594926837* Q

$70945526841433* Il y a {years} ans


# Billion
$71072134093858* G

$84076931764831* Il y a 1 jour


# Thousand
$84696693690500* k

$86244493049244* Il y a {hours} heures


# Trillion
$87907122406742* T

$95018143828198* Il y a un an

$98363990684104* Il y a une heure

$98703677236827* Il y a une minute



=== presenter/board_ui.nim ===

$36331525379247* Enregistrer ce schéma



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

$55369640789869* Clique n'importe où sur le plateau pour démarrer un fil\nConnecte le composant rouge et la porte NAND

$79416009887091* Clique n'importe où sur le plateau pour placer la porte

$86840165316981* Clique droit pour déselectionner la porte



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

$13880985462901* Réalise un circuit pour lequel l'entrée du composant dépend de sa propre sortie.

$16336401898647* Test 1/2

$22446480186064* Crée une dépendance circulaire incluant au moins 2 composants

$32314337981189* Vérifie

$73467991035922* Sans espoir !

$89309211963063* Test 2/2



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

$10634456248075* Entrée 1

$10792411581963* {size}Mo

$10967837475411* Entrée 1

$12673774208656* Bit 1

$12729457392140* {size} Go

$12806857886815* Bit 0

$12955769263032* Entrée

$13973719570693* Taille

$14527438551030* Entrée

$14913356525578* Coût

$16406822661708* Entrée

$17231618567710* Donnée d'initialisation

$18430168550669* Sortie

$23494294864855* Min {unit}

$23854618911893* Retard simulé

$24632471752785* Fichier

$26116781897961* Coût

$27295540163510* Entrée 1

$30447216087962* décalage

$31208530565026* Entrée 0

$32492998000365* Entrée 0


# com_static_eval's expression
$32721727081818* Expression

$34792822299047* Entrée 1

$36741466396909* Entrée 2

$39848783424235* Entrée

$40353371905977* Constante


# Load a level
$41294322771286* Charger

$45584048068675* Entrée 1

$47647445869837* Zeros

$48920514303805* Fonderie

$49848147518867* Entrée 2

$50011261574308* Entrée 1

$50488075986026* Sortie

$52764622766005* Sortie

$53201813578269* Assembleur

$55717355371460* Sortie

$56555605872372* Sortie

$58366024847549* Entrée 0

$58805963760936* décalage à droite positif, décalage à gauche négatif

$59987930153159* Sortie

$60193172250813* Le paramètre que tu as choisi pour ce composant occupera {size} de mémoire sur ton ordinateur. es-tu d'accord ??

$61114700325299* Entrée 0

$64034551286307* Persistant

$64695289448271* Les 8 bits de la valeur activent chacun une des 8 zones de l'afficheur.

$65186041856822* Sortie

$65254105186908* Sortie

$65365515206856* Remarque : bien que le composant mémorise de nombreux événements d'enfoncement et de relâchement de touche, il n'en émet qu'un seul par cycle !

$69729205667293* Éditeur hexadécimal

$70002762618597* Bas

$71918065858983* Enregistrer

$75293122338496* Cycles pour compléter

$76078010638637* Activer

$76120552154698* Entrée 0

$76125262162505* Entrée 1

$77252050278971* Sortie

$78475032277779* Entrée 0

$80252365204151* Carte perforée

$81678588906692* Message d'arrêt

$82521178851608* Entrée 0

$84542005958715* Label

$85815999713437* Entrée 1

$86658255589213* Données mutables

$88655619989708* Entrée 0

$88881918807029* Immutable

$89612128414294* Sens de l'étiquette

$90286330794518* Sortie

$91063734228931* Gauche

$95419083709418* little endian

$95766090310621* Droite

$97169317610794* Haut



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

$24027424800887* Niveau suivant

$70403032472607* Bien joué ! Passons au prochain niveau.

$80966247197959* Cliquez sur le bouton Entrée en haut à gauche pour activer l'entrée.



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

$32982011047799* Vérifie

$43078933051174* Clique sur les boutons gris de la dernière ligne du tableau.

$61241226128494* Non !

$71204033550134* Que fait la porte NAND ?



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

$95509904060545* Valider



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

$21618236951146* Regarder la solution

$65770257567603* Si tu es sûr que tu veux voir la solution, clique sur le bouton ci-dessous.



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

$10446152707984* Adresse

$20074247151096* Instruction

$41540713506719* Instruction

$64281970848639* Description



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

$10463931654475* Entrée 0

$14057674753878* Entrée 1

$58374689721038* OCTETS

$73841752788709* Entrée

$74796974148718* Sortie



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

$70994998239232* Clique sur la porte NAND à sélectionner



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

$18403698792036* Type de niveau

$41662660252584* Curseur

$53456282160464* Mode bac à sable

$72245209470436* IPS

$74564675939961* Vitesse de sim

$99534264629442* Test



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


# Placeholder on the name input field of the file explorer
$18871898542185* Nouveau dossier

$56429258960561* Renommer

$69090690657232* Cloner


# Load a schematic
$70369485875359* charger


# Placeholder on the name input field of the file explorer
$84870575118100* Nouvel objet

$91861509153454* Supprimer



=== presenter/board_ui/function_icons.nim ===

$36396661222670* Clique droit pour augmenter la vitesse simulation.

$39440928972984* Reset ({key})

$42454393978813* Clique sur ce bouton pour lancer les tests

$53448014080434* Supprimer (Raccourci : Clic droit)

$54853798559740* Exécution rapide ({key}) (clic droit : modifier la vitesse cible)

$66405942066048* Précédent

$68617247634978* Taille en bit (Clic droit: Changer la taille)

$69987793052607* Commentaire de fil (Cliquer sur le fil)

$78287906849040* Couleur de fil

$80451578314373* Zoomer

$80746616574054* Suivant ({key}) (Clic droit pour passer au cycle suivant) 

$84434122873489* Dézoomer

$85147529532131* Sélection multiple (Raccourci : SHIFT & glisser)



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


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


# MEMORY section title on the left panel
$34156015279634* MÉMOIRE


# INPUTS section title on the left panel
$64033841051521* ENTRÉES



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

$11731996208080* Fonderie

$30516879701896* Bac à Sable

$33761197388580* Afficher les indices

$38557550573896* Présentation du niveau

$50924073287410* Choix du format de nombre

$56916384895438* Menu Général

$71951682957395* Carte des niveaux

$79554853897000* Changer de schéma

$85248932172256* Masquer les indices

$85430022417382* Montrer les délais

$91515053618360* Manuel

$98930461722118* Revenir au niveau



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

$68227209887733* Fonderie


# Placeholder for the search bar in the level tree
$72813322690589* Recherche de niveau



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


# OK button on popups
$26766209496460* Ok

$36265530817755* Sauter à l'adresse

$40263691211335* décalage en octets (16, 0xF, ...)



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

$37885763626223* Link RAM

$51331074553774* How many registers

$67225915898937* Prefix

$67275059688693* Size

$77103446544344* Example: reg_

$77741358519166* Count



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

$19062117579269* Simule jusqu'au cycle: 



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

$16026817441460* cycles/sec



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

$52150443679969* Continue

$89787506720574* Fermer



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

$10090938799865*
[large]Entrée de manuel[/large]
Entrée: [color=#68d277]{page}[/color]

$14047403461014* Énergie (porte x delais(retard))

$16820079067437* Niveau terminé

$20801641140962*

[b]Mode carte de niveaux[/b]
[color=#cccccc]Clique "[color=#e49f44]C'est parti[/color]" et tu verras[/color]

$26794262854382* Jeter

$30368115829346* Pire cycle

$32133561664335* Garder les deux

$33922330743421*

[b]Couleur de fil[/b]
[color=#cccccc]Organise tes fils avec des couleurs.[/color]

$40510295620397* Écraser

$41649402437253*

[b]Nombres négatifs[/b]
[color=#cccccc]Bascule entre nombres signés 
et non-signés[/color]

$43462148240207* Instructions par cycle

$43591599177045* Énergie (porte x delais(retard))

$44038153424304* Une sauvegarde nommée "{save}" existe déjà.

$45250062735373* Déverrouillé

$51096427131653* C'est parti !

$53037516781370* Conflit de sauvegarde: 

$53389567901907* Un composant personnalisé appelé "{comp}" existe déjà.


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$58769207148712* Composant

$65428404547905* Stats


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$66101029228279* Programmation


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$69219742310717* Architecture

$69511102367948* Type

$72987046679863* Temps (delai x cycles)

$76805548224716* La taille totale de la RAM est trop élevée ! Cette solution ne sera pas prise en compte par le serveur.

$78783902500954*

[b]Profil en ligne[/b]
[color=#cccccc]trouve-le dans le menu principal.[/color]

$84923734370936* Pire test


# This is a level kind, similar to Architecture, Programming & Component levels on the website
$90134890578411* Divers

$92313038380926* Niveau

$92673421413755*

[b]Commentaire de fil[/b]
[color=#cccccc]Ajoute des commentaire à tes fils.[/color]

$94261690850981*

[b]Hexadecimal[/b]
[color=#cccccc]Bascule entre l'affichage de nombre signés, non-signés et hexadécimaux[/color]



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


# IDE tab name
$11106925604855* Fichier

$11967666262990* Erreur de spécification ! Ouvre l'éditeur de spécification pour la corriger

$13400106910274* Ligne {nr}: {msg}


# IDE tab name
$88520918982355* Registres



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

$63693638857058* Il contient {folders} dossier(s).

$66107456188362* Il contient {folders} dossier(s) et {asm} fichier(s) .asm.

$86093358515620* C'est un dossier vide.

$93027749509988* Il contient {asm} fichier(s) .asm.



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

$84832818424728* Fichier



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

$12944436882589* Ajouter des registres



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

$10141348037745* Immédiate : {nr}

$10366913897135* Clique pour inverser les bits

$14831276667273* Instructions


# The text above the 3 LSBs
$25145891843959* Toujours

$26521666422399* Calculer

$31185395052385* SORTIE


# The text above the 3 LSBs
$38497477227061* Quand [color=#e49f44] le résultat {condition} 0[/color]


# The text above the 3 LSBs
$39935096343723* Jamais

$41846451178700* déplacer vers {to} depuis {from}

$43723329256095* REG {nr}

$53665446068319* INUTILISE

$54909668901048* Valeur immédiate


# The text below the byte
$59958585065722* Lorsque [color=#e49f44]le résultat {condition} 0[/color], déplace [color=#DD6576][bold]REG 0[/bold][/color] vers le compteur

$67413863640193* Ne déplace jamais [color=#DD6576][bold]REG 0[/bold][/color] vers le compteur.

$81322935207536* ENTRÉE

$89294533225655* {operation} [color=#DD6576][bold]REG 1[/bold][/color] et [color=#DD6576][bold]REG 2[/bold][/color]

$89662716409733* Déplace toujours [color=#DD6576][bold]REG 0[/bold][/color] vers le compteur.

$92046368194170* Condition

$98983752580592* Copier



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

$14436541903929* Architectures: {list}

$17985924005596* Contient {nr} schémas.

$38011567415872* Le dossier est vide.

$51791491383290* Le composant personalisé est utilisé dans

$57790786178566* Composants personalisés : {list}

$66392158413243* Es tu sûr de vouloir supprimer "{file_name}" ?

$68586106474430* Note: Toutes les architectures de niveaux partagent les mêmes sauvegardes, donc celles-ci seront supprimées pour tous les niveaux !

$89354977462546* Non



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

$15827374884671* Vers le dossier parent

$19184997172542* Utilisé dans les architectures

$23950941073542* Nom

$32598300339944* <Partager comme nouveau schéma>

$32645745463577* Utilisé dans les composants

$34084132835354* Visible dans le menu

$36200352866864* Modifié

$38755675398147* Utiliser WOR 

$54460367152653* Partager

$62604042376934* Exporter

$74184088067843* Sélectionner

$84344684205464* Chemin

$87138477300432* BBCode, avec [image] et [link] désactivé

$87579936985765* D'accord pour utiliser [link=`CC0`]CC0[/link] license

$95386916091656* Description



=== presenter/board_ui/popup/static_value_editor.nim ===

$54982025748137* Déduire la taille à partir de l'entrée

$61685569269160* Automatique

$70256730895162* Valeur statique



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

$36027984716180* commentaire de fils



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

$11176073682097* Combien fait {number} en binaire ?

$13872783467999* Écris {number} en binaire signé.

$19099025738142* Démarrer

$23959994711260* Prêt pour la course ?

$37093663674348* Niveau {x}

$41793938939207* Temps écoulé

$45532697833519* Niveau {level} atteint !

$56999237564848* {x} secondes restantes

$92057009138253* Comment écrire {number} en binaire ?



=== presenter/console.nim ===

$63321577947087* Appuie sur Entrée pour voir le manuel



=== presenter/level_tree_ui.nim ===

$19508086025944* PROGRAMMATION 2

$26276191141664* Déplacer la vue à l'aide du clavier

$35696974632265* Couleurs de la carte des niveaux

$38100016313511* ARCHITECTURE PROCESSEUR 2

$38843517090942* ORDINATEUR FONCTIONNEL

$44937904689376* PROGRAMMATION

$51337598329530* ARITHMÉTIQUE

$55841332003989* Réduire les délais pour passé !

$65362728703588* MÉMOIRE

$75049509201775* LOGIQUE BOOLÉENNE

$81337533438394* Complet

$81707212583931* Disponible

$87420015169370* NIVEAUX DE COMPOSANTS OPTIONNELS

$95146987030704* Verrouillé

$95559333192525* ARCHITECTURE PROCESSEUR



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

$15872341864658*

Remerciements sincères à:

[b]Traduction[/b]
{translators}

[b]Beta-test[/b]
{beta_testers}

[b]Polices de caractère[/b]
{font_work}

[b]Bande son[/b]
{soundtrack}

$21717110565858* Crédits



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

$12639868461113* Quitter

$13921098180953* Bibliothèque de schémas

$15234594767991* Crédits

$16857608955464* Bac à sable

$32835651830157* Profil

$49251062339706* Options

$66967233942803* Campagne



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


# The hub schematic size
$15762392983604* Taille :

$22639280459994* Téléchargement de la liste...

$44524092309946* Chargement en cours...


# To download hub schematics
$55983490912314* charger

$61693098943939* Continue


# To delete hub schematics
$62589392744014* Supprimer


# To confirm deleting hub schematics
$66333328482057* Es-tu sûr?


# The hub author
$71812400203030* par:

$76747661573536* Oui

$76770986264566* Recherche

$84668607423763* Le téléchargement nécessite la désactivation de la limite de longueur du chemin sous Windows. Cliquer sur Continuer affichera une fenêtre contextuelle te demandant de confirmer la désactivation. Les limites de chemin d'accès sont un paramètre hérité de Windows et il n'y a aucune raison de les activer.

$90731554079332* Aucun schéma trouvé



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

$23829497228009* Type

$25536941657464* Composants

$43488408276984* Populaire

$56045953383535* Architectures

$70134513915163* Ajouts récents

$77788981567936* Niveaux

$83319579232915* Trié par

$87115430626073* Mes contributions



=== presenter/main_menu_ui/options/control_tab.nim ===

$13231048881956* Reset cycle

$15032124477918* Couleur de fil 4

$20313704155593* Couleur de fil 6

$21380256293472* Sélectionner tout

$33884219481037* Déplacer la vue vers la droite

$36372993787575* Couleur de fil 1

$50610605761210* Refaire

$52159578521318* Volume de la Musique

$53266310714298* Contrôles

$55156524671891* Couleur de fil 5

$58334563411624* Annuler

$58442122157391* Changer la couleur d'un fil

$60118970740682* Démarrer la simulation

$64529333110609* Couleur de fil 7

$66251711975517* Couleur de fil 9

$67362258372706* Changer la couleur d'un groupe de fils

$74309706297402* Copier

$76995246992803* Couleur de fil 10

$77819900580235* Couleur de fil 2

$78515694621006* Déplacer la vue vers la gauche

$78673220868687* Couleur de fil 8

$78777350869870* Press new key

$80031998727851* Déplacer la vue vers le haut

$83373647697807* Couleur de fil 3

$86574817679356* Prochain cycle

$87273391208106* Couleur de fil 0

$88236351843942* Rotation

$88238310953306* Couper

$93140495547084* Déplacer la vue vers le bas

$96339976117958* Pipette à fil

$96449970906640* Commentaire de fil

$96601731563408* Ouvrir le terminal



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

$12034378482152* Es-tu sûr ?

$13442839894535* Vitesse d'animation des fils

$15557473522933* Réinitialiser

$21908594290225* Général

$23270083417453* Annuler

$24145565754506* Volume des Effets

$29594613477534* Tu dois redémarrer le jeu pour que le changement de langue s'applique.

$30910326565868* Langue

$49806848871093* Daltonisme

$54328660964287* Mode fenêtré

$55047615798435* Mode d'accessibilité

$61172959716558* Emplacement de Sauvegarde

$67420270098223* Remise à zéro

$70994568832660* Continuer

$71208664264770*

Cette action va supprimer toute ta progression, tous tes composants personnalisés et toutes tes architectures.
Cette opération NE peut PAS être annulée.
Es-tu sûr de vouloir tout supprimer ?

Après avoir confirmé, le jeu va se fermer.
Une fois relancé tout aura été remis à zéro

$93981778736076* Volume de la Musique

$95307230990123* Mode Verilog



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

$36195388998735* Général



=== presenter/markup/markup.nim ===

$66207112287034* ASTUCE



=== presenter/update_state_common.nim ===

$13327741293223* Entrée {nr}

$29169064199243* Sortie {nr}

$39906291838542* Cycle

$43118901497406* Délai

$70170261551278* Énergie

$95192766583497* Portes



=== presenter/update_state_stream.nim ===

$12823129240050* Clique sur le bouton en haut à gauche pour lier l'écran


# Text on keyboard component
$41639816417947* Activé quand simulé


# Text on keyboard component
$61909856780806* Activé


# Text on keyboard component
$73297471730751* Désactivé



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

$10186190492148* Clique + ALT pour déplacer la tête de fil

$22780831606716* Charger un fichier

$26085882338208* Modifier la carte perforée

$38481453712356* Éditer la mémoire

$64854367750357* Ouvrir l'éditeur hexadécimal

$80005228759908* Valeur ici: 

$98772447663910* Éditer les points d'observation



=== presenter/utilities.nim ===


# Switched Output is the name under 19513138880387
$12249248261034* Pour résoudre ce niveau tu dois utiliser le composant 'Sortie commuté'

$12256736989028* Tu as plus d'une sonde sur le même carré.

$14665712485657* Ce composant personnalisé ne peut pas être utilisé car il n'a aucune surface.

$15549447390000* 2 composants d'entrée/sortie sont dans la même zone. Le composant personnalisé sera inutilisable car 2 connecteurs ne peuvent se chevaucher.

$18997072674417* <Ce composant> n'est pas débloqué à ce niveau.

$25337574230078* Deux connecteurs sont sur le même carré.

$27322222841583* Court circuit entre <> et <>

$29718660090112* Mauvaise réponse

$32087108522443* Les connecteurs de taille peuvent uniquement être connectés à d'autres connecteurs de taille.

$42649958199625* La carte des niveaux a été mise à jour et ta progression est désynchronisée. Termine ce niveau <level> pour corriger le problème.

$44947135063289* Dépendance circulaire – La sortie d'un composant renvoie à sa propre entrée.

$45545544521085* un <composant> se trouve dans une position invalide.

$45678915971282* Court circuit dans <ce composant personnalisé>.

$47880883686501* Dépendance circulaire - Un composant dépend de sa propre entrée. Voir 'Dépendance circulaire' dans le manuel.

$48909199348313* Les tests ont réussi, mais ta solution utilise un délai(retard) supérieur à {max_delay}.

$51332486391182* Le chemin critique se trouve à l'intérieur de ce <composant personnalisé>.

$51730362111148* <Ce composant personnalisé>  utilise un composant {name} non déverrouillé à ce niveau.

$56798729463813* Code de validation du niveau incorrect.

$73948669941805* Les tests ont réussi, mais ta solution utilise plus de {max_gates} portes


# Switched Input is the name under 11278573510238
$95056157627313* Pour résoudre ce niveau tu dois utiliser le composant 'Entrée commuté'



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


# Fallback for component name on the left panel
$11467644007149* Compteur {nr}


# Fallback for component name on the left panel
$11980538317261* Mémoire


# Fallback for component name on the left panel
$19471584538385* Entrée

$25272818268849*

[b]RÉCAP[/b]

Normalement tu as dû remarquer que:
1. Il existe une seule manière d'écrire chaque nombre en binaire.
2. La valeur de chaque chiffre est toujours le double du chiffre précédent.

$37319690622142* Très bien, tu as atteint le niveau {current_level}.


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


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


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

$87016829502381* Très bien, tu as atteint le niveau {current_level}.


# Fallback for component name on the left panel
$87591753278764* Reg {nr}

$97450409600317*

[b]POINTS CLÉS[/b]

1. Pour passer de négatif à positif, on inverse tous les bits et on ajoute[nbsp]1.
2. Si le bit le plus élevé est [T], la valeur est toujours négative.
3. L'additionneur d'octet que tu as construit fonctionne aussi avec les nombres signés.
4. Il n'y a toujours qu'une seule manière d'écrire un nombre en binaire.


# Fallback for component name on the left panel
$97889215332379* Mémoire {nr} 

