diff --git a/20230517/functions-01-O3.s b/20230517/functions-01-O3.s
new file mode 100644
index 0000000000000000000000000000000000000000..24383d1b4cabc383c8e0cf574ddb9a423c3cc23c
--- /dev/null
+++ b/20230517/functions-01-O3.s
@@ -0,0 +1,38 @@
+	.file	"functions-01.c"
+	.text
+	.p2align 4,,15
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	leal	(%rdi,%rsi), %eax
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.1,"aMS",@progbits,1
+.LC0:
+	.string	"c = %d\n"
+	.section	.text.startup,"ax",@progbits
+	.p2align 4,,15
+	.globl	main
+	.type	main, @function
+main:                                               ; #include <stdio.h>
+.LFB12:                                             ; 
+	.cfi_startproc                              ; int sum (int a, int b)
+	subq	$8, %rsp                            ; {
+	.cfi_def_cfa_offset 16                      ;   return a + b;
+	movl	$10, %esi                           ; }
+	leaq	.LC0(%rip), %rdi                    ; 
+	xorl	%eax, %eax                          ; int main (void)
+	call	printf@PLT                          ; {
+	xorl	%eax, %eax                          ;   int c = sum (3, 7);
+	addq	$8, %rsp                            ;   printf ("c = %d\n", c);
+	.cfi_def_cfa_offset 8                       ;   return 0;
+	ret                                         ; }
+	.cfi_endproc
+.LFE12:
+	.size	main, .-main
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230517/functions-01.c b/20230517/functions-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..ee59b3fafaf0801c6249fc4039530b3a1c54b1b6
--- /dev/null
+++ b/20230517/functions-01.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int sum (int a, int b)
+{
+  return a + b;
+}
+
+int main (void)
+{
+  int c = sum (3, 7);
+  printf ("c = %d\n", c);
+  return 0;
+}
diff --git a/20230517/functions-01.s b/20230517/functions-01.s
new file mode 100644
index 0000000000000000000000000000000000000000..2604b090a2e777632aa2331bc9360e207473ec19
--- /dev/null
+++ b/20230517/functions-01.s
@@ -0,0 +1,56 @@
+	.file	"functions-01.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	movl	%edi, -4(%rbp)
+	movl	%esi, -8(%rbp)
+	movl	-4(%rbp), %edx
+	movl	-8(%rbp), %eax
+	addl	%edx, %eax
+	popq	%rbp
+	.cfi_def_cfa 7, 8                               ; #include <stdio.h>
+	ret                                             ; 
+	.cfi_endproc                                    ; int sum (int a, int b)
+.LFE0:                                                  ; {
+	.size	sum, .-sum                              ;   return a + b;
+	.section	.rodata                         ; }
+.LC0:                                                   ; 
+	.string	"c = %d\n"                              ; int main (void)
+	.text                                           ; {
+	.globl	main                                    ;   int c = sum (3, 7);
+	.type	main, @function                         ;   printf ("c = %d\n", c);
+main:                                                   ;   return 0;
+.LFB1:                                                  ; }
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	subq	$16, %rsp
+	movl	$7, %esi
+	movl	$3, %edi
+	call	sum
+	movl	%eax, -4(%rbp)
+	movl	-4(%rbp), %eax
+	movl	%eax, %esi
+	leaq	.LC0(%rip), %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %eax
+	leave
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE1:
+	.size	main, .-main
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230517/logo-hochschule-bochum-cvh-text-v2.pdf b/20230517/logo-hochschule-bochum-cvh-text-v2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8
--- /dev/null
+++ b/20230517/logo-hochschule-bochum-cvh-text-v2.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
diff --git a/20230517/logo-hochschule-bochum.pdf b/20230517/logo-hochschule-bochum.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1
--- /dev/null
+++ b/20230517/logo-hochschule-bochum.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20230517/pgslides.sty b/20230517/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64
--- /dev/null
+++ b/20230517/pgslides.sty
@@ -0,0 +1 @@
+../common/pgslides.sty
\ No newline at end of file
diff --git a/20230517/rtech-20230517.pdf b/20230517/rtech-20230517.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..4745240253be6ca10e88b4de2cde2b6fdf961695
Binary files /dev/null and b/20230517/rtech-20230517.pdf differ
diff --git a/20230517/rtech-20230517.tex b/20230517/rtech-20230517.tex
new file mode 100644
index 0000000000000000000000000000000000000000..31035b20a80b504ee8c41c894085326ea63988bb
--- /dev/null
+++ b/20230517/rtech-20230517.tex
@@ -0,0 +1,1081 @@
+% rtech-20230517.pdf - Lecture Slides on Computer Technology
+% Copyright (C) 2012, 2013, 2014, 2021, 2022, 2023  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or 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 document 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 document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: Assembler-Programmierung: Redcode (Fortsetzung)
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{pdftricks}
+%\usepackage[obeyfamily=false,mathrm=mathsf,textrm=sffamily]{siunitx}
+%\usepackage{eurosym}
+\usepackage{tikz}
+
+\newcommand{\Cin}{C\raisebox{-0.5ex}{\footnotesize in}}
+\newcommand{\Cout}{C\raisebox{-0.5ex}{\footnotesize out}}
+
+\lstdefinestyle{asm}{basicstyle=\color{structure},
+                     language={},
+                     gobble=4}
+
+\begin{psinputs}
+  \usepackage[utf8]{inputenc}
+  \usepackage[german]{babel}
+  \usepackage[T1]{fontenc}
+  \usepackage{helvet}
+  \renewcommand*\familydefault{\sfdefault}
+  \usepackage{pstricks,pst-grad,pst-circ-pg}
+  \newcommand{\invisible}{\tiny\color{white}}
+  \psset{unit=1cm}
+  \psset{logicLabelstyle=\invisible}
+  \newcommand{\logicSymbol}{\small\boldmath\bf\rule{0pt}{0.5cm}}
+  \psset{logicSymbolstyle=\logicSymbol}
+  \newcommand{\Cin}{C\raisebox{-0.5ex}{\footnotesize in}}
+  \newcommand{\Cout}{C\raisebox{-0.5ex}{\footnotesize out}}
+\end{psinputs}
+
+\title{Rechnertechnik}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{17.\ Mai 2022}
+
+\begin{document}
+
+\maketitleframe
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+    \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer}
+    \item[\textbf{3}] \textbf{Assember-Programmierung}
+      \begin{itemize}
+        \color{medgreen}
+        \item[3.1] Struktur von Assembler-Programmen
+        \item[3.2] Beispiel: Redcode
+        \item[\dots]
+      \end{itemize}
+%    \color{gray}
+%    \item[\textbf{3}] \textbf{Architekturmerkmale von Prozessoren}
+%    \item[\textbf{4}] \textbf{Der CPU-Stack}
+%    \item[\textbf{5}] \textbf{Hardwarenahe Programmierung}
+%    \item[\textbf{6}] \textbf{Anwender-Software}
+%    \item[\textbf{7}] \textbf{Bus-Systeme}
+%    \item[\textbf{8}] \textbf{Pipelining}
+%    \item[\textbf{9}] \textbf{Ausblick}
+    \item[\textbf{\dots\hspace{-0.75em}}]
+  \end{itemize}
+
+\end{frame}
+
+\setcounter{section}{2}
+\section{Assembler-Programmierung}
+\subsection{Struktur von Assembler-Programmen}
+
+\begin{frame}
+  \showsection
+  \showsubsection
+
+  \textbf{Maschinensprache:} Bits besagen, was in diesem Takt geschehen soll
+
+  \begin{itemize}
+    \item
+      \textbf{arithmetisch-logische Befehle:}\\[\smallskipamount]
+      Daten aus Registern (oder Hauptspeicher) an ALU legen,\\
+      Ergebnis in Register (oder Hauptspeicher) schreiben
+    \item
+      \textbf{Lade- und Speicher-Befehle:}\\[\smallskipamount]
+      Daten aus dem Hauptspeicher in Register einlesen\\
+      oder aus Register in den Hauptspeicher schreiben
+    \item
+      \textbf{(unbedingter) Sprungbefehl:}\\[\smallskipamount]
+      Daten aus Register oder Hauptspeicher in das \lstinline{IP}-Register laden
+    \item
+      \textbf{(bedingter) Sprungbefehl:}\\[\smallskipamount]
+      Sprungbefehl nur dann, wenn im Status-Ausgang der ALU\\
+      ein bestimmtes Bit gesetzt ist
+    \bigskip
+    \arrowitem
+      Der Computer kann "`alles"' -- \newterm{Turing-Vollständigkeit}
+  \end{itemize}
+\end{frame}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \textbf{Maschinensprache:} Bits besagen, was in diesem Takt geschehen soll
+  \begin{itemize}
+    \item
+      Lade- und Speicher-Befehle\\
+      arithmetisch-logische Befehle\\
+      unbedingte und bedingte Sprungbefehle
+    \arrowitem
+      Der Computer kann "`alles"' -- \newterm{Turing-Vollständigkeit}
+  \end{itemize}
+
+  \medskip
+
+  \textbf{\newterm{Assembler\/}-Sprache}
+  \begin{itemize}
+    \item
+      Maschinensprache = Zahlen \textarrow\ für Menschen schwer handhabbar
+    \arrowitem
+      Namen für die Befehle: \newterm{Mnemonics}
+  \end{itemize}
+
+%  \pause
+  \medskip
+
+  \textbf{Beispiele}
+  \begin{itemize}
+    \item
+      Intel 8086 \textcolor{red}{(emulierter 16-Bit-Rechner)}
+    \item
+      Atmel AVR \textcolor{red}{(Arduino, 8 Bit)}
+    \item
+      Intel IA-32 / AMD64 \textcolor{red}{(Notebook-PC, 64 Bit)}
+    \item
+      Redcode \textcolor{red}{(emulierter Rechner, Praktikumsversuch)}
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel: IA-32-Assembler
+  \only<1>{-- \newterm{Befehl (Opcode)}}%
+  \only<2>{-- \newterm{Befehl (Opcode)} und \newterm{Operanden}}%
+  \only<3>{-- \newterm{Adressierungsarten}}
+
+  \vspace{2cm}
+
+  \begin{lstlisting}
+    addl    $1, %eax
+    movb    %al, b
+    cmpb    (%ebx), %dl
+    jbe     .L2
+  \end{lstlisting}
+
+  \begin{onlyenv}<1-2>
+    \begin{picture}(0,0)
+      \color{red}
+      \put(0.4,2.8){\vector(0,-1){0.7}}
+      \put(0.4,2.9){\makebox(0,0)[b]{Befehl}}
+      \only<1>{%
+        \put(1.4,2.8){\vector(-1,-1){0.7}}
+        \put(2.3,2.9){\makebox(0,0)[b]{Größen-Suffix}}}
+      \only<2>{%
+        \put(1.4,2.8){\vector(-1,-2){0.35}}
+        \put(1.4,2.8){\vector(1,-2){0.35}}
+        \put(2.0,2.9){\makebox(0,0)[b]{Operanden}}}
+    \end{picture}
+  \end{onlyenv}
+  \begin{onlyenv}<3>
+    \begin{picture}(0,0)
+      \color{red}
+      \put(1.4,2.8){\vector(-1,-2){0.35}}
+      \put(2.0,2.9){\makebox(0,0)[b]{unmittelbar}}
+      \put(3.0,1.8){\vector(-1,0){0.7}}
+      \put(3.1,1.8){\makebox(0,0)[l]{Register}}
+      \put(4.8,1.4){\vector(-1,0){2.7}}
+      \put(4.9,1.4){\makebox(0,0)[l]{Speicher (absolut)}}
+      \put(2.3,-0.0){\vector(-1,1){0.7}}
+      \put(3.5,-0.1){\makebox(0,0)[t]{indirekt mit Register}}
+      \put(0.8,-0.6){\vector(0,1){0.9}}
+      \put(0.0,-0.7){\makebox(0,0)[tl]{Speicher (relativ)}}
+    \end{picture}
+  \end{onlyenv}
+
+\end{frame}
+
+\subsection{Beispiel: Redcode}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel: Redcode (ICWS '86) -- Core War[s] (Krieg der Kerne)\\
+  Virtuelle Maschine: Memory Array Redcode Simulator (MARS)
+
+  \bigskip
+
+  \begin{minipage}[t]{7.2cm}
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B} -- Daten \only<1->{-- "`Du hast verloren!"'}\\
+    \lstinline{mov A, B} -- kopiere A nach B\\
+    \lstinline{add A, B} -- addiere A zu B\\
+    \lstinline{sub A, B} -- subtrahiere A von B\\
+    \lstinline{jmp A} -- unbedingter Sprung nach A\\
+    \lstinline{jmz A, B} -- Sprung nach A, wenn B $=$ 0\\
+    \lstinline{jmn A, B} -- Sprung nach A, wenn B $\ne$ 0\\
+    \lstinline{djn A, B} -- "`decrement and jump if not zero"'\\
+    \lstinline{cmp A, B} -- "`compare"': überspringe, falls gleich\\
+    \lstinline{spl A} -- "`split"': Programm verzweigen
+  \end{minipage}\hfill
+  \begin{minipage}[t]{4.7cm}
+    Adressierungsarten:\\[\smallskipamount]
+    grundsätzlich: Speicher relativ\\[\smallskipamount]
+    \lstinline{#} -- unmittelbar\\
+    \lstinline{$} -- direkt\\
+    \lstinline{@} -- indirekt\\
+    \lstinline{<} -- indirekt mit Prä-Dekrement
+
+%    \pause[5]
+    \bigskip
+    Programm "`Nothing"':
+    \begin{lstlisting}[gobble=6]
+      jmp 0
+    \end{lstlisting}
+%    \pause
+    \bigskip
+    Programm "`Knirps"':
+    \begin{lstlisting}[gobble=6]
+      mov 0, 1
+    \end{lstlisting}
+    \smallskip
+    \textcolor{red}{Wie schreibt man\\knirpsresistente Programme?}
+
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Unbedingte Verzweigung
+
+  Beispiel: Endlosschleife von "`Dwarf"'
+
+  \begin{minipage}[t]{1.2cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      bomb
+      start
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      dat #0
+      add #4, bomb
+      mov bomb, @bomb
+      jmp start
+      end start
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+%  \pause
+  \bigskip
+
+  Problem: Wenn die Speichergröße nicht durch 4 teilbar ist,\\
+  \phantom{Problem: }bringt "`Dwarf"' sich selbst zum Absturz.\\[\smallskipamount]
+%  \pause
+  Lösung: \textcolor{red}{Haben Sie Ideen?}
+  \textcolor{red}{\textarrow\ Übungsaufgabe}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \alt<2->{Mehrere Threads}{Bedingte Verzweigung}
+
+  Beispiel: \alt<2->{Multithreading}{Kopierschleife} von "`Mice"'
+
+  \begin{minipage}[t]{1.2cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      ptr
+      start
+      loop
+
+
+
+
+      dest
+
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      dat              #0
+      mov     #12,     ptr
+      mov     @ptr,    <dest
+      djn     loop,    ptr
+      spl     @dest
+      add     #653,    dest
+      jmz     start,   ptr
+      dat              #833
+      end start
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+  \pause[3]
+  \bigskip
+
+  Gegenmaßnahme: "`Zeitfalle"'\\
+  \textarrow\ Programm "`Catcan"'
+
+%  \smallskip
+%
+%  Problem: Wenn die Speichergröße nicht durch 8 teilbar ist,\\
+%  \phantom{Problem: }bringt "`Catcan"' sich selbst zum Absturz.
+
+\end{frame}
+
+\iffalse
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Selbstmodifizierender Code
+
+  Beispiel: Selbsterkennung von "`Fini"'
+
+  \begin{minipage}[t]{1.2cm}
+    \begin{lstlisting}[language={},gobble=6]
+      num
+      start
+
+      pos
+
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{0.9cm}
+    \begin{lstlisting}[language={},gobble=6]
+      dat #-2
+      mov num, <pos
+      jmp start
+      dat #-3
+      end start
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+\end{frame}
+
+\fi
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \strut
+ 
+  \strut\makebox(0,0)[bl]{\large\color{structure}\textbf{Praktikumsversuch}}
+
+  \begin{minipage}[t]{5cm}
+    \medskip
+    Schreiben Sie ein\\
+    Redcode-Programm,\\
+    das die Gegner\\
+    \file{Nothing}, \file{Knirps}\\
+    und \file{Mice} besiegt.
+
+    \medskip
+
+    ICWS-86-Standard,\\
+    max.\ 64 Prozesse,\\
+    Speichergröße zufällig\\
+    von 512 bis 8192
+
+    \medskip
+
+    Teams bis zu 3 Personen\\
+    sind zulässig.
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+\end{frame}
+
+\subsection{Architekturmerkmale von Prozessoren}
+\subsubsection{Speicherarchitekturen}
+
+\begin{frame}
+
+  \showsubsection
+
+  Oder: Jede Assembler-Sprache ist anders.
+
+  \bigskip
+
+  \showsubsubsection
+
+  Bezeichnungen
+  \begin{itemize}
+    \item
+      \newterm{Bit\/} = 0 oder 1 -- kleinste Einheit an Information
+    \item
+      \newterm{Byte\/} = Zusammenfassung mehrerer \newterm{Bits}\\
+      zu einer Binärzahl, die ein Zeichen (\newterm{Character\/}) darstellen kann,\\
+      häufig 8 Bits (\newterm{Oktett\/})
+    \item
+      \newterm{Speicherwort\/} = Zusammenfassung mehrerer Bits\\
+      zu der kleinsten adressierbaren Einheit, häufig 1 Byte
+    \item
+      \newterm{RAM\/} = \newterm{Random Access Memory\/} = Hauptspeicher
+    \item
+      \newterm{ROM\/} = \newterm{Read Only Memory\/} = nur lesbarer Speicher
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsection
+
+  Verschiedene Arten von Speicher
+  \begin{itemize}
+    \item
+      \newterm{Prozessor-Register}\\
+      können direkt mit ALU verbunden werden,\\
+      besonders schnell (Flipflops),\\
+      überschaubare Anzahl von Registern
+    \item
+      \newterm{Hauptspeicher}\\
+      kann direkt adressiert und mit Prozessor-Registern abgeglichen werden,\\
+      heute i.\,d.\,R.\ dynamischer Speicher (Kondensatoren)
+    \item
+      \newterm{I/O-Ports}\\
+      sind spezielle Speicheradressen, über die\\
+      mit externen Geräten kommuniziert wird
+    \item
+      \newterm{Massenspeicher}\\
+      liegt auf externem Gerät, wird über I/O-Ports angesprochen,\\
+      Festplatte, Flash-Speicher, \dots
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsubsection
+
+  \begin{itemize}
+    \item
+      \newterm{Von-Neumann-Architektur}\\
+      Es gibt nur 1 Hauptspeicher, in dem sich sowohl die Befehle\\
+      als auch die Daten befinden.
+
+      \begin{onlyenv}<1>
+        \smallskip
+
+        Vorteil: Flexibilität in der Speichernutzung
+
+        Nachteil: Befehle können überschrieben werden.\\
+        $\longrightarrow$ Abstürze und Malware möglich
+      \end{onlyenv}
+
+    \pause
+    \item
+      \newterm{Harvard-Architektur}\\
+      Es gibt 2 Hauptspeicher. In einem befinden sich die Befehle,\\
+      im anderen die Daten.
+
+      \begin{onlyenv}<2>
+        \smallskip
+
+        Vorteil: Befehle können nicht überschrieben werden\\
+        $\longrightarrow$ sicherer als Von-Neumann-Architektur
+
+        Nachteile: Leitungen zum Speicher (Bus) müssen doppelt vorhanden sein,\\
+        freier Befehlsspeicher kann nicht für Daten genutzt werden.
+      \end{onlyenv}
+
+    \pause
+    \item
+      Weitere Kombinationen\\
+      Hauptspeicher und I/O-Ports gemeinsam oder getrennt,\\
+      Hauptspeicher und Prozessorregister gemeinsam oder getrennt
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsubsection
+
+  Beispiele:
+  \begin{itemize}
+    \item
+      Intel IA-32, AMD64:\\
+      Von-Neumann-Architektur (plus Speicherschutzmechanismen),\\
+      Prozessorregister und I/O-Ports vom Hauptspeicher getrennt
+    \item
+      Atmel AVR (z.\,B.\ ATmega):\\
+      Harvard-Architektur (Befehlsspeicher als Flash-Speicher grundsätzlich auch schreibbar),\\
+      Prozessorregister und I/O-Ports in gemeinsamem Adressbereich mit Hauptspeicher
+    \item
+      6502, Renesas-Mikro-Controller:\\
+      Von-Neumann-Architektur,\\
+      I/O-Ports in gemeinsamem Adressbereich mit Hauptspeicher,\\
+      Prozessorregister und Hauptspeicher getrennt
+  \end{itemize}
+
+\end{frame}
+
+\subsubsection{Registerarchitekturen}
+
+\begin{frame}[fragile]
+
+  \showsubsubsection
+
+  \vspace*{-\medskipamount}
+
+  \begin{itemize}
+    \item
+      Mehrere Register, einzeln ansprechbar
+    \item
+      \newterm{Akkumulator\/}: Nur 1 Register kann rechnen.
+    \item
+      \newterm{Stack-Architektur\/}: Stapel, "`umgekehrte Polnische Notation"'
+  \end{itemize}
+
+  \pause
+
+  Operationen: typischerweise nur 
+  \lstinline{=}, \lstinline{+=}, \lstinline{-=}, \lstinline{*=}, \lstinline{/=}, \dots
+
+  \pause
+  \medskip
+
+  Beispiel: \lstinline{c = a + 2 * b;}
+
+  \pause
+  \medskip
+
+  \begin{minipage}[t]{2cm}
+    C, Java:\smallskip\par
+    \begin{lstlisting}[gobble=6]
+      R = b;
+      R *= 2;
+      R += a;
+      c = R;
+    \end{lstlisting}
+  \end{minipage}\pause
+  \begin{minipage}[t]{4cm}
+    Mehrere Register:\smallskip\par
+    \begin{lstlisting}[style=asm,gobble=6]
+      movl  (b), %eax
+      imull $2, %eax, %eax
+      addl  (a), %eax
+      movl  %eax, (c)
+    \end{lstlisting}
+    \smallskip\par
+    (IA-32-Assembler)
+  \end{minipage}\pause
+  \begin{minipage}[t]{3cm}
+    Akkumulator:\smallskip\par
+    \begin{lstlisting}[style=asm,gobble=6]
+      load  (b)
+      mul   $2
+      add   (a)
+      store (c)
+    \end{lstlisting}
+    \smallskip\par
+    (Pseudo-Assembler)
+  \end{minipage}\pause
+  \begin{minipage}[t]{3cm}
+    Register-Stack:\smallskip\par
+    \begin{lstlisting}[style=asm,gobble=6]
+      push  (a)
+      push  (b)
+      push  $2
+      mul
+      add
+      pop   (c)
+    \end{lstlisting}
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsubsection
+
+  Beispiele:
+  \begin{itemize}
+    \item
+      Intel IA-32, AMD64:\\
+      Mehrere Register, für verschiedene Zwecke spezialisiert (unübersichtlich),\\[\smallskipamount]
+      Fließkommaregister: Stack-Architektur
+    \item
+      Atmel AVR (z.\,B.\ ATmega):\\
+      32 Register
+    \item
+      6502, Renesas-Mikro-Controller:\\
+      3 Register: A, X, Y. Nur A kann rechnen $\longrightarrow$ Akkumulator
+    \item
+      Java Virtual Machine (JVM):\\
+      Stack-Architektur
+    \item
+      Redcode:\\
+      Jede Speicherzelle fungiert als Register
+  \end{itemize}
+
+\end{frame}
+
+\subsubsection{Befehlssätze}
+
+\begin{frame}
+
+  \showsubsubsection
+
+  \begin{itemize}
+    \item
+     \newterm{Reduced Instruction Set Computer (RISC)}
+
+      \smallskip
+
+      wenige, wenig mächtige Befehle
+
+      \begin{onlyenv}<1>
+        \textarrow\ Programmierung in Assembler für Menschen unkomfortabel\\
+        \textarrow\ schnelle Abarbeitung der Befehle
+
+        \medskip
+
+        Beispiel: Atmel AVR
+        \begin{itemize}
+          \item
+            Der ``load immediate''-Befehl funktioniert nur
+            für die Register 16 bis 31,\\
+            nicht für die Register 0 bis 15.
+          \item
+            Die meisten Befehle werden in nur 1 Taktzyklus abgearbeitet.
+        \end{itemize}
+
+        \medskip
+        
+        Beispiel: Redcode ICWS-86
+        \begin{itemize}
+          \item
+            Es gibt indirekte Adressierung mit Prä-Dekrement,\\
+            aber nicht mit Prä-Inkrement.
+          \item
+            Alle Befehle werden in nur 1 Taktzyklus abgearbeitet.
+        \end{itemize}
+      \end{onlyenv}
+ 
+    \pause
+    \medskip
+    \item
+      \newterm{Complex Instruction Set Computer (CISC)}
+
+      \smallskip
+
+      Umfangreiche Befehlssätze, mächtige Befehle
+
+      \begin{onlyenv}<2>
+        \textarrow\ komfortable manuelle Programmierung in Assembler\\
+        \textarrow\ längere Abarbeitungszeit der einzelnen Befehle
+
+        \smallskip
+
+        Realisierung: "`Prozessor im Prozessor"' -- \newterm{Mikroprogramme}
+
+        \medskip
+
+        Beispiel: Intel IA-32, AMD64
+        \begin{itemize}
+          \item
+            Es gibt spezielle Befehle für BCD- und String-Operationen.
+          \item
+            Befehle benötigen meistens 2 oder mehr,\\
+            gelegentlich (z.\,B.\ Fließkomma-Operationen) auch über 100 Taktzyklen.
+        \end{itemize}
+      \end{onlyenv}
+
+    \medskip
+    \pause
+    \item
+      \newterm{Very Long Instruction Word (VLIW)\/} und\\
+      \newterm{Explicitly Parallel Instruction Computing (EPIC)}
+
+      \smallskip
+
+      mehrere Befehle gleichzeitig ausführbar
+
+      \begin{onlyenv}<3>
+        \textarrow\ mehr Rechenleistung möglich\\
+        \textarrow\ Programmierung sehr aufwendig
+
+        \medskip
+
+        Beispiel: Intel IA-64
+      \end{onlyenv}
+
+    \pause
+    \medskip
+    \item
+      \newterm{Orthogonaler Befehlssatz}
+
+      \smallskip
+
+      Jeder Befehl ist mit jeder Adressierungsart kombinierbar.
+
+      \medskip
+
+      Beispiel: Redcode
+  \end{itemize}
+  \vspace*{-4cm}
+
+\end{frame}
+
+\subsection{Der CPU-Stack\label{CPU-Stack}}
+\addtocounter{subsection}{-1}
+\subsubsection{Was ist ein Stack?}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+  \showsubsubsection
+
+  \bigskip
+
+\iffalse
+
+  \begin{minipage}[b]{6cm}
+    \begin{center}
+      "`First In -- First Out"'
+
+      \bigskip
+
+      \begin{picture}(6,4)
+        \thicklines
+        \color{structure}
+        \put(0.5,0){\line(1,0){5}}
+
+        \put(3.5,0){\only<1-5>{\line(0,1){1}}}
+        \put(4.5,0){\only<1-4>{\line(0,1){1}}}
+        \put(3.5,1){\only<1-4>{\line(1,0){1}}}
+        \put(4.0,0.5){\only<1-4>{\makebox(0,0){\lstinline{3}}}}
+        \put(3.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
+        \put(3.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
+
+        \put(2.5,0){\only<2-6>{\line(0,1){1}}}
+        \put(2.5,1){\only<2-5>{\line(1,0){1}}}
+        \put(3.0,0.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
+        \put(2.0,1.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
+        \put(2.0,1.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
+
+        \put(1.5,0){\only<3-6>{\line(0,1){1}}}
+        \put(1.5,1){\only<3-6>{\line(1,0){1}}}
+        \put(2.0,0.5){\only<3-6>{\makebox(0,0){\lstinline{137}}}}
+        \put(1.0,1.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
+        \put(1.0,1.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
+
+        \put(4.55,1.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
+        \put(5.00,1.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
+
+        \put(3.55,1.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
+        \put(4.00,1.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
+
+        \put(2.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
+        \put(3.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
+      \end{picture}
+
+      \bigskip
+
+      FIFO = Queue = Reihe
+    \end{center}
+  \end{minipage}\hfill
+
+\fi
+
+  \begin{minipage}[b]{6cm}
+    \begin{center}
+      "`Last In -- First Out"'
+
+      \bigskip
+
+      \begin{picture}(6,4)
+        \thicklines
+        \color{structure}
+        \put(1.5,0){\line(1,0){3}}
+
+        \put(2.5,0){\line(0,1){1}}
+        \put(3.5,0){\line(0,1){1}}
+        \put(2.5,1){\line(1,0){1}}
+        \put(3.0,0.5){\makebox(0,0){\lstinline{3}}}
+        \put(2.0,1.5){\only<1>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
+        \put(2.0,1.5){\only<1>{\makebox(0,0)[b]{\lstinline{push (3)}}}}
+
+        \put(2.5,1){\only<2-5>{\line(0,1){1}}}
+        \put(3.5,1){\only<2-5>{\line(0,1){1}}}
+        \put(2.5,2){\only<2-5>{\line(1,0){1}}}
+        \put(3.0,1.5){\only<2-5>{\makebox(0,0){\lstinline{7}}}}
+        \put(2.0,2.5){\only<2>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
+        \put(2.0,2.5){\only<2>{\makebox(0,0)[b]{\lstinline{push (7)}}}}
+
+        \put(2.5,2){\only<3-4>{\line(0,1){1}}}
+        \put(3.5,2){\only<3-4>{\line(0,1){1}}}
+        \put(2.5,3){\only<3-4>{\line(1,0){1}}}
+        \put(3.0,2.5){\only<3-4>{\makebox(0,0){\lstinline{137}}}}
+        \put(2.0,3.5){\only<3>{\makebox(0,0)[tl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,-0.45);}}}}
+        \put(2.0,3.5){\only<3>{\makebox(0,0)[b]{\lstinline{push (137)}}}}
+
+        \put(3.55,3.05){\only<4>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
+        \put(4.00,3.60){\only<4>{\makebox(0,0)[b]{\lstinline{pop ()}: 137}}}
+
+        \put(3.55,2.05){\only<5>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
+        \put(4.00,2.60){\only<5>{\makebox(0,0)[b]{\lstinline{pop ()}: 7}}}
+
+        \put(3.55,1.05){\only<6>{\makebox(0,0)[bl]{\tikz{\draw[-latex, line width=1pt](0,0)--(0.45,0.45);}}}}
+        \put(4.00,1.60){\only<6>{\makebox(0,0)[b]{\lstinline{pop ()}: 3}}}
+      \end{picture}
+
+      \bigskip
+
+      LIFO = Stack = Stapel
+    \end{center}
+  \end{minipage}
+
+%
+%  \dots
+
+\end{frame}
+\subsubsection{Implementierung}
+
+\begin{frame}
+
+  \showsubsection
+  \showsubsubsection
+
+  Speicher, in dem Werte "`gestapelt"' werden: \newterm{Stack}
+
+  \begin{itemize}
+    \item
+      Speicherbereich (ein array) reservieren
+    \item
+      Variable (typischerweise: Prozessorregister) als
+      \newterm{Stack Pointer\/} reservieren \textarrow\ \lstinline{SP}
+    \item
+      Assembler-Befehl \lstinline[style=asm]{push foo}: \quad
+      \lstinline{*SP++ = foo;}
+      \begin{itemize}
+        \item
+          In der Speicherzelle,
+          auf die der Stack Pointer \lstinline{SP} gerade zeigt,\\
+          den Wert \lstinline{foo} speichern.
+        \item
+          Danach den Stack Pointer inkrementieren (um 1 erhöhen).
+      \end{itemize}
+    \item
+      Assembler-Befehl \lstinline[style=asm]{pop bar}: \quad
+      \lstinline{bar = *--SP;}
+      \begin{itemize}
+        \item
+          Zuerst den Stack Pointer dekrementieren (um 1 erniedrigen).
+        \item
+          Danach aus der Speicherzelle,\\
+          auf die der Stack Pointer \lstinline{SP} gerade zeigt,\\
+          einen Wert lesen und in der Variablen \lstinline{bar} speichern.
+      \end{itemize}
+  \end{itemize}
+
+  \pause
+  \medskip
+  Speziell: Unterprogramme
+
+\end{frame}
+
+\subsubsection{Unterprogramme}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+  \showsubsubsection
+
+  \begin{minipage}[t]{4.5cm}
+    Parameter:
+    \begin{itemize}
+      \item
+        Prozessorregister
+      \item
+        CPU-Stack
+    \end{itemize}
+
+    \smallskip
+
+    Rückgabewert:
+    \begin{itemize}
+      \item
+        Prozessorregister
+    \end{itemize}
+  \end{minipage}%
+  \begin{minipage}[t]{5cm}
+    Aufruf:
+    \begin{itemize}
+      \item
+        \lstinline[style=asm]{push IP}\\
+        \lstinline[style=asm]{jmp foo}
+        {\color{red}\boldmath $\longleftarrow$ mov \#foo IP}\\
+        \textarrow\ \lstinline[style=asm]{call foo}
+    \end{itemize}
+    Rücksprung:
+    \begin{itemize}
+      \item
+        \lstinline[style=asm]{pop IP}\\
+        \textarrow\ \lstinline[style=asm]{ret}
+    \end{itemize}
+  \end{minipage}
+
+\end{frame}
+
+\iffalse
+
+\subsubsection{Register sichern}
+
+\begin{frame}
+
+  \showsubsection
+  \showsubsubsection
+
+  Ein Unterprogramm verändert Registerinhalte.
+  \begin{itemize}
+    \item
+      im Hauptprogramm nötigenfalls vor Aufruf sichern
+    \item
+      im Unterprogramm vor Benutzung sichern
+    \item
+      Kombinationen (manche Register so, manche so)
+  \end{itemize}
+
+\end{frame}
+
+\fi
+
+\end{document}
diff --git a/20230517/rtech-20230517.txt b/20230517/rtech-20230517.txt
new file mode 100644
index 0000000000000000000000000000000000000000..13efd31ab2cbcfbbe17eeeb8b2af37e69a12976a
--- /dev/null
+++ b/20230517/rtech-20230517.txt
@@ -0,0 +1,10 @@
+Binär codiertes Dezimalsystem (BCD), 17.05.2023, 11:27:10
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Speicherzellen (hexadezimal): 0123
+--> dezimal: 1 · 256 + 2 · 16 + 3 = 291
+
+komfortabler zum Lesen: Interpretation als Dezimalzahl 123
+--> Jede Hex-Ziffer wird als Dezimalziffer interpretiert.
+--> bequem zu lesen (im Debugger)
+    bequem für die Ausgabe (z.B. beim Drucken)