Update README.org

test 20250907

README.org

@@ -89,6 +89,7 @@ Total time elapsed: 0.01099 secs, nodes/leaves evaluated:401,817/397,973
 Numérotation:
 
 1) ce sera 1
+2) ce sera 2
 
 ```
 code

TODO.org

@@ -1,4 +1,77 @@
+#+title: brlib - A small personal C library
 #+OPTIONS: toc:nil
+#+OPTIONS: num:2
+#+startup: num
+
+* brlib - A small personal C library
+** License
+~SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>~
+
+This work is, with exceptions below, Copyright (C) 2021-2024 Bruno Raoult
+("br"), and licensed under the GNU General Public License v3.0 or later.
+Some rights reserved. See COPYING.
+
+*The licence exceptions are:**
+_Cutest testing framework.__
+You can find the original work on
+[[https://sourceforge.net/projects/cutest/files/cutest/][sourceforge]].
+
+This software is (C) 2000-2003 Asim Jalis, under the zlib License.
+See [[test/cutest/license.txt][license local copy]] or
+<https://spdx.org/licenses/Zlib.html>.
+
+** Installation:
+*** user...
+#+BEGIN_EXAMPLE
+$ git clone https://git.raoult.com:bruno/brlib.git
+or
+$ git clone https://github.com/braoult/brlib.git
+#+END_EXAMPLE
+
+*** ...or developer
+#+BEGIN_EXAMPLE
+$ git clone git@git.raoult.com:bruno/brlib.git
+$ cd brlib
+$ git remote add github git@github.com:braoult/brlib.git
+#+END_EXAMPLE
+#+OPTIONS: toc:3
+
+* brlib - A small personal C library
+** License
+SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
+
+This work is, with exceptions below, Copyright (C) 2021-2024 Bruno Raoult
+("br"), and licensed under the GNU General Public License v3.0 or later.
+Some rights reserved. See COPYING.
+
+*** The licence exceptions are:
+**** Cutest testing framework.
+You can find the original work on
+[[https://sourceforge.net/projects/cutest/files/cutest/][sourceforge]].
+
+This software is (C) 2000-2003 Asim Jalis, under the zlib License.
+See [[test/cutest/license.txt][license local copy]] or
+<https://spdx.org/licenses/Zlib.html>.
+
+** Installation:
+*** clone repository
+**** user...
+#+BEGIN_EXAMPLE
+$ git clone https://git.raoult.com:bruno/brlib.git
+#+END_EXAMPLE
+or
+#+BEGIN_EXAMPLE
+$ git clone https://github.com/braoult/brlib.git
+#+END_EXAMPLE
+
+**** ... or developer
+#+BEGIN_EXAMPLE
+$ git clone git@git.raoult.com:bruno/brlib.git
+$ cd brlib
+$ git remote add github git@github.com:braoult/brlib.git
+#+END_EXAMPLE
+
+
 
 * NFSv4 with Kerberos on Debian from scratch
 #+BEGIN_QUOTE
@@ -57,3 +130,29 @@ not so easy: need to keep track of allocated blocks, **and** to understand that
 - ~move_gen()~: ~doit~ is maybe redundant with test on current turn.
 - should board be included in position ?
 - Whill +this text+ be strikethrough ?
+
+* A small personal C library
+** License
+SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
+
+This work is, with exceptions below, Copyright (C) 2021-2024 Bruno Raoult ("br"), and licensed under the GNU General Public License v3.0 or later.
+Some rights reserved. See COPYING.
+
+*** The licence exceptions are:
+**** [[https://sourceforge.net/projects/cutest/files/cutest/][CuTest]]
+This work is (C) 2000-2003 Asim Jalis, under the zlib License.
+See the [[test/cutest/license.txt][license file]].
+
+** Installation:
+*** clone repository
+**** user...
+#+BEGIN_EXAMPLE
+$ git clone https://git.raoult.com:bruno/brlib.git
+#+END_EXAMPLE
+or
+~git clone https://git.raoult.com:bruno/brlib.git~
+
+**** ... or developer
+$ git clone https@git.raoult.com:bruno/brlib.git
+$ cd brlib
+$ git remote add github git@github.com:braoult/brlib.git

chatGPT-c-est-pas-gagné.md

@@ -0,0 +1,674 @@
+### You
+Essaie de résoudre le problème suivant en bash:
+
+You climb the hill and again try contacting the Elves. However, you instead receive a signal you weren't expecting: a distress signal.
+
+Your handheld device must still not be working properly; the packets from the distress signal got decoded out of order. You'll need to re-order the list of received packets (your puzzle input) to decode the message.
+
+Your list consists of pairs of packets; pairs are separated by a blank line. You need to identify how many pairs of packets are in the right order.
+
+For example:
+```
+[1,1,3,1,1]
+[1,1,5,1,1]
+
+[[1],[2,3,4]]
+[[1],4]
+
+[9]
+[[8,7,6]]
+
+[[4,4],4,4]
+[[4,4],4,4,4]
+
+[7,7,7,7]
+[7,7,7]
+
+[]
+[3]
+
+[[[]]]
+[[]]
+
+[1,[2,[3,[4,[5,6,7]]]],8,9]
+[1,[2,[3,[4,[5,6,0]]]],8,9]
+```
+Packet data consists of lists and integers. Each list starts with [, ends with ], and contains zero or more comma-separated values (either integers or other lists). Each packet is always a list and appears on its own line.
+
+When comparing two values, the first value is called left and the second value is called right. Then:
+
+  If both values are integers, the lower integer should come first. If the left integer is lower than the right integer, the inputs are in the right order. If the left integer is higher than the right integer, the inputs are not in the right order. Otherwise, the inputs are the same integer; continue checking the next part of the input.
+  If both values are lists, compare the first value of each list, then the second value, and so on. If the left list runs out of items first, the inputs are in the right order. If the right list runs out of items first, the inputs are not in the right order. If the lists are the same length and no comparison makes a decision about the order, continue checking the next part of the input.
+  If exactly one value is an integer, convert the integer to a list which contains that integer as its only value, then retry the comparison. For example, if comparing [0,0,0] and 2, convert the right value to [2] (a list containing 2); the result is then found by instead comparing [0,0,0] and [2].
+
+Using these rules, you can determine which of the pairs in the example are in the right order:
+
+== Pair 1 ==
+- Compare [1,1,3,1,1] vs [1,1,5,1,1]
+  - Compare 1 vs 1
+  - Compare 1 vs 1
+  - Compare 3 vs 5
+    - Left side is smaller, so inputs are in the right order
+
+== Pair 2 ==
+- Compare [[1],[2,3,4]] vs [[1],4]
+  - Compare [1] vs [1]
+    - Compare 1 vs 1
+  - Compare [2,3,4] vs 4
+    - Mixed types; convert right to [4] and retry comparison
+    - Compare [2,3,4] vs [4]
+      - Compare 2 vs 4
+        - Left side is smaller, so inputs are in the right order
+
+== Pair 3 ==
+- Compare [9] vs [[8,7,6]]
+  - Compare 9 vs [8,7,6]
+    - Mixed types; convert left to [9] and retry comparison
+    - Compare [9] vs [8,7,6]
+      - Compare 9 vs 8
+        - Right side is smaller, so inputs are not in the right order
+
+== Pair 4 ==
+- Compare [[4,4],4,4] vs [[4,4],4,4,4]
+  - Compare [4,4] vs [4,4]
+    - Compare 4 vs 4
+    - Compare 4 vs 4
+  - Compare 4 vs 4
+  - Compare 4 vs 4
+  - Left side ran out of items, so inputs are in the right order
+
+== Pair 5 ==
+- Compare [7,7,7,7] vs [7,7,7]
+  - Compare 7 vs 7
+  - Compare 7 vs 7
+  - Compare 7 vs 7
+  - Right side ran out of items, so inputs are not in the right order
+
+== Pair 6 ==
+- Compare [] vs [3]
+  - Left side ran out of items, so inputs are in the right order
+
+== Pair 7 ==
+- Compare [[[]]] vs [[]]
+  - Compare [[]] vs []
+    - Right side ran out of items, so inputs are not in the right order
+
+== Pair 8 ==
+- Compare [1,[2,[3,[4,[5,6,7]]]],8,9] vs [1,[2,[3,[4,[5,6,0]]]],8,9]
+  - Compare 1 vs 1
+  - Compare [2,[3,[4,[5,6,7]]]] vs [2,[3,[4,[5,6,0]]]]
+    - Compare 2 vs 2
+    - Compare [3,[4,[5,6,7]]] vs [3,[4,[5,6,0]]]
+      - Compare 3 vs 3
+      - Compare [4,[5,6,7]] vs [4,[5,6,0]]
+        - Compare 4 vs 4
+        - Compare [5,6,7] vs [5,6,0]
+          - Compare 5 vs 5
+          - Compare 6 vs 6
+          - Compare 7 vs 0
+            - Right side is smaller, so inputs are not in the right order
+
+What are the indices of the pairs that are already in the right order? (The first pair has index 1, the second pair has index 2, and so on.) In the above example, the pairs in the right order are 1, 2, 4, and 6; the sum of these indices is 13.
+
+Determine which pairs of packets are already in the right order. What is the sum of the indices of those pairs?
+
+### ChatGPT
+
+Voici un script bash qui résout ce problème :
+
+```bash
+#!/bin/bash
+
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+}
+
+# Lire l'input et stocker chaque ligne dans un tableau
+readarray -t lines
+
+# Initialiser le compteur de paires en ordre à 0
+count=0
+
+# Pour chaque paire d'éléments du tableau
+for ((i=0; i<${#lines[@]}; i+=2)); do
+  # Comparer les deux éléments de la paire
+  result=$(compare "${lines[i]}" "${lines[i+1]}")
+  # Si les éléments sont dans l'ordre, incrémenter le compteur
+  if [ "$result" == "left" ]; then
+    count=$((count+1))
+  fi
+done
+
+# Afficher le résultat
+echo "$count"
+
+```
+
+Ce script utilise la fonction compare pour comparer deux éléments en utilisant les règles spécifiées dans l'énoncé. La fonction retourne "left" si l'élément de gauche est inférieur à l'élément de droite, "right" si l'élément de gauche est supérieur à l'élément de droite, et "equal" si les deux éléments sont égaux.
+
+Le script lit l
+
+### You
+la réponse a été tronquée. D'autre part, le programme semble boucler indéfiniment avec l'exemple donné.
+
+### ChatGPT
+
+Je suis désolé pour le problème rencontré. Voici la réponse complète :
+
+```bash
+#!/bin/bash
+
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+}
+
+# Lire l'input et stocker chaque ligne dans un tableau
+readarray -t lines
+
+# Initialiser le compteur de paires en ordre à 0
+count=0
+
+# Pour chaque paire d'éléments du tableau
+for ((i=0; i<${#lines[@]}; i+=2)); do
+  # Comparer les deux éléments de la paire
+  result=$(compare "${lines[i]}" "${lines[i+1]}")
+  # Si les éléments sont dans l'ordre, incrémenter le compteur
+  if [ "$result" == "left" ]; then
+    count=$((count+1))
+  fi
+done
+
+# Afficher le résultat
+echo "$count"
+
+```
+
+Je suis désolé pour l'erreur de boucle infinie. Pour résoudre ce problème, il faut ajouter un return à la fin de la fonction compare afin de sortir de la fonction lorsque l'on a trouvé une comparaison égale. Voici la version corrigée de la fonction :
+
+```python
+# Fonction de comparaison de deux éléments
+compare
+
+```
+
+### You
+je n'ai pas reçu la version corrigée
+
+### ChatGPT
+
+Je suis désolé pour ce problème. Voici la version corrigée de la fonction compare :
+
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+
+```
+
+Je vous prie de m'excuser pour cet oubli et j'espère que cette version corrigée vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+ajouter "return" à la fin d'une fonction bash ne change rien. Le problème est toujours là.
+
+### ChatGPT
+
+Je suis désolé pour cet autre problème. En effet, ajouter return à la fin d'une fonction en bash ne change pas son comportement et ne peut pas résoudre le problème de boucle infinie.
+
+Le problème vient en réalité du fait que la fonction compare n'a pas de cas de sortie pour les comparaisons égales. Lorsque la fonction compare deux éléments qui sont égaux, elle retourne "equal", mais elle ne fait rien de plus et ne sort pas de la fonction. Cela entraîne une boucle infinie lorsque la fonction est appelée avec deux éléments égaux.
+
+Pour résoudre ce problème, il faut ajouter un return à la fin de la fonction lorsque la comparaison est égale :
+
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[
+
+```
+
+Je suis désolé pour le problème de formatage de la réponse précédente. Voici la version corrigée de la fonction compare 
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+
+
+### You
+
+Il s'agit de la mẽme version que la dernière, avec "return" ajouté à la fin de la fonction, ce qui n'a aucun effet.
+
+### ChatGPT
+Je suis désolé pour cette erreur. En effet, ajouter return à la fin de la fonction compare ne résoud pas le problème de boucle infinie.Pour résoudre ce problème, il faut ajouter un cas de sortie lorsque la comparaison est égale, comme ceci 
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+Je suis désolé pour cette erreur et j'espère que cette version corrigée vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+
+La fonction compare() est toujours appelée sans fin. Peut-être que la détection des terminaison des sous-listes n'est pas correcte ?
+
+### ChatGPT
+Vous avez raison, il y a un autre problème dans la fonction compare. En effet, lorsque la fonction compare deux listes, elle ne vérifie pas si l'une des listes est plus longue que l'autre. Si une liste est plus longue, la fonction continue à comparer les éléments suivants, ce qui entraîne une boucle infinie.Pour résoudre ce problème, il faut ajouter une vérification de la longueur des listes avant de comparer leurs éléments
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+
+Je suis désolé pour ces erreurs et j'espère que cette version corrigée de la fonction compare vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+
+ça boucle toujours. Je me demande si les terminaisons des sous-listes ("]") sont bien gérées par la fonction compare(). 
+
+### ChatGPT
+Vous avez raison, il y a encore un autre problème dans la fonction compare. En effet, la fonction ne gère pas correctement les terminaisons de sous-listes ("]"). Lorsqu'elle compare deux sous-listes, elle ne vérifie pas si l'une des sous-listes est terminée avant de continuer à comparer les éléments suivants. Si une sous-liste est terminée alors que l'autre est plus longue, la fonction continue à comparer les éléments suivants, ce qui entraîne une boucle infinie.Pour résoudre ce problème, il faut ajouter une vérification de la terminaison des sous-listes avant de comparer leurs éléments
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      if [[ "${left[i]}" == *"]"* ]] || [[ "${right[i]}" == *"]"* ]]; then
+        result=$(compare "${left[i]}" "${right[i]}")
+        if [ "$result" == "left" ]; then
+          echo "left"
+          return
+       
+```
+
+### You
+
+le code a été tronqué
+
+### ChatGPT
+Je suis désolé pour cette erreur. Voici le code complet de la fonction compare corrigée :
+
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      if [[ "${left[i]}" == *"]"* ]] || [[ "${right[i]}" == *"]"* ]]; then
+        result=$(compare "${left[i]}" "${right[i]}")
+        if [ "$result" == "left" ]; then
+          echo "left"
+          return
+        elif [ "$result" == "right" ]; then
+          echo "right"
+          return
+        fi
+      else
+        result=$(compare "${left[i]}" "${right[i]}")
+        if [ "$result" == "left" ]; then
+          echo "left"
+          return
+        elif [ "$result" == "right" ]; then
+          echo "right"
+          return
+        elif [ "$result" == "equal" ]; then
+          continue
+        fi
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+Je suis désolé pour ces erreurs et j'espère que cette version corrigée de la fonction compare vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+ça boucle toujours. Peut-être faudrait-t'il s'assurer que les deux "read" s'arrêtent à la fin de la liste concernée ?
+
+### ChatGPT
+Vous avez raison, il y a encore un problème dans la fonction compare. En effet, lorsque la fonction compare deux listes, elle utilise `IFS=',' read -a left <<< "$1"` et `IFS=',' read -a right <<< "$2"` pour les découper en tableaux left et right. Cependant, cette syntaxe ne s'arrête pas à la fin de la liste et inclut tous les caractères suivants jusqu'à la fin de la ligne. Si la liste contient des crochets fermants, cela peut entraîner des erreurs de découpage et des comparaisons incorrectes.
+
+Pour résoudre ce problème, il faut utiliser une expression régulière pour découper les listes en tableaux :
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    left=$(sed 's/^\[//;s/\]$//' <<< "$1")
+    right=$(sed 's/^\[//;s/\]$//' <<< "$2")
+    IFS=',' read -a left <<< "$left"
+    IFS=',' read -a right <<< "$right"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      result=$(compare "${
+```
+
+### You
+la réponse a été tronquée
+
+### ChatGPT
+Je suis désolé pour cette erreur. Voici la fonction `compare` complète :
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    left=$(sed 's/^\[//;s/\]$//' <<< "$1")
+    right=$(sed 's/^\[//;s/\]$//' <<< "$2")
+    IFS=',' read -a left <<< "$left"
+    IFS=',' read -a right <<< "$right"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+Je suis désolé pour cette erreur et j'espère que cette version corrigée de la fonction `compare` vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.

chatGPT-c-est-pas-gagné.md.backup

@@ -0,0 +1,673 @@
+### You
+Essaie de résoudre le problème suivant en bash:
+
+You climb the hill and again try contacting the Elves. However, you instead receive a signal you weren't expecting: a distress signal.
+
+Your handheld device must still not be working properly; the packets from the distress signal got decoded out of order. You'll need to re-order the list of received packets (your puzzle input) to decode the message.
+
+Your list consists of pairs of packets; pairs are separated by a blank line. You need to identify how many pairs of packets are in the right order.
+
+For example:
+```
+[1,1,3,1,1]
+[1,1,5,1,1]
+
+[[1],[2,3,4]]
+[[1],4]
+
+[9]
+[[8,7,6]]
+
+[[4,4],4,4]
+[[4,4],4,4,4]
+
+[7,7,7,7]
+[7,7,7]
+
+[]
+[3]
+
+[[[]]]
+[[]]
+
+[1,[2,[3,[4,[5,6,7]]]],8,9]
+[1,[2,[3,[4,[5,6,0]]]],8,9]
+```
+Packet data consists of lists and integers. Each list starts with [, ends with ], and contains zero or more comma-separated values (either integers or other lists). Each packet is always a list and appears on its own line.
+
+When comparing two values, the first value is called left and the second value is called right. Then:
+
+  If both values are integers, the lower integer should come first. If the left integer is lower than the right integer, the inputs are in the right order. If the left integer is higher than the right integer, the inputs are not in the right order. Otherwise, the inputs are the same integer; continue checking the next part of the input.
+  If both values are lists, compare the first value of each list, then the second value, and so on. If the left list runs out of items first, the inputs are in the right order. If the right list runs out of items first, the inputs are not in the right order. If the lists are the same length and no comparison makes a decision about the order, continue checking the next part of the input.
+  If exactly one value is an integer, convert the integer to a list which contains that integer as its only value, then retry the comparison. For example, if comparing [0,0,0] and 2, convert the right value to [2] (a list containing 2); the result is then found by instead comparing [0,0,0] and [2].
+
+Using these rules, you can determine which of the pairs in the example are in the right order:
+
+== Pair 1 ==
+- Compare [1,1,3,1,1] vs [1,1,5,1,1]
+  - Compare 1 vs 1
+  - Compare 1 vs 1
+  - Compare 3 vs 5
+    - Left side is smaller, so inputs are in the right order
+
+== Pair 2 ==
+- Compare [[1],[2,3,4]] vs [[1],4]
+  - Compare [1] vs [1]
+    - Compare 1 vs 1
+  - Compare [2,3,4] vs 4
+    - Mixed types; convert right to [4] and retry comparison
+    - Compare [2,3,4] vs [4]
+      - Compare 2 vs 4
+        - Left side is smaller, so inputs are in the right order
+
+== Pair 3 ==
+- Compare [9] vs [[8,7,6]]
+  - Compare 9 vs [8,7,6]
+    - Mixed types; convert left to [9] and retry comparison
+    - Compare [9] vs [8,7,6]
+      - Compare 9 vs 8
+        - Right side is smaller, so inputs are not in the right order
+
+== Pair 4 ==
+- Compare [[4,4],4,4] vs [[4,4],4,4,4]
+  - Compare [4,4] vs [4,4]
+    - Compare 4 vs 4
+    - Compare 4 vs 4
+  - Compare 4 vs 4
+  - Compare 4 vs 4
+  - Left side ran out of items, so inputs are in the right order
+
+== Pair 5 ==
+- Compare [7,7,7,7] vs [7,7,7]
+  - Compare 7 vs 7
+  - Compare 7 vs 7
+  - Compare 7 vs 7
+  - Right side ran out of items, so inputs are not in the right order
+
+== Pair 6 ==
+- Compare [] vs [3]
+  - Left side ran out of items, so inputs are in the right order
+
+== Pair 7 ==
+- Compare [[[]]] vs [[]]
+  - Compare [[]] vs []
+    - Right side ran out of items, so inputs are not in the right order
+
+== Pair 8 ==
+- Compare [1,[2,[3,[4,[5,6,7]]]],8,9] vs [1,[2,[3,[4,[5,6,0]]]],8,9]
+  - Compare 1 vs 1
+  - Compare [2,[3,[4,[5,6,7]]]] vs [2,[3,[4,[5,6,0]]]]
+    - Compare 2 vs 2
+    - Compare [3,[4,[5,6,7]]] vs [3,[4,[5,6,0]]]
+      - Compare 3 vs 3
+      - Compare [4,[5,6,7]] vs [4,[5,6,0]]
+        - Compare 4 vs 4
+        - Compare [5,6,7] vs [5,6,0]
+          - Compare 5 vs 5
+          - Compare 6 vs 6
+          - Compare 7 vs 0
+            - Right side is smaller, so inputs are not in the right order
+
+What are the indices of the pairs that are already in the right order? (The first pair has index 1, the second pair has index 2, and so on.) In the above example, the pairs in the right order are 1, 2, 4, and 6; the sum of these indices is 13.
+
+Determine which pairs of packets are already in the right order. What is the sum of the indices of those pairs?
+
+### ChatGPT
+
+Voici un script bash qui résout ce problème :
+
+```bash
+#!/bin/bash
+
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+}
+
+# Lire l'input et stocker chaque ligne dans un tableau
+readarray -t lines
+
+# Initialiser le compteur de paires en ordre à 0
+count=0
+
+# Pour chaque paire d'éléments du tableau
+for ((i=0; i<${#lines[@]}; i+=2)); do
+  # Comparer les deux éléments de la paire
+  result=$(compare "${lines[i]}" "${lines[i+1]}")
+  # Si les éléments sont dans l'ordre, incrémenter le compteur
+  if [ "$result" == "left" ]; then
+    count=$((count+1))
+  fi
+done
+
+# Afficher le résultat
+echo "$count"
+
+```
+
+Ce script utilise la fonction compare pour comparer deux éléments en utilisant les règles spécifiées dans l'énoncé. La fonction retourne "left" si l'élément de gauche est inférieur à l'élément de droite, "right" si l'élément de gauche est supérieur à l'élément de droite, et "equal" si les deux éléments sont égaux.
+
+Le script lit l
+
+### You
+la réponse a été tronquée. D'autre part, le programme semble boucler indéfiniment avec l'exemple donné.
+
+### ChatGPT
+
+Je suis désolé pour le problème rencontré. Voici la réponse complète :
+
+```bash
+#!/bin/bash
+
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+}
+
+# Lire l'input et stocker chaque ligne dans un tableau
+readarray -t lines
+
+# Initialiser le compteur de paires en ordre à 0
+count=0
+
+# Pour chaque paire d'éléments du tableau
+for ((i=0; i<${#lines[@]}; i+=2)); do
+  # Comparer les deux éléments de la paire
+  result=$(compare "${lines[i]}" "${lines[i+1]}")
+  # Si les éléments sont dans l'ordre, incrémenter le compteur
+  if [ "$result" == "left" ]; then
+    count=$((count+1))
+  fi
+done
+
+# Afficher le résultat
+echo "$count"
+
+```
+
+Je suis désolé pour l'erreur de boucle infinie. Pour résoudre ce problème, il faut ajouter un return à la fin de la fonction compare afin de sortir de la fonction lorsque l'on a trouvé une comparaison égale. Voici la version corrigée de la fonction :
+
+```python
+# Fonction de comparaison de deux éléments
+compare
+
+```
+
+### You
+je n'ai pas reçu la version corrigée
+
+### ChatGPT
+
+Je suis désolé pour ce problème. Voici la version corrigée de la fonction compare :
+
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+
+```
+
+Je vous prie de m'excuser pour cet oubli et j'espère que cette version corrigée vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+ajouter "return" à la fin d'une fonction bash ne change rien. Le problème est toujours là.
+
+### ChatGPT
+
+Je suis désolé pour cet autre problème. En effet, ajouter return à la fin d'une fonction en bash ne change pas son comportement et ne peut pas résoudre le problème de boucle infinie.
+
+Le problème vient en réalité du fait que la fonction compare n'a pas de cas de sortie pour les comparaisons égales. Lorsque la fonction compare deux éléments qui sont égaux, elle retourne "equal", mais elle ne fait rien de plus et ne sort pas de la fonction. Cela entraîne une boucle infinie lorsque la fonction est appelée avec deux éléments égaux.
+
+Pour résoudre ce problème, il faut ajouter un return à la fin de la fonction lorsque la comparaison est égale :
+
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[
+
+```
+
+Je suis désolé pour le problème de formatage de la réponse précédente. Voici la version corrigée de la fonction compare 
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+
+
+### You
+
+Il s'agit de la mẽme version que la dernière, avec "return" ajouté à la fin de la fonction, ce qui n'a aucun effet.
+
+### ChatGPT
+Je suis désolé pour cette erreur. En effet, ajouter return à la fin de la fonction compare ne résoud pas le problème de boucle infinie.Pour résoudre ce problème, il faut ajouter un cas de sortie lorsque la comparaison est égale, comme ceci 
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+Je suis désolé pour cette erreur et j'espère que cette version corrigée vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+
+La fonction compare() est toujours appelée sans fin. Peut-être que la détection des terminaison des sous-listes n'est pas correcte ?
+
+### ChatGPT
+Vous avez raison, il y a un autre problème dans la fonction compare. En effet, lorsque la fonction compare deux listes, elle ne vérifie pas si l'une des listes est plus longue que l'autre. Si une liste est plus longue, la fonction continue à comparer les éléments suivants, ce qui entraîne une boucle infinie.Pour résoudre ce problème, il faut ajouter une vérification de la longueur des listes avant de comparer leurs éléments
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+
+Je suis désolé pour ces erreurs et j'espère que cette version corrigée de la fonction compare vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+
+ça boucle toujours. Je me demande si les terminaisons des sous-listes ("]") sont bien gérées par la fonction compare(). 
+
+### ChatGPT
+Vous avez raison, il y a encore un autre problème dans la fonction compare. En effet, la fonction ne gère pas correctement les terminaisons de sous-listes ("]"). Lorsqu'elle compare deux sous-listes, elle ne vérifie pas si l'une des sous-listes est terminée avant de continuer à comparer les éléments suivants. Si une sous-liste est terminée alors que l'autre est plus longue, la fonction continue à comparer les éléments suivants, ce qui entraîne une boucle infinie.Pour résoudre ce problème, il faut ajouter une vérification de la terminaison des sous-listes avant de comparer leurs éléments
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      if [[ "${left[i]}" == *"]"* ]] || [[ "${right[i]}" == *"]"* ]]; then
+        result=$(compare "${left[i]}" "${right[i]}")
+        if [ "$result" == "left" ]; then
+          echo "left"
+          return
+       
+```
+
+### You
+
+le code a été tronqué
+
+### ChatGPT
+Je suis désolé pour cette erreur. Voici le code complet de la fonction compare corrigée :
+
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    IFS=',' read -a left <<< "$1"
+    IFS=',' read -a right <<< "$2"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      if [[ "${left[i]}" == *"]"* ]] || [[ "${right[i]}" == *"]"* ]]; then
+        result=$(compare "${left[i]}" "${right[i]}")
+        if [ "$result" == "left" ]; then
+          echo "left"
+          return
+        elif [ "$result" == "right" ]; then
+          echo "right"
+          return
+        fi
+      else
+        result=$(compare "${left[i]}" "${right[i]}")
+        if [ "$result" == "left" ]; then
+          echo "left"
+          return
+        elif [ "$result" == "right" ]; then
+          echo "right"
+          return
+        elif [ "$result" == "equal" ]; then
+          continue
+        fi
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```
+Je suis désolé pour ces erreurs et j'espère que cette version corrigée de la fonction compare vous sera utile. Si vous avez d'autres questions ou si vous avez besoin de plus de détails, n'hésitez pas à me contacter.
+
+### You
+ça boucle toujours. Peut-être faudrait-t'il s'assurer que les deux "read" s'arrêtent à la fin de la liste concernée ?
+
+### ChatGPT
+Vous avez raison, il y a encore un problème dans la fonction compare. En effet, lorsque la fonction compare deux listes, elle utilise `IFS=',' read -a left <<< "$1"` et `IFS=',' read -a right <<< "$2"` pour les découper en tableaux left et right. Cependant, cette syntaxe ne s'arrête pas à la fin de la liste et inclut tous les caractères suivants jusqu'à la fin de la ligne. Si la liste contient des crochets fermants, cela peut entraîner des erreurs de découpage et des comparaisons incorrectes.
+
+Pour résoudre ce problème, il faut utiliser une expression régulière pour découper les listes en tableaux :
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    left=$(sed 's/^\[//;s/\]$//' <<< "$1")
+    right=$(sed 's/^\[//;s/\]$//' <<< "$2")
+    IFS=',' read -a left <<< "$left"
+    IFS=',' read -a right <<< "$right"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      result=$(compare "${
+```
+
+### You
+la réponse a été tronquée
+
+### ChatGPT
+Je suis désolé pour cette erreur. Voici la fonction `compare` complète :
+```bash
+# Fonction de comparaison de deux éléments
+compare() {
+  # Si les deux éléments sont des entiers, les comparer
+  if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
+    if [ "$1" -lt "$2" ]; then
+      echo "left"
+    elif [ "$1" -gt "$2" ]; then
+      echo "right"
+    else
+      echo "equal"
+      return
+    fi
+  # Sinon, si les deux éléments sont des listes, comparer chaque élément de la liste
+  elif [[ "$1" == *"["* ]] && [[ "$2" == *"["* ]]; then
+    left=$(sed 's/^\[//;s/\]$//' <<< "$1")
+    right=$(sed 's/^\[//;s/\]$//' <<< "$2")
+    IFS=',' read -a left <<< "$left"
+    IFS=',' read -a right <<< "$right"
+    if [ ${#left[@]} -lt ${#right[@]} ]; then
+      echo "left"
+      return
+    elif [ ${#left[@]} -gt ${#right[@]} ]; then
+      echo "right"
+      return
+    fi
+    for i in "${!left[@]}"; do
+      result=$(compare "${left[i]}" "${right[i]}")
+      if [ "$result" == "left" ]; then
+        echo "left"
+        return
+      elif [ "$result" == "right" ]; then
+        echo "right"
+        return
+      fi
+    done
+    # Si les deux listes sont égales, continuer à vérifier la suite de l'input
+    echo "equal"
+  # Sinon, si un des deux éléments est une liste, convertir l'autre en liste et retenter la comparaison
+  else
+    if [[ "$1" == *"["* ]]; then
+      compare "$1" "[$2]"
+    else
+      compare "[$1]" "$2"
+    fi
+  fi
+  return
+}
+```

fetch-all.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+
+origin=origin
+
+declare -a remotes local
+
+readarray -t remotes < <(git remote)
+declare -A aremotes alocal_b
+
+# fetch all remotes
+for remote in "${remotes[@]}"; do
+    aremotes["$remote"]=1
+    echo doing git fetch -a "$remote"
+done
+
+# get local branches
+readarray -t local_b < <(git for-each-ref --format='%(refname:short)' refs/heads/)
+
+# build local ref array
+for ref in "${local_b[@]}"; do
+    alocal_b[$ref]=1
+done
+
+
+readarray -t orig_b  < <(git for-each-ref --format='%(refname:short)' \
+                             refs/remotes/"$origin"/)
+
+declare -p remotes
+#declare -p aremotes
+declare -p local_b orig_b
+
+# find-out missing local branches
+for remote_b in "${orig_b[@]}"; do
+    short=${remote_b#"$origin"/};
+    echo "$remote_b -> $short ${alocal_b[$short]}"
+done
+
+
+
+
+
+
+#git remote | xargs -n 1 git fetch -a

foo.h

@@ -2,4 +2,4 @@
 
 #define bit_for_each64(pos, tmp, ul)  \
     for (tmp = ul, pos = ffs64(tmp); pos; tmp &= (tmp - 1),  pos = ffs64(tmp))
-
+#define true 1

g910-gkeys-setup.org

@@ -1,19 +1,25 @@
 * Alternative settings for g910-gkeys
+*Important : This document is for Xorg only (not Wayland).**
 
 This document will explain how to setup g910-gkeys by limiting as much as possible the usage of a global config, the idea being to setup global mapping in a static manner, and let the user set the actions in his/her own environment.
 
 ** Preamble
-~g910-gkeys~ allows different actions : `typeout`, `shortcut` and `run`. All of these actions will be performed on the process environment, that is `root`. Also, these actions will be *global*.
+~g910-gkeys~ allows different actions : ~typeout~, ~shortcut~ and ~run~. There are some drawbacks with that :
-** g910-gkeys
+- All of these actions will be performed on the process environment, that is ~root~.
-The configuration chosen will ba basic: assign each ~g-key~ to a key which does not exist on physical keyboard. Any key could be used, like specific localized keys which do not exist on your keyboard (example: Japanese keys for an English keyboard), or function keys above F12.
+- These actions are *global*.
+- The actions (especially ~run~) will be performed even when the user is not logged-on.
+- It is impossible to use the G-keys as /normal/ keys (for example different actions with different modifiers, for example ~Shift-G1~ or ~Control-Meta-G1~).
 
-We will choose to map them to Function keys `F13` to `F21`. It is possible that some of these F-keys are already used on your system (example: some media keys may be assigned to `F20`). In this case, simply use another F-key.
+** g910-gkeys configuration file (/etc/g910-gkeys/config.json)
+The configuration chosen will be basic: assign each ~G-key~ to a key which does not exist on physical keyboard. Any key could be used, like specific localized keys which do not exist on your keyboard (example: Japanese keys for an English keyboard), or function keys above F12.
 
-The ~g910-gkeys~ will be (skipping ~F20~ on my system):
+We will choose to map them to Function keys ~F13~ to ~F21~.
 
-#+begin_src json
+My ~g910-gkeys~ is :
+
+#+BEGIN_SRC json
 {
-    "__comment": "I was unable to use F20, even xev does not show the keycode. It just mutes/unmutes sound, same as the G910's <mute> button",
+    "__comment": "I was sometimes unable to use F20, even xev did not show the keycode (It just muted/unmuted sound, same as the G910's <mute> button). If it is the case for you, just skip F20 and use F22 instead.",
     "keyboard_mapping": "en",
     "g1": {
         "hotkey_type": "shortcut",
@@ -45,32 +51,200 @@ The ~g910-gkeys~ will be (skipping ~F20~ on my system):
     },
     "g8": {
         "hotkey_type": "shortcut",
-        "do": "F21"
+        "do": "F20"
     },
     "g9": {
         "hotkey_type": "shortcut",
-        "do": "F22"
+        "do": "F21"
     }
 }
-#end_src
+#+END_SRC
+
+** X11 keyboard mapping
+/*Note*: Below, I configure ~F22~ (which looks un-necessary), because I had trouble with ~F20~ at some point, and used ~F22~ as fallback./
+
+By default, the F13-F22 keys may be mapped to some defaults. For example, ~F13~ could return ~XF86Tools~.
+This is not what we want: Instead we want F13-F22 to return themselves.
+
+It could be possible to keep the default mappings, but it makes less sense, and it would probably clash with the keyboard Media keys.
+
+You can check if this mapping is done on your system with the command ~xmodmap -pke | grep -E 'keycode (19[1-9]|200)'~ :
+#+CAPTION: Correct F-keys mapping
+#+BEGIN_SRC
+$ xmodmap -pke | grep -E 'keycode (19[1-9]|200)'
+keycode 191 = F13 F13 F13 F13 F13 F13 F13
+keycode 192 = F14 F14 F14 F14 F14 F14 F14
+keycode 193 = F15 F15 F15 F15 F15 F15 F15
+keycode 194 = F16 F16 F16 F16 F16 F16 F16
+...
+keycode 200 = F22 F22 F22 F22 F22 F22 F22
+#+END_SRC
+
+#+CAPTION: Incorrect F-keys mapping
+#+BEGIN_SRC
+$ xmodmap -pke | grep -E 'keycode (19[1-9]|200)'
+keycode 191 = XF86Tools NoSymbol XF86Tools
+keycode 192 = XF86Launch5 NoSymbol XF86Launch5
+keycode 193 = XF86Launch6 NoSymbol XF86Launch6
+...
+keycode 200 = XF86TouchpadOn NoSymbol XF86TouchpadOn
+#+END_SRC
+
+If your configuration is incorrect, you can choose one of the two solutions below (I prefer the first one) :
+*** Solution 1: Fix F-keys mapping globally
+You will need to find out where the mapping *F-key -> Different key* is done. On my system, it was in ~/usr/share/X11/xkb/symbols/inet~.
+
+To find where the mapping is done on your system, you may run : ~setxkbmap -print -verbose 10~) :
+#+BEGIN_SRC
+$ setxkbmap -print -verbose 10
+Setting verbose level to 10
+locale is C
+Trying to load rules file ./rules/evdev...
+Trying to load rules file /usr/share/X11/xkb/rules/evdev...
+Success.
+Applied rules from evdev:
+rules:      evdev
+model:      pc105
+layout:     us
+variant:    altgr-intl
+options:    compose:ralt,grp:ctrls_toggle,lv3:ralt_switch,terminate:ctrl_alt_bksp
+Trying to build keymap using the following components:
+keycodes:   evdev+aliases(qwerty)
+types:      complete
+compat:     complete
+symbols:    pc+us(altgr-intl)+inet(evdev)+group(ctrls_toggle)+level3(ralt_switch)+compose(ralt)+terminate(ctrl_alt_bksp)
+geometry:   pc(pc105)
+xkb_keymap {
+	xkb_keycodes  { include "evdev+aliases(qwerty)"	};
+	xkb_types     { include "complete"	};
+	xkb_compat    { include "complete"	};
+	xkb_symbols   { include "pc+us(altgr-intl)+inet(evdev)+group(ctrls_toggle)+level3(ralt_switch)+compose(ralt)+terminate(ctrl_alt_bksp)"	};
+	xkb_geometry  { include "pc(pc105)"	};
+};
+#+END_SRC
+
+In my case, the faulty configuration was the ~inet(evdev)~ part on ~symbols~ line, meaning in the ~xkb_symbols "evdev" {~ section of ~/usr/share/X11/xkb/symbols/inet~ file. I had to remove the ~FK13-FK22~ lines and add my own. For example, replacing the line :
+#+BEGIN_SRC
+key <FK13>   {      [ XF86Tools         ]       };
+#+END_SRC
+With :
+#+BEGIN_SRC
+key <FK13>   {      [ F13, F13, F13, F13   ]       };
+#+END_SRC
+The full diff with my changes is :
+#+BEGIN_SRC
+$ diff -u0 inet.brsav.2022.11.13 inet
+--- inet.brsav.2022.11.13	2022-02-08 18:13:55.000000000 +0100
++++ inet	2022-11-13 13:09:29.910184100 +0100
+@@ -115,5 +114,0 @@
+-    key <FK21>   {      [ XF86TouchpadToggle    ]       };
+-    key <FK22>   {      [ XF86TouchpadOn        ]       };
+-    key <FK23>   {      [ XF86TouchpadOff       ]       };
+-
+-    key <FK20>   {      [ XF86AudioMicMute      ]       };
+@@ -204,6 +199,10 @@
+-    key <FK13>   {      [ XF86Tools         ]       };
+-    key <FK14>   {      [ XF86Launch5       ]       };
+-    key <FK15>   {      [ XF86Launch6       ]       };
+-    key <FK16>   {      [ XF86Launch7       ]       };
+-    key <FK17>   {      [ XF86Launch8       ]       };
+-    key <FK18>   {      [ XF86Launch9       ]       };
++    key <FK13>   {      [ F13, F13, F13, F13   ]       };
++    key <FK14>   {      [ F14, F14, F14, F14   ]       };
++    key <FK15>   {      [ F15, F15, F15, F15   ]       };
++    key <FK16>   {      [ F16, F16, F16, F16   ]       };
++    key <FK17>   {      [ F17, F17, F17, F17   ]       };
++    key <FK18>   {      [ F18, F18, F18, F18   ]       };
++    key <FK19>   {      [ F19, F19, F19, F19   ]       };
++    key <FK20>   {      [ F20, F20, F20, F20   ]       };
++    key <FK21>   {      [ F21, F21, F21, F21   ]       };
++    key <FK22>   {      [ F22, F22, F22, F22   ]       };
+#+END_SRC
+*** Solution 2: Fix F-keys mapping with .Xmodmaprc
+If you prefer not to touch system-wide files, you can add in your ~/.Xmodmap~ :
+#+BEGIN_SRC
+!!!!!!!!!!!!!! Logitech G910 keyboard
+! Note:
+! F11-F20 have synonyms L1-L10
+! F21-F35 have synonyms R1-R15
+! See: /usr/include/X11/keysymdef.h
+!
+! original F13, F14, etc... mapping on my system :
+! F13 = keycode 191 = XF86Tools NoSymbol XF86Tools
+! F14 = keycode 192 = XF86Launch5 NoSymbol XF86Launch5
+! F15 = keycode 193 = XF86Launch6 NoSymbol XF86Launch6
+! F16 = keycode 194 = XF86Launch7 NoSymbol XF86kLaunch7
+! F17 = keycode 195 = XF86Launch8 NoSymbol XF86Launch8
+! F18 = keycode 196 = XF86Launch9 NoSymbol XF86Launch9
+! F19 = keycode 197 = (nothing)
+! F20 = keycode 198 = XF86AudioMicMute NoSymbol XF86AudioMicMute
+! F21 = keycode 199 = XF86TouchpadToggle NoSymbol XF86TouchpadToggle
+! F22 = keycode 200 = XF86TouchpadOn NoSymbol XF86TouchpadOn
+
+! we map the Gkeys (G1-G9), to F13-F21,
+
+! G1
+keycode 191 = F13 F13 F13 F13 F13 F13
+! G2
+keycode 192 = F14 F14 F14 F14 F14 F14
+! G3
+keycode 193 = F15 F15 F15 F15 F15 F15
+! G4
+keycode 194 = F16 F16 F16 F16 F16 F16
+! G5
+keycode 195 = F17 F17 F17 F17 F17 F17
+! G6
+keycode 196 = F18 F18 F18 F18 F18 F18
+! G7
+keycode 197 = F19 F19 F19 F19 F19 F19
+! G8
+keycode 198 = F20 F20 F20 F20 F20 F20
+! G9
+keycode 199 = F21 F21 F21 F21 F21 F21
+#+END_SRC
 
 ** User configuration
 *Note*: Configuration below will make the ~G-keys~ active only when user is logged-on, as any other key.
 
-We will assign the F-keys we defined in `config.json` to any program (this includes graphical programs), or to send a string to active window (using *xvkbd*[fn:1]).
+We will assign the F-keys we defined in ~config.json~ to run any program (this includes graphical programs), or to send a string/command output to active window.
-
-*xvkbd* not only allows to send strings ("hello, World!"), but also modifiers (as ~Control-A~, ~Alt-B~, ~Control-Left~), mouse events (motion, buttons), etc... This is a subset of the *typeout* option of config.json. See ~xbkbd man page~ for more details.
 
 Below are some examples (screenshots from ~Xubuntu 22.10~). We will define the following actions :
-- ~G1~ will make the *Emacs* main window (whose title is always "*GNU Emacs*") active.
+- ~G1~: Activate the *Emacs* main window (whose title is always "*GNU Emacs*").
-- ~G2~ will launch a *Gnome Terminal*.
+- ~Shift-G1~: Launch *Gnome Terminal*.
-- ~G3~ will send the string "Hello, World !" to active window.
+- ~G2~ (including with modifiers): Send ~strings~ or ~commands output~ to active window.
-- ~G4~ will send the current date to active window.
+- ~G5~: Assigned to ~Hyper~ modifier: ~G5+a~ will be ~Hyper-a~, as ~Control+a~ is ~Control-a~.
-- ~G5~ will be assigned to a ~Hyper~ modifier: `G5 + a` will be `Hyper-a`, as `Control + a` is `Control-a`.
+- ~G6~: Will move the cursor to top-left corner.
+All settings below (except for ~G5~) are configurable in ~Settings/keyboard~, ~Application Shortcuts~ tab, or, for pasting text, via ~autokey~ :
+#+CAPTION: Xfce keyboard settings
+[[./img/g910-keyboard-settings.png]]
+#+CAPTION: Autokey screenshot
+[[./img/autokey.png]]
+*** G1: Activate the *Emacs* main window
+In ~Application Shortcut~ section, click on ~Add~, then set command to ~wmctrl -F -a "GNU Emacs"~, click ~OK~, then press ~G1~ when asked.
+*** Shift-G1: Launch *Gnome Terminal*
+In ~Application Shortcut~ section, click on ~Add~, then set command to ~gnome-terminal~, click ~OK~, then press ~Shift-G1~ when asked.
+*** G2: Send different strings to active window
+We can send static/dynamic strings to active window, using ~autokey~ (on Ubuntu 22.10, autokey is provided by ~autokey-gtk~ or ~autokey-qt~ packages).
 
-All settings below (except for ~G5~) are configurable in `Settings/keyboard`, `Application Shortcuts` tab :
+Note that you can use any combination of modifiers (for example Shift+Meta+G2).
-#+CAPTION: This is the caption for the next figure link (or table)
+*Example 1*: Insert Japanese "山" with Shift-Control-G2 :
-#+NAME:   fig:SED-HR4049
+[[./img/yama.png]]
-./img/g910-keyboard-settings.png
 
-[fn:1] *xvkbd* is in package of same name on ~debian~ and derivatives. If your distribution does not have this package, you can download it at : [[http://t-sato.in.coocan.jp/xvkbd/]].
+*Example 2*: Insert current date to active window with G2 :
+[[./img/date.png]]
+
+
+*** G5: Assign to /Hyper/ modifier
+In ~$HOME/.Xmodmap~, add the following lines :
+#+CAPTION: Add an Hyper modifier to G5
+#+BEGIN_SRC
+! G5 becomes Hyper_L
+keycode 195 = Hyper_L NoSymbol Hyper_L
+clear mod3
+add mod3 = Hyper_L
+#+END_SRC
+
+*** G6: Move mouse cursor to top-left corner
+In ~Application Shortcut~ section, click on ~Add~, then set command to ~xvkbd -text '\x0\y0'~ (or ~xdotool mousemove 0 0~), click ~OK~, then press ~G6~ when asked.
+
+NOTE: wayland equivalent to : wtype

patrick-markdown/Makefile

@@ -1,10 +1,11 @@
 SHELL := /bin/bash
 
 # CSS to be included as stylesheets and alternate stylesheets
-CSS      := assets/ghost.css
+CSS      := assets/ghost-dark.css
-ALTCSS   := assets/ghost-dark.css assets/ghost-caca.css
+ALTCSS   := assets/ghost.css
 
-TARGETS  := $(patsubst %.md,%.html,$(wildcard *.md))
+MDFILES  := $(wildcard *.md)
+TARGETS  := $(patsubst %.md,%.html,$(MDFILES))
 CSSINC   := css.inc
 
 # our main html5 template, mostly taken from :
@@ -22,8 +23,9 @@ TITLE = $(shell sed -n '0,/^\#/ s/^[\# ]*//p' $1)
 OPTS     = --standalone --include-in-header=$(CSSINC) --template=$(TEMPLATE) \
            --from=gfm --to=html5
 
-.PHONY: all html clean
+.PHONY: titles all html clean
 
+#all: $(CSSINC) titles html
 all: $(CSSINC) html
 
 html: $(TARGETS)
@@ -40,5 +42,10 @@ $(CSSINC): $(CSS) $(ALTCSS)
 	@$(foreach css,$(ALTCSS),$(call ADD_LINE,$(css),alternate stylesheet,$@))
 
 %.html: %.md $(CSSINC)
-	@echo generating $@
+	@echo -n "generating $@... "
-	@pandoc $(OPTS) --metadata=title:"$(call TITLE,$<)" -o $@ $<
+	@if ! grep -q "^#" $< ; then                                      \
+	    echo "ERROR (no title), skipping." ;                          \
+	else                                                              \
+	    pandoc $(OPTS) --metadata=title:"$(call TITLE,$<)" -o $@ $< ; \
+	    echo done. ;                                                  \
+	fi

patrick-nextcoud.copy.md

@@ -0,0 +1,32 @@
+### CRÉER UNE VERSION DE NEXTCLOUD POUR TESTER L'UPGRADE (NEXTCLOUD2)
+
+1) créer dans FREENOM un DNS “nextcloud2”
+
+2) copier le répertoire “nextcloud” :
+```
+sudo cp -r /home/www/ml.faivre/nextcloud/ /home/www/ml.faivre/nextcloud2
+```
+3) créer une nouvelle base :
+```
+mysql -u root -p
+CREATE DATABASE IF NOT EXISTS `nextcloud2` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;
+```
+
+puis créer un nouvel utilisateur et lui donner tous les privilèges sur cette nouvelle base :
+```
+GRANT ALL ON nextcloud2.* TO 'nextcloud2'@'localhost' IDENTIFIED BY 'mon_mot_de_passe';
+FLUSH PRIVILEGES;
+```
+quitter MYSQL
+
+4) copier la base nextcloud.sql.gz en nextcloud2 :
+```
+cd /var/lib/mysql/
+zcat webtrees-old.sql.gz | sudo mysql nextcloud2
+```
+
+### RESTAURATION DE NEXTCLOUD ET DE SA BASE :
+```
+sudo rsync -e ssh -avz /mnt/backup1/damia-mountpoint/daily-04/www/ml.faivre/nextcloud/ /home/www/ml.faivre/nextcloud
+gunzip < /mnt/backup1/damia-mountpoint/daily-04/mysql/nextcloud.sql.gz | mysql -u root -p"my-password" nextcloud
+```

police-chinoise.org

@@ -0,0 +1,65 @@
+* Le Canada coupe le long bras de la police chinoise
+** Ouest-France, 3 décembre 2022
+*Chris Helgren, Reuters.*
+
+#+CAPTION: Des manifestants protestent contre la politique « zéro Covid » de Xi Jinping, le 29 novembre à Toronto, où la police chinoise a clandestinement implanté trois bureaux.
+[[file:Image-MEDIUM-22448322.jpg]]
+
+
+
+
+Un rapport publié en septembre par l'ONG Safeguard Defenders, basée à
+Madrid, a mis en évidence de discrètes implantations dans une trentaine
+de pays. Pour rendre service, et surveiller.
+
+La pression monte à Ottawa sur Cong Peiwu, l'ambassadeur de Chine. Il a
+été plusieurs fois convoqué au ministère canadien des Affaires
+étrangères, ces dernières semaines, pour s'expliquer sur un dossier
+embarrassant : l'implantation clandestine, à Toronto, hors de tout cadre
+légal, de trois *« postes de police »* chinois.
+
+L'ambassade a reconnu leur existence, mais minimisé les faits. Il
+s'agirait de simples *« points de services »* destinés à faciliter la
+vie des Chinois de la diaspora au moment de renouveler leur permis de
+conduire, par exemple. Une explication peu crédible : c'est le rôle des
+consulats, régis par la Convention de Vienne, et il en existe évidemment
+un dans la ville la plus peuplée du Canada.
+
+Sous pression de l'opposition conservatrice, le gouvernement de Justin
+Trudeau a fini, cette semaine, par sommer Pékin de fermer ces postes qui
+enfreignent la souveraineté canadienne. La police a annoncé enquêter
+*« sur une ingérence étrangère plus large »*.
+
+** Diaspora sous surveillance
+
+Le bras très long de la police chinoise a été mis en évidence, en
+septembre, par l'ONG Safeguard Defenders, basée à Madrid. Dans un
+rapport intitulé « 110 Overseas » (110 étant le numéro de police secours
+en Chine), elle a révélé l'existence de cinquante-quatre antennes de
+police, disséminées dans vingt-neuf pays.
+
+Une toile tissée par des polices municipales. Celles de Fuzhou et de
+Qingtian ne s'en cachent d'ailleurs pas. Elles signalent sur leurs sites
+internet ces *« points de contacts »*, qui reposent sur des Chinois
+de la diaspora. L'un des deux relais de la police de Fuzhou à Paris est
+ainsi logé à l'adresse de l'Association de Fuzhou en France, dans le 13ème
+arrondissement.
+
+S'agit-il seulement de rendre service ? Pékin se flattait récemment
+d'avoir *« persuadé »* 230 000 Chinois de rentrer au pays, entre
+avril 2021 et juillet 2022, pour y répondre de délits. Or, pour cela, il
+existe des accords d'entraide judiciaire entre pays. Pour l'ONG, le
+réseau policier sert aussi à surveiller et menacer les expatriés.
+
+Depuis la publication du rapport, une quinzaine de pays -- dont les
+États-Unis -- ont déclenché des enquêtes. L'Irlande et les Pays-Bas ont
+ordonné les fermetures immédiates des antennes clandestines. Des
+enquêtes sont annoncées du Portugal à la Suède. En France, le ministère
+de l'Intérieur a répondu évasivement au /Monde/ que la Direction
+générale de la sécurité intérieure veillait.
+
+En Europe, seule l'Italie semble hausser les épaules. En septembre, le
+ministre de l'Intérieur affirmait ne *«pas être particulièrement
+inquiet»* de la présence de la police de Fuzhou en Toscane. Une vidéo
+de 2018 montrerait même des policiers romains à l'ouverture d'une
+antenne de la police de Qingtian.