diff --git a/20220517/catcan2.red b/20220517/catcan2.red
new file mode 100644
index 0000000000000000000000000000000000000000..f0aa1dcf34b4ecda5fe14a170ec69c6ad3044fe3
--- /dev/null
+++ b/20220517/catcan2.red
@@ -0,0 +1,21 @@
+;name Cat Can
+;author A. Kirchner, F. Uy, minor changes by P. Gerwinski
+;assert 1
+;
+; Your basic two sweep methodical bomber.
+; Fires SPL 0 and JMP -1 at every eight
+; addresses, then erases the core with
+; DAT bombs.
+
+start mov trap2, < bomb
+ mov trap1, < bomb
+ sub # 6, bomb
+ jmn start, bomb ; trap loop
+set mov # -5, bomb
+kill mov bomb, @ bomb
+ djn kill, bomb ; kill loop
+reset jmp set
+bomb dat # -8
+trap1 spl 0
+trap2 jmp -1
+ end start
diff --git a/20220517/knirps.red b/20220517/knirps.red
new file mode 100644
index 0000000000000000000000000000000000000000..befaa2a3da9a8cab5e76207623ac49880453b472
--- /dev/null
+++ b/20220517/knirps.red
@@ -0,0 +1,5 @@
+;name Knirps
+;assert 1
+
+start mov 0, 1
+ end start
diff --git a/20220517/mice.red b/20220517/mice.red
new file mode 100644
index 0000000000000000000000000000000000000000..88012d26a184b89f1d0510f76e44b7857b4e62eb
--- /dev/null
+++ b/20220517/mice.red
@@ -0,0 +1,16 @@
+;name Mice
+;author Chip Wendell
+;assert 1
+
+ptr dat #0
+start mov #12, ptr ; n = 12
+loop mov @ptr, <dest ; *--dest = *(ptr+(*ptr))
+ djn loop, ptr ; if(--ptr != 0)
+ ; goto loop
+ spl @dest ; split(*dest)
+ add #653, dest ; dest += 653
+ jmz start, ptr ; if(!ptr)
+ ; goto start
+dest dat #833
+
+ end start
diff --git a/20220517/nothing.red b/20220517/nothing.red
new file mode 100644
index 0000000000000000000000000000000000000000..5d6f3c21f2f19c3929c675c21b1e9a8ff47d8bf1
--- /dev/null
+++ b/20220517/nothing.red
@@ -0,0 +1,5 @@
+;name Nothing
+;assert 1
+
+start jmp 0
+ end start
diff --git a/20220517/rtech-20220517.txt b/20220517/rtech-20220517.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ed2a3288182f68eb43a3bb445cb6299306d40b4e
--- /dev/null
+++ b/20220517/rtech-20220517.txt
@@ -0,0 +1,243 @@
+Alte Klausuren (Hardwarenahe Programmierung):
+
+https://gitlab.cvh-server.de/pgerwinski/hp
+
+Prüfungsform im Sommersemester 2022: Hausarbeit mit Kolloquium
+
+Ideen für Projekte: z.B. bei heise.de
+ - Selbstgebauter Retro-Rechner - das Mainboard Terminal
+ https://www.heise.de/-7095736
+
+
+Struktur von Assembler-Programmen, 17.05.2022, 10:34:04
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Arithmetisch-logische Befehle: Operation, Operanden
+
+ Operation: +, -, *, /, and, or, xor, ...
+
+ Operanden, z.B. für "+": 1. und 2. Summand, Ergebnis
+
+ Beispiele:
+
+ i860:
+
+ add r24, r26, r28
+
+ "Nimm die Inhalte der Register 24 und 26, addiere sie,
+ und speichere das Ergebnis in Register 28."
+
+ IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+
+ addl %eax, %ebx
+
+ "Nimm den Inhalt der Register eax und ebx, addiere sie,
+ und speichere das Ergebnis in Register ebx."
+
+ (Die Endung "l" steht für 32 Bit.)
+
+ IA-32 (Intel-Architektur, 32 Bit), Intel-Syntax:
+
+ add ebx, eax
+
+ "Nimm den Inhalt der Register eax und ebx, addiere sie,
+ und speichere das Ergebnis in Register ebx."
+
+ (Die Register eax und ebx haben immer 32 Bit.)
+
+Sprungbefehle: Operand = Sprungziel
+
+ Beispiele:
+
+ IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+
+ jbe .L2
+
+ "Ist bei der letzten arithmetisch-logischen Operation
+ 'below or equal' herausgekommen? (D.h. z.B.: Das Ergebnis
+ einer Subtraktion ist negativ oder null.)
+ Falls ja, springe an die Speicherzelle,
+ der wir vorher den Namen '.L2' gegeben haben."
+
+ Prüfung, ob ein Wert kleiner oder gleich 7 ist:
+
+ Wert: im eax-Register
+
+ subl $7, %eax
+ jbe .L2
+
+ Nachteil: Danach ist der Wert des eax-Registers verändert.
+ Gegenmaßnahme: zwischenspeichern
+
+ movl %eax, %ebx
+ subl $7, %ebx
+ jbe .L2
+
+ Andere Gegenmaßnahme: cmp-Befehl ("compare")
+
+ cmpl $7, %eax
+ jbe .L2
+
+ "Führe die Subtraktion aus, aber verwerfe das Ergebnis und merke
+ dir nur, ob das Ergebnis größer, kleiner oder gleich Null war."
+
+ Wenn wir ein Programm direkt mit einem jbe-Befehl starten,
+ hängt das Ergebnis von der letzten arithmetisch-logischen Operation
+ des vorherigen Programms ab, also letztlich vom Zufall.
+
+Lade- und Speicher-Befehle: Operanden = Speicherzellen (einschließlich Prozessorregister)
+
+ Beispiele:
+
+ IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+
+ movb %al, b
+
+ "Nimm den Inhalt des al-Registers und speichere ihn
+ in der Speicherzelle, der wir den Namen b gegeben haben."
+
+ (Die Endung "b" steht für 8 Bit.)
+
+ movl %eax, %ebx
+
+ "Nimm den Inhalt des eax-Registers und speichere ihn im ebx-Register."
+
+ movl $1, %eax
+
+ "Nimm die Zahl 1 und speichere sie im Register eax."
+
+ IA-32 (Intel-Architektur, 32 Bit), Intel-Syntax:
+
+ mov ebx, eax
+
+ "Nimm den Inhalt des eax-Registers und speichere ihn im ebx-Register."
+
+ mov eax, #1
+
+ "Nimm die Zahl 1 und speichere sie im Register eax."
+
+ ATmega, AT&T-Syntax:
+
+ ldi r24, lo8(1)
+
+ "Nimm die untersten 8 Bit der Zahl 1 und speichere sie im Register r24."
+
+ (Das Register r24 hat nur 8 Bit.)
+
+Adressierungsarten:
+
+ unmittelbar: "die Zahl"
+
+ Beispiele:
+
+ IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+ movl $1, %eax
+ "Nimm die Zahl 1 und speichere sie im Register eax."
+
+ IA-32 (Intel-Architektur, 32 Bit), Intel-Syntax:
+ mov eax, #1
+ "Nimm die Zahl 1 und speichere sie im Register eax."
+
+ ATmega, AT&T-Syntax:
+ ldi r24, lo8(1)
+ "Nimm die untersten 8 Bit der Zahl 1 und speichere sie im Register r24."
+ (Das Register r24 hat nur 8 Bit.)
+
+ Register: "im Register"
+
+ Beispiele: dieselben (siehe oben)
+
+ Speicher absolut
+
+ Beispiele:
+
+ IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+ movb %al, b
+ "Nimm den Inhalt des al-Registers und speichere ihn
+ in der Speicherzelle, der wir den Namen b gegeben haben."
+
+ "Speicher" steht hier für: Arbeitsspeicher, RAM (random-access memory)
+ durchnumerierte Speicherzellen
+
+ "Register" steht für spezielle Speicherzellen im Inneren des Prozessors.
+ Diese können spezielle Namen haben (eax, ebx, al, rdi, ...)
+ oder ebenfalls durchnumeriert sein (r0, r1, ..., r24, ...).
+
+ Register "können mehr" und arbeiten schneller.
+ Es gibt mehr Befehle für die Adressierungsart "Register"
+ als für die Adressierungsart "Speicher".
+
+ Arbeitsspeicher (RAM) steht in größeren Mengen zur Verfügung.
+ Beispiel: IA-64 hat vielleicht 30 Register,
+ aber typischerweise mehrere GB an Arbeitsspeicher.
+
+ "absolut" bedeutet: Der Operand ist die Nummer der Speicherzelle.
+
+ Speicher relativ
+
+ "relativ" bedeutet: Der Operand ist die Nummer der Speicherzelle,
+ gezählt ab einer vorher bekannten Zahl.
+
+ Z.B. in Zusammenhang mit Sprungbefehlen:
+ "Springe um 5 Speicherzellen nach oben."
+
+ Zweck: Einfachere Relokation des Programms
+ (Das Programm ist lauffähig, egal wo es sich im Speicher befindet.)
+
+ Speicher indirekt
+
+ Beispiel: IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+
+ cmpb (%ebx), %dl
+ "Betrachte den Inhalt des ebx-Registers als Nummer einer Speicherzelle (Zeiger)
+ und vergleiche die 8-Bit-Zahl, die sich dort befindet, mit dem dl-Register."
+
+ movb (%ebx), %dl
+ "Betrachte den Inhalt des ebx-Registers als Nummer einer Speicherzelle (Zeiger)
+ und kopiere die 8-Bit-Zahl, die sich dort befindet, in das dl-Register."
+
+ addb %dl, (%ebx)
+ "Betrachte den Inhalt des ebx-Registers als Nummer einer Speicherzelle (Zeiger)
+ und addiere den Inhalt des dl-Registers zu der 8-Bit-Zahl, die sich dort befindet."
+
+ Beispiel: Redcode
+
+ mov -1, @-2
+
+ "Betrachte den Inhalt der Speicherzelle, die sich 2 weiter oben befindet,
+ als Nummer einer Speicherzelle (Zeiger)
+ und kopiere den Inhalt der Speicherzelle, die sich 1 weiter oben befindet, dorthin."
+
+Zusätzliche Manipulatoren
+
+ Prä-Dekrement:
+
+ Bevor der Befehl ausgeführt wird, subtrahiere eine Konstante von einem der Operanden.
+
+ Beispiel: Redcode
+
+ mov -1, <-2
+
+ 1. Prä-Dekrement:
+ "Subtrahiere 1 von der Speicherzelle, die sich 2 weiter oben befindet."
+ 2. mov-Befehl:
+ "Betrachte den Inhalt der Speicherzelle, die sich 2 weiter oben befindet,
+ als Nummer einer Speicherzelle (Zeiger)
+ und kopiere den Inhalt der Speicherzelle, die sich 1 weiter oben befindet, dorthin."
+
+ Analog: Prä-Inkrement, Post-Dekrement, Post-Inkrement
+
+Hardware-spezifische Befehle
+
+ Beispiel: IA-32 (Intel-Architektur, 32 Bit), AT&T-Syntax, GNU-Standard:
+
+ syscall
+
+ Rufe eine Funktion im Betriebssystemkern auf.
+
+ Beispiel: Redcode
+
+ spl 2
+
+ "Führe das Programm nicht nur in der folgenden Speicherzelle aus,
+ sondern auch in der genannten, hier also in der übernächsten.
+ Dadurch entstehen zwei Tasks (oder Threads), die sich die Rechenzeit teilen."
diff --git a/20220517/sk.red b/20220517/sk.red
new file mode 100644
index 0000000000000000000000000000000000000000..49af80506e241ac711230d52743a788ab1a4bc67
--- /dev/null
+++ b/20220517/sk.red
@@ -0,0 +1,8 @@
+;name SK
+;version 2
+;author Peter Gerwinski
+;assert 1
+
+ spl 2
+ jmp 0, <-50
+ mov 0, 1
diff --git a/20220517/test-01.red b/20220517/test-01.red
new file mode 100644
index 0000000000000000000000000000000000000000..1e26a54c48cbec4d33fdcbc64b9a0f8d497cada3
--- /dev/null
+++ b/20220517/test-01.red
@@ -0,0 +1 @@
+mov -1, @-2
diff --git a/20220517/test-02.red b/20220517/test-02.red
new file mode 100644
index 0000000000000000000000000000000000000000..26bdb83e474bc3e3ff41289507211ae5b2b34e43
--- /dev/null
+++ b/20220517/test-02.red
@@ -0,0 +1,9 @@
+ dat -3
+ dat -2
+ dat -1
+start mov -1, @-2
+ dat 1
+ dat 2
+ dat 3
+
+ end start
diff --git a/20220517/test-03.red b/20220517/test-03.red
new file mode 100644
index 0000000000000000000000000000000000000000..f6a3e947bcd7f310a91f8e2d9461909b5fece1eb
--- /dev/null
+++ b/20220517/test-03.red
@@ -0,0 +1,10 @@
+ dat -3
+ dat -2
+ dat -1
+start mov -1, @-2
+ jmp start
+ dat 1
+ dat 2
+ dat 3
+
+ end start
diff --git a/20220517/test-04.red b/20220517/test-04.red
new file mode 100644
index 0000000000000000000000000000000000000000..16e568b3f6c8953e8fa7059c7bac24307169bc72
--- /dev/null
+++ b/20220517/test-04.red
@@ -0,0 +1,10 @@
+ dat -3
+ dat -2
+ dat -1
+start mov -1, <-2
+ jmp start
+ dat 1
+ dat 2
+ dat 3
+
+ end start
diff --git a/20220517/test-05.red b/20220517/test-05.red
new file mode 100644
index 0000000000000000000000000000000000000000..7367de9554af8efbeca5541ad4af7eb2c22ce959
--- /dev/null
+++ b/20220517/test-05.red
@@ -0,0 +1,12 @@
+ dat -3
+ dat -2
+ dat -1
+start spl 3
+loop mov -1, <-3
+ jmp loop
+ mov 0, 1
+ dat 1
+ dat 2
+ dat 3
+
+ end start