diff --git a/base_1.md b/base_1.md
index 4200e4dfb33f311fe2f5bd00c559f32dc67c6d0e..d0afd6a14d8485cec787b39ef377ec7a33d3e764 100644
--- a/base_1.md
+++ b/base_1.md
@@ -106,7 +106,7 @@ int a, b, c; // déclarations multiples
 int d = e = f = 1; // décl./init. multiples
 ```
 
-# Types de base (1/N)
+# Types de base (1/4)
 
 ## Numériques
 
@@ -122,7 +122,7 @@ Type                               Signification (**gcc pour x86-64**)
 
 **La signification de `short`{.C}, `int`{.C}, ... dépend du compilateur et de l'architecture.**
 
-# Types de base (2/N)
+# Types de base (2/4)
 
 Voir `<stdint.h>` pour des représentations **portables**
 
@@ -134,7 +134,7 @@ Type                               Signification
 `int64_t`{.C}, `uint64_t`{.C}      Entier signé/non-signé 64-bit
 ---------------------------------- ---------------------------------------------
 
-# Types de base (3/N)
+# Types de base (3/4)
 
 ## Booléens
 
@@ -167,7 +167,7 @@ bool x = true;
 if (x) { /* vrai */ }
 ``` -->
 
-# Types de base (4/N)
+# Types de base (4/4)
 
 ## Conversions
 
@@ -199,7 +199,7 @@ bool d = 2.78; // 0
 bool e = 1.0; // 1
 ``` -->
 
-# Expressions et opérateurs (1/N)
+# Expressions et opérateurs (1/6)
 
 Une expression est tout bout de code qui est **évalué**.
 
@@ -225,7 +225,7 @@ x = 4 + 5; // 4 + 5 est une expression
            // dont le résultat est affecté à 'x'
 ```
 
-# Expressions et opérateurs (1/N)
+# Expressions et opérateurs (2/6)
 
 ## Opérateurs relationnels
 
@@ -242,7 +242,7 @@ Opérateurs testant la relation entre deux *expressions*:
 | `==`{.C}  | `a == b`{.C} | 1 si a == b; 0 sinon |
 | `!=`{.C}  | `a != b`{.C} | 1 si a != b; 0 sinon |
 
-# Expressions et opérateurs (2/N)
+# Expressions et opérateurs (3/6)
 
 ## Opérateurs logiques
 
@@ -264,7 +264,7 @@ Soit n un unsigned char initialisé à 127:
 !n == 0
 ``` -->
 
-# Expressions et opérateurs (3/N)
+# Expressions et opérateurs (4/6)
 
 ## Opérateurs arithmétiques
 
@@ -276,7 +276,7 @@ Soit n un unsigned char initialisé à 127:
 | `/`{.C}   | `a / b`{.C}  | Division             |
 | `%`{.C}   | `a % b`{.C}  | Modulo               |
 
-# Expressions et opérateurs (4/N)
+# Expressions et opérateurs (5/6)
 
 ## Opérateurs d'assignation
 
@@ -295,7 +295,7 @@ Soit n un unsigned char initialisé à 127:
 | `%=`{.C}  | `a %= b`{.C} | Calcule le modulo la valeur de `b` à `a` et |
 |           |              | assigne le résultat à `a`.                  |
 
-# Expressions et opérateurs (5/N)
+# Expressions et opérateurs (6/6)
 
 ## Opérateurs d'assignation (suite)
 
@@ -309,7 +309,7 @@ Soit n un unsigned char initialisé à 127:
 | `--`{.C}  | `--a`{.C}    | Retourne `a`{.C} et décrémente `a` de 1.    |
 
 
-# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/N)
+# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)
 
 ## Syntaxe
 
@@ -334,7 +334,7 @@ if (x) { // si x s'évalue à `vrai`
 }
 ```
 
-# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/N)
+# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)
 
 ## Pièges
 
@@ -351,7 +351,7 @@ else
     x = -1; // toujours évalué
 ```
 
-# Structures de contrôle: `switch`{.C} .. `case`{.C} (1/N)
+# Structures de contrôle: `switch`{.C} .. `case`{.C} (1/2)
 
 ```C
 switch (expression) {
@@ -369,7 +369,7 @@ switch (expression) {
 
 **Que se passe-t-il si `break`{C} est absent?**
 
-# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/N)
+# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/2)
 
 ```C
 int x = 0;
@@ -388,7 +388,7 @@ switch (x) {
 
 **Dangereux, mais c'est un moyen d'avoir un "ou" logique dans un case.**
 
-# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (1/N)
+# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (1/4)
 
 ## La boucle `for`{.C}
 
@@ -414,7 +414,7 @@ do {
 } while (expression);
 ```
 
-# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (2/N)
+# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (2/4)
 
 ## La boucle `for`{.C}
 
@@ -429,7 +429,7 @@ for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
 }
 ```
 
-# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (3/N)
+# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (3/4)
 
 ## La boucle `while`{.C}
 
@@ -451,7 +451,7 @@ do { // assuré·e·s de faire un tour
 } while (i < 10);
 ```
 
-# Structures de contrôle: `continue`{.C}, `break`{.C} (4/N)
+# Structures de contrôle: `continue`{.C}, `break`{.C} (4/4)
 
 - `continue`{.C} saute à la prochaine itération d'une boucle.
 
@@ -477,7 +477,7 @@ do { // assuré·e·s de faire un tour
     }
     ```
 
-# Les variables (1/N)
+# Les variables (1/2)
 
 ## Variables et portée
 
@@ -488,7 +488,7 @@ do { // assuré·e·s de faire un tour
 - Une variable est **locale** lorsqu'elle est déclarée dans un **bloc**, `{...}`{.C}.
 - Une variable est dans la portée **après** avoir été déclarée.
 
-# Les variables (2/N)
+# Les variables (2/2)
 
 ## Exemple 
 
@@ -551,7 +551,7 @@ int main() {
 } // COMPILE
 ``` -->
 
-# Entrées/sorties: `printf()`{.C} (1/N)
+# Entrées/sorties: `printf()`{.C} (1/2)
 
 ## Généralités
 
@@ -564,7 +564,7 @@ int main() {
 - `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
 - Les arguments suivants sont les expressions à afficher.
 
-# Entrées/sorties: `printf()`{.C} (2/N)
+# Entrées/sorties: `printf()`{.C} (2/2)
 
 ## Exemple
 
@@ -581,7 +581,7 @@ int main() {
 }
 ```
 
-# Entrées/sorties: `scanf()`{.C} (1/N)
+# Entrées/sorties: `scanf()`{.C} (1/2)
 
 ## Généralités
 
@@ -594,7 +594,7 @@ int main() {
 - `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
 - Les arguments suivants sont les variables où sont stockées les valeurs lues.
 
-# Entrées/sorties: `scanf()`{.C} (2/N)
+# Entrées/sorties: `scanf()`{.C} (2/2)
 
 ## Exemple