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