diff --git a/20250401/ad-20250401.pdf b/20250401/ad-20250401.pdf
index abfab80592754c022e0842e7b3eea0691be51dbe..301816c119ab62cddd14e46b17b7a5a432e86cad 100644
Binary files a/20250401/ad-20250401.pdf and b/20250401/ad-20250401.pdf differ
diff --git a/20250401/ad-20250401.tex b/20250401/ad-20250401.tex
index 9de9087a015cd443bb90eae54ddd682d2a874b32..ee6fadf434bdae2ea5a267f764528b23b742c8cc 100644
--- a/20250401/ad-20250401.tex
+++ b/20250401/ad-20250401.tex
@@ -383,7 +383,9 @@
 
 %    \pause[4]
     \smallskip
-    \hspace*{2.29cm}\textcolor{red}{\textbf{Mit Quantencomputer: \boldmath$\mathcal{O}\bigl((\log n)^3\bigr)$}}
+    \hspace*{2.29cm}\textcolor{red}{\textbf{Mit Quantencomputer:
+    \boldmath$\mathcal{O}\bigl((\log n)^3\bigr)$}
+    \textcolor{magenta}{bzw.~\boldmath$\mathcal{O}\bigl(n^3\bigr)$}}
 
   \end{onlyenv}
 
diff --git a/20250401/ad-20250401.txt b/20250401/ad-20250401.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5df5e55805461499ce7eda64050496f9cd0c04ac
--- /dev/null
+++ b/20250401/ad-20250401.txt
@@ -0,0 +1,43 @@
+Binär codiertes Dezimalsystem (BCD), 01.04.2025, 13:53:26
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+42 --> 0x42
+13 --> 0x13
+     + ----  spezieller Maschinenbefehl: BCD-Addition
+       0x55
+
+(Im Gegensatz zu:
+
+41 --> 0x2a
+13 --> 0x0d
+       --1-
+       0x37 = 55)
+
+Mögliche Projekte, 01.04.2025, 14:32:43
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Schreiben Sie ein nichttriviales Programm,
+das mit Algorithmen und Datenstrukturen arbeitet.
+Gruppenarbeit ist zulässig.
+
+Beispiele:
+
+ - https://gitlab.cvh-server.de/hardwarenahe-it/projekte
+
+ - Freies Smartphone:
+   Linux-Rechner in Smartphone-Gehäuse (Librem 5, Pinephone)
+   Problem: Die darauf laufenden Linux-Programme sind nur zum Teil
+   an Smartphone-Verhältnisse angepaßt.
+   Projekt: Etwas heraussuchen, was relevant, aber nicht gut bedienbar ist;
+   dafür sorgen, daß es gut bedienbar ist.
+
+ - yesVNC: Web-Interface zum Teilen des Bildschirms über VNC
+   https://streaming.cvh-server.de/vnc/yesvnc-wc-6.html
+   Problem 1: Das Programm "schläft ein", wenn der Browser nicht im Vordergrund ist.
+   Problem 2: Verbesserung der Kompression in Hinblick auf Scrolling
+   mögliche Lösung: neu schreiben in WebAssembly statt JavaScript
+ 
+ - Signal-Client anpassen, so daß P.G. damit gut arbeiten kann. ;-)
+   Grundlage: https://github.com/boxdot/gurk-rs/
+
+ - Wayland so konfigurieren, so daß P.G. damit gut arbeiten kann. ;-)
+   xbindkeys, xdotool, VNC, ...
+   Grundlage: https://github.com/swaywm/sway/
diff --git a/20250401/bigint2.c b/20250401/bigint2.c
new file mode 100644
index 0000000000000000000000000000000000000000..d1fe53e27b0d1ab7b41333e33cea70e5edecc70a
--- /dev/null
+++ b/20250401/bigint2.c
@@ -0,0 +1,106 @@
+// Copyright (C) 2025  Jakob Bierwolf
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#include <error.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#define N 2lu
+const uint64_t MAX = (uint64_t)UINT32_MAX + 1;
+
+typedef struct {
+  uint32_t n[N];
+} barr;
+
+barr barr_new(uint64_t value) {
+  barr number = {.n = {0}};
+  for (int i = 0; value; i++) {
+    if (i >= N)
+      error(1, 0,
+            "barr_new(): Number overflow, can only store %lu * "
+            "sizeof(uint32_t) bytes",
+            N);
+
+    number.n[i] += value % MAX;
+    value /= MAX;
+  }
+  return number;
+}
+
+void barr_print(barr a) {
+  int omit_leading_zeros = 0;
+  // int omit_leading_zeros = 1;
+  printf("0x");
+  for (int i = N - 1; i >= 0; i--) {
+    if (!omit_leading_zeros || a.n[i] || !i) {
+      printf("%08x", a.n[i]);
+      omit_leading_zeros = 0;
+    }
+  }
+}
+
+barr barr_add(barr a, barr b) {
+  barr sum = barr_new(0);
+  for (int i = 0; i < N; i++) {
+    uint64_t s = (uint64_t)sum.n[i] + (uint64_t)a.n[i] + (uint64_t)b.n[i];
+    if (s < MAX)
+      sum.n[i] = s;
+    else if (i + 1 < N) {
+      sum.n[i] = s % MAX;
+      sum.n[i + 1] += s / MAX;
+    } else {
+      error(1, 0,
+            "barr_add(): Number overflow, can only store %lu * "
+            "sizeof(uint32_t) bytes",
+            N);
+    }
+  }
+  return sum;
+}
+
+barr barr_sub(barr a, barr b) {
+  barr diff = barr_new(0);
+  for (int i = 0; i < N; i++) {
+    int32_t d = (int32_t)diff.n[i] + (int32_t)a.n[i] - (int32_t)b.n[i];
+    diff.n[i] = d;
+    if (d < 0) {
+      if (i + 1 < N) {
+        diff.n[i] = d + MAX;
+        diff.n[i + 1] += d / MAX;
+      } else {
+        error(1, 0,
+              "barr_sub(): Number overflow, can only store %lu * "
+              "sizeof(uint32_t) bytes",
+              N);
+      }
+    }
+  }
+  return diff;
+}
+
+int main(void) {
+  // barr a = barr_new(0xffffffffffffffff);
+  // barr b = barr_new(0x0000000000000001);
+  barr a = barr_new(0x00000000ffffffff);
+  barr b = barr_new(0x0000000000000001);
+  barr c = barr_add(a, b);
+  printf("  ");
+  barr_print(a);
+  printf("\n+ ");
+  barr_print(b);
+  printf("\n--------------------\n= ");
+  barr_print(c);
+  printf("\n");
+}
diff --git a/20250401/long-numbers-01.c b/20250401/long-numbers-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb0c11e5bd519258bc0b063a4acc2c52368ba874
--- /dev/null
+++ b/20250401/long-numbers-01.c
@@ -0,0 +1,10 @@
+int ergebnis = 0;
+int uebertrag = 0;
+for (int i = 0; i < MAX; i++)
+  {
+    int summe = zahl1[i] + zahl2[i] + uebertrag;
+    ergebnis[i] = summe % 10;
+    uebertrag = summe / 10;
+  }
+
+könnte die schleife so aussehen ?
diff --git a/20250401/long-numbers-02.c b/20250401/long-numbers-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..86383ea5ae40aed08a2595d5e4f3b9682a7c4d4e
--- /dev/null
+++ b/20250401/long-numbers-02.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <error.h>
+
+#define N 4
+
+void add_numbers (char *a, char *b, char *s)
+{
+  int carry = 0;
+  for (int i = N - 1; i >= 0; i--)
+    {
+      int A = a[i] - '0';
+      int B = b[i] - '0';
+      int S = A + B + carry;
+      s[i] = S + '0';
+    }
+  if (carry)
+    error (1, 1, "overflow");
+}
+
+int main (void)
+{
+  char *a = "1234";
+  char *b = "3456";
+  char s[N] = "0000";
+  add_numbers (a, b, s); 
+  return 0;
+}
diff --git a/20250401/long-numbers-03.c b/20250401/long-numbers-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..4830dadb2071568aba5cec37c08b51714487a359
--- /dev/null
+++ b/20250401/long-numbers-03.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <error.h>
+
+#define N 4
+
+void add_numbers (char *a, char *b, char *s)
+{
+  int carry = 0;
+  for (int i = N - 1; i >= 0; i--)
+    {
+      int A = a[i] - '0';
+      int B = b[i] - '0';
+      int S = A + B + carry;
+      s[i] = S + '0';
+    }
+  if (carry)
+    error (1, 1, "overflow");
+}
+
+int main (void)
+{
+  char *a = "1234";
+  char *b = "3456";
+  char s[N] = "0000";
+  add_numbers (a, b, s); 
+  printf ("%s + %s = %s\n", a, b, s);
+  return 0;
+}
diff --git a/20250401/long-numbers-04.c b/20250401/long-numbers-04.c
new file mode 100644
index 0000000000000000000000000000000000000000..bc5c0f85966af207b02befb0b04c00f3965cae88
--- /dev/null
+++ b/20250401/long-numbers-04.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <error.h>
+
+#define N 4
+
+void add_numbers (char *a, char *b, char *s)
+{
+  int carry = 0;
+  for (int i = N - 1; i >= 0; i--)
+    {
+      int A = a[i] - '0';
+      int B = b[i] - '0';
+      int S = A + B + carry;
+      if (S > 9)
+        {
+          S -= 10;
+          carry = 1;
+        }
+      else
+        carry = 0;
+      s[i] = S + '0';
+    }
+  if (carry)
+    error (1, 1, "overflow");
+}
+
+int main (void)
+{
+  char *a = "1234";
+  char *b = "3456";
+  char s[N] = "0000";
+  add_numbers (a, b, s); 
+  printf ("%s + %s = %s\n", a, b, s);
+  return 0;
+}
diff --git a/20250401/long-numbers-05.c b/20250401/long-numbers-05.c
new file mode 100644
index 0000000000000000000000000000000000000000..b9eef552e1c9fd5a10ec94e3f6f1ff281e6c915f
--- /dev/null
+++ b/20250401/long-numbers-05.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <error.h>
+
+#define N 4
+
+void add_numbers (char *a, char *b, char *s)
+{
+  int carry = 0;
+  for (int i = N - 1; i >= 0; i--)
+    {
+      int A = a[i] - '0';
+      int B = b[i] - '0';
+      int S = A + B + carry;
+      if (S > 9)
+        {
+          S -= 10;
+          carry = 1;
+        }
+      else
+        carry = 0;
+      s[i] = S + '0';
+    }
+  if (carry)
+    error (1, 1, "overflow");
+}
+
+int main (void)
+{
+  char *a = "1234";
+  char *b = "3456";
+  char s[N + 1] = "0000";
+  add_numbers (a, b, s); 
+  printf ("%s + %s = %s\n", a, b, s);
+  return 0;
+}
diff --git a/20250401/rsa-01.c b/20250401/rsa-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f225698444f9eed04a5fb28d63f34df4ea9450b
--- /dev/null
+++ b/20250401/rsa-01.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  for (int i = 0; i < e; i++)
+    c = (c * m) % N;
+  printf ("c = %d\n", c);
+  return 0;
+}
diff --git a/20250401/rsa-02.c b/20250401/rsa-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..775fb10d8274851bdd1c2185250178a726e511e7
--- /dev/null
+++ b/20250401/rsa-02.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  for (int i = 0; i < e; i++)   // O(n) mit n = e, z.B. e = 2 hoch 2048
+    c = (c * m) % N;            // O(2^n) mit n = Anzahl der Bits in e --> langsam
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  m = 1;
+  // m = c hoch d modulo N
+  for (int i = 0; i < d; i++)
+    m = (m * c) % N;
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/rsa-03.c b/20250401/rsa-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..f652dd513a422a6615e969a04a0d274780235101
--- /dev/null
+++ b/20250401/rsa-03.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+int binexp (int b, int e, int N)
+{
+  int result = 1;
+  for (int i = 0; i < e; i++)   // geschummelt: O(2^n) statt O(n), n = Bits von e
+    result = (result * b) % N;
+  return result;
+}
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  c = binexp (m, e, N);
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  // m = c hoch d modulo N
+  m = binexp (c, d, N);
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/rsa-04.c b/20250401/rsa-04.c
new file mode 100644
index 0000000000000000000000000000000000000000..19bd1fd7a12b108b97072345024a881dda18f8c8
--- /dev/null
+++ b/20250401/rsa-04.c
@@ -0,0 +1,56 @@
+#include <stdio.h>
+
+int binexp (int b, int e, int N)
+{
+  if (e == 4)
+    {
+      b *= b;
+      b *= b;
+      return b;
+    }
+  else if (e == 5)
+    {
+      int orig_b = b;
+      b *= b;
+      b *= b;
+      b *= orig_b;
+      return b;
+    }
+  else if (e == 13)
+    {
+      int orig_b = b;
+      b *= b;
+      b *= b;
+      int b_4 = b;
+      b *= b;
+      b *= orig_b * b_4;
+      return b;
+    }
+  else
+    {
+      int result = 0;
+      for (int i = 0; i < e; i++)   // geschummelt
+        result *= b;
+      return result;
+    }
+}
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  c = binexp (m, e, N);
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  // m = c hoch d modulo N
+  m = binexp (c, d, N);
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/rsa-05.c b/20250401/rsa-05.c
new file mode 100644
index 0000000000000000000000000000000000000000..c911501c7e903ac0d092d817d20e6387f983433a
--- /dev/null
+++ b/20250401/rsa-05.c
@@ -0,0 +1,56 @@
+#include <stdio.h>
+
+int binexp (int b, int e, int N)
+{
+  if (e == 4)
+    {
+      b = (b * b) % N;  // b^2
+      b = (b * b) % N;  // b^4
+      return b;
+    }
+  else if (e == 5)
+    {
+      int orig_b = b;
+      b = (b * b) % N;  // b^2
+      b = (b * b) % N;  // b^4
+      b = (b * orig_b) % N;
+      return b;
+    }
+  else if (e == 13)
+    {
+      int orig_b = b;
+      b = (b * b) % N;  // b^2
+      b = (b * b) % N;  // b^4
+      int b_4 = b;
+      b = (b * b) % N;  // b^8
+      b = (b * orig_b * b_4) % N;  // b^13
+      return b;
+    }
+  else
+    {
+      int result = 1;
+      for (int i = 0; i < e; i++)   // geschummelt
+        result = (result * b) % N;
+      return result;
+    }
+}
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  c = binexp (m, e, N);
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  // m = c hoch d modulo N
+  m = binexp (c, d, N);
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/rsa-06.c b/20250401/rsa-06.c
new file mode 100644
index 0000000000000000000000000000000000000000..c9e11c10f06a303b2f88b54a66eb63e221ec82ac
--- /dev/null
+++ b/20250401/rsa-06.c
@@ -0,0 +1,56 @@
+#include <stdio.h>
+
+int binexp (int b, int e, int N)
+{
+  if (e == 4)  // 4 = 0b100
+    {
+      b = (b * b) % N;  // b^2
+      b = (b * b) % N;  // b^4
+      return b;
+    }
+  else if (e == 5)  // 5 = 0b101 = 4 + 1
+    {
+      int orig_b = b;
+      b = (b * b) % N;  // b^2
+      b = (b * b) % N;  // b^4
+      b = (b * orig_b) % N;
+      return b;
+    }
+  else if (e == 13)  // 13 = 0b1101 = 8 + 4 + 1
+    {
+      int orig_b = b;
+      b = (b * b) % N;  // b^2
+      b = (b * b) % N;  // b^4
+      int b_4 = b;
+      b = (b * b) % N;  // b^8
+      b = (b * orig_b * b_4) % N;  // b^13
+      return b;
+    }
+  else
+    {
+      int result = 1;
+      for (int i = 0; i < e; i++)   // geschummelt
+        result = (result * b) % N;
+      return result;
+    }
+}
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  c = binexp (m, e, N);
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  // m = c hoch d modulo N
+  m = binexp (c, d, N);
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/rsa-07.c b/20250401/rsa-07.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c801d4e007b7f8eef68eee055bdbc7179b64bc4
--- /dev/null
+++ b/20250401/rsa-07.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+
+int binexp (int b, int e, int N)
+{
+  int result = 1;
+  int mask = 1;
+  for (int i = 0; i < 32; i++)
+    {
+      if (e % mask)
+        result = (result * b) % N;
+      b = (b * b) % N;
+      mask <<= 1;
+    }
+  return result;
+}
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  c = binexp (m, e, N);
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  // m = c hoch d modulo N
+  m = binexp (c, d, N);
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/rsa-08.c b/20250401/rsa-08.c
new file mode 100644
index 0000000000000000000000000000000000000000..b3a35863110600e5961a98f746cf12a278c350c5
--- /dev/null
+++ b/20250401/rsa-08.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+
+int binexp (int b, int e, int N)
+{
+  int result = 1;
+  int mask = 1;
+  for (int i = 0; i < 32; i++)      // O(n), wenn n die (maximale) Anzahl der Bits in e (= Schlüssellänge) ist.
+    {                               // O(log n), wenn n die Zahl e selbst ist.
+      if (e & mask)  // #-)         // Wenn das Bit in e gesetzt ist,
+        result = (result * b) % N;  // mit b multiplizieren.
+      b = (b * b) % N;              // b jedesmal quadrieren.
+      mask <<= 1;
+    }
+  return result;
+}
+
+int main (void)
+{
+  int p = 7;       // geheimer Schlüssel
+  int q = 11;      // geheimer Schlüssel
+  int d = 1;       // geheimer Schlüssel
+  int e = 13;      // öffentlicher Schlüssel
+  while ((e * d) % ((p - 1) * (q - 1)) != 1)   // weiterhin O(n), wobei n = (p - 1) * (q - 1)
+    d++;
+  int N = p * q;   // öffentlicher Schlüssel
+  int m = 12;      // Nachricht
+  int c = 1;       // verschlüsselte Nachricht ("Chiffrat")
+  // c = m hoch e modulo N
+  c = binexp (m, e, N);
+  printf ("Verschlüsselte Nachricht: c = %d\n", c);
+  // m = c hoch d modulo N
+  m = binexp (c, d, N);
+  printf ("Entschlüsselte Nachricht: m = %d\n", m);
+  return 0;
+}
diff --git a/20250401/schriftlich-addieren.png b/20250401/schriftlich-addieren.png
new file mode 100644
index 0000000000000000000000000000000000000000..a8ed21ae7cc0f16d8fb11996e1f7e8fb14e0767b
Binary files /dev/null and b/20250401/schriftlich-addieren.png differ
diff --git a/20250401/schriftlich-addieren.xcf.gz b/20250401/schriftlich-addieren.xcf.gz
new file mode 100644
index 0000000000000000000000000000000000000000..aa2d24118b35702d156b2c49b0d5b3375f56f05b
Binary files /dev/null and b/20250401/schriftlich-addieren.xcf.gz differ