diff --git a/20220426/rtech-20220426.pdf b/20220426/rtech-20220426.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..e9ccb0f1836d17a4b6c172f8b5eea0bc81c5ce4c
Binary files /dev/null and b/20220426/rtech-20220426.pdf differ
diff --git a/20220426/rtech-20220426.tex b/20220426/rtech-20220426.tex
new file mode 100644
index 0000000000000000000000000000000000000000..6c5a25fba81c3fc89877507c7d65d02ffc2657ba
--- /dev/null
+++ b/20220426/rtech-20220426.tex
@@ -0,0 +1,1016 @@
+% rtech-20220426.pdf - Lecture Slides on Computer Technology
+% Copyright (C) 2012, 2013, 2014, 2021, 2022  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: Struktur von Assembler-Programmen
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{pdftricks}
+%\usepackage[obeyfamily=false,mathrm=mathsf,textrm=sffamily]{siunitx}
+%\usepackage{eurosym}
+
+\newrgbcolor{orange}{0.7 0.2 0.0}
+
+\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[latin1]{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{26.\ April 2022}
+
+\begin{document}
+
+\maketitleframe
+
+\sectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \showsectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+    \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer}
+      \begin{itemize}
+        \item[2.1] Logik-Schaltkreise
+        \item[2.2] Binärdarstellung von Zahlen
+        \item[2.3] Vom Logik-Schaltkreis zum Addierer
+        \item[2.4] Negative Zahlen
+        \color{medgreen}
+        \item[2.5] Vom Addierer zum Computer
+        \color{orange}
+        \item[2.6] Computer-Sprachen
+        \color{red}
+        \item[2.7] Struktur von Assembler-Programmen
+      \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{\dots\hspace{-0.75em}}]
+%    \item[\textbf{9}] \textbf{Ausblick}
+  \end{itemize}
+
+\end{frame}
+
+\setcounter{section}{1}
+\section{Vom Schaltkreis zum Computer}
+\setcounter{subsection}{4}
+\subsection{Vom Addierer zum Computer}
+
+\begin{frame}
+
+  \showsubsection
+
+  Schaltkreis, der wahlweise eine von mehreren Verknüpfungen
+  durchführt:
+
+  \smallskip
+
+  \newterm{arithmetisch-logische Einheit\/} --
+  \newterm{arithmetic logic unit (ALU)}
+
+  \bigskip
+  
+  \begin{center}
+    \vspace*{-2.5cm}
+    \includegraphics{alu2.pdf}
+    \vspace*{-23cm}
+  \end{center}
+
+  \bigskip
+
+  Siehe z.\,B.: \url{https://en.wikipedia.org/wiki/File:74181aluschematic.png}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \begin{visibleenv}<2->
+    \showsubsection
+
+    Information speichern
+  \end{visibleenv}
+
+  \begin{pdfpic}
+    \newcommand{\invisible}{\tiny\color{white}}
+    \psset{logicLabelstyle=\invisible}
+    \newcommand{\logicSymbol}{\small\boldmath\bf\rule{0pt}{0.5cm}}
+    \psset{logicSymbolstyle=\logicSymbol}
+    \psset{unit=0.6cm}
+    \psset{linewidth=0.03}
+    \begin{pspicture}(-3,-2)(3,2)
+      \pnode(-1,1.5){A}
+      \uput[l](-2.5,0|A){$S$}
+      \pnode(1,1.5){B}
+      \ground[connectingdot=false](2,1.5)
+      \relais(A)(B){}
+      \pnode(2.5,2.5){A3}
+      \uput[l](2.0,0|A3){$R$}
+      \pnode(4.5,2.5){B3}
+      \ground[connectingdot=false](5.5,2.5)
+      \relais(A3)(B3){}
+      \pnode(-0.5,0){C0}
+      \psline[arrows=-*](C0)(-1.5,0)(-1.5,1.5)
+      \pnode(0.5,0.3){D0}
+      \pnode(0.5,-0.3){E0}
+      \pnode(3,-0.3){C3}
+      \pnode(4,0){D3}
+      \pnode(4,-0.6){E3}
+      \psline[arrows=*-,linewidth=2\pslinewidth](C3)(D3)
+      \pnode(7,0.7){D3plus}
+      \uput[180](D3plus){\textbf{+}}
+      \psline(E0)(C3)
+      \psline[arrows=->,arrowsize=0.3](D3)(D3plus|D3)(D3plus)
+      \psline[arrows=*-,linewidth=2\pslinewidth](C0)(D0)
+      \pnode(-0.5,-1.5){C1}
+      \pnode(0.5,-1.2){D1}
+      \pnode(0.5,-1.8){E1}
+      \uput[r](2.5,0|E1){$Q$}
+      \pnode(-3.0,-0.5){C1plus}
+      \uput[180](C1plus){\textbf{+}}
+      \psline[arrows=->,arrowsize=0.3](C1)(C1plus|C1)(C1plus)
+      \psline[arrows=*-,linewidth=2\pslinewidth](C1)(D1)
+      \psline[linestyle=dashed](0,-1.25)(0,1.0)
+      \psline[linestyle=dashed](3.5,-0.15)(3.5,2.0)
+      \psline[arrows=o-](-2.5,0|A)(A)
+      \psline[arrows=o-](2.0,0|A3)(A3)
+      \psline(B)(2,0|B)
+      \psline(B3)(5.5|B3)
+      \psline[arrows=o-](1.5,0|D0)(D0)
+      \psline[arrows=o-](1.5,0|D1)(D1)
+      \psline[arrows=o-](2.5,0|E1)(E1)
+      \psline[arrows=o-](5.0,0|E3)(E3)
+    \end{pspicture}
+  \end{pdfpic}
+
+  \pause
+
+  \newterm{Selbsthalteschaltung}
+
+  1-Bit-\newterm{Speicherzelle}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Information speichern
+
+  \begin{pdfpic}
+    \psset{unit=0.6cm}
+    \psset{linewidth=0.03}
+    \begin{pspicture}(-4,-4)(4,4)
+      \logic[logicType=nand](-0.75,2){nand1}
+      \logic[logicType=nand](-0.75,-2){nand2}
+      \psline[arrows=o-](-3,0|nand12)(nand12)
+      \uput[180](-3,0|nand12){$\overline{\mbox{S}}$}
+      \psline[arrows=o-](-3,0|nand21)(nand21)
+      \uput[180](-3,0|nand21){$\overline{\mbox{R}}$}
+      \psline[arrows=o-](3,0|nand1Q)(nand1Q)
+      \uput[0](3,0|nand1Q){Q}
+      \psline[arrows=o-](3,0|nand2Q)(nand2Q)
+      \uput[0](3,0|nand2Q){$\overline{\mbox{Q}}$}
+      \psline[arrows=*-](2,0|nand1Q)(2,1.75)(-2,0.75)(-2,0|nand22)(nand22)
+      \psline[arrows=*-](2,0|nand2Q)(2,0.75)(-2,1.75)(-2,0|nand11)(nand11)
+    \end{pspicture}
+  \end{pdfpic}
+
+  \newterm{Bistabile Kippstufe} -- \newterm{Bistabiler Multivibrator} -- \newterm{Flip-Flop}
+
+  1-Bit-Speicherzelle
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Information speichern
+
+  \vspace*{-0.5cm}
+
+  \begin{pdfpic}
+    \psset{unit=0.6cm}
+    \psset{linewidth=0.03}
+    \begin{pspicture}(-4,-4)(4,4)
+      \pnode(0,0.5){A}
+      \pnode(0,-0.5){B}
+      \capacitor(A)(B){}
+      \psline[arrows=-o](A)(A|0,1)
+      \psline[arrows=-o](B)(B|0,-1)
+    \end{pspicture}
+  \end{pdfpic}
+
+  \vspace*{-1.0cm}
+
+  \newterm{Kondensator}
+
+  \only<2->{\newterm{dynamische\/}} 1-Bit-Speicherzelle\\
+  \pause
+  \textarrow\ benötigt \newterm{Refresh}-Schaltung
+
+  \pause[3]
+  \medskip
+  Flip-Flop
+
+  \newterm{statische\/} 1-Bit-Speicherzelle
+
+  \begin{pdfpic}
+    \psset{unit=0.6cm}
+    \psset{linewidth=0.03}
+    \begin{pspicture}(-4,-4)(4,4)
+      \logic[logicType=nand](-0.75,2){nand1}
+      \logic[logicType=nand](-0.75,-2){nand2}
+      \psline[arrows=o-](-3,0|nand12)(nand12)
+      \uput[180](-3,0|nand12){$\overline{\mbox{S}}$}
+      \psline[arrows=o-](-3,0|nand21)(nand21)
+      \uput[180](-3,0|nand21){$\overline{\mbox{R}}$}
+      \psline[arrows=o-](3,0|nand1Q)(nand1Q)
+      \uput[0](3,0|nand1Q){Q}
+      \psline[arrows=o-](3,0|nand2Q)(nand2Q)
+      \uput[0](3,0|nand2Q){$\overline{\mbox{Q}}$}
+      \psline[arrows=*-](2,0|nand1Q)(2,1.75)(-2,0.75)(-2,0|nand22)(nand22)
+      \psline[arrows=*-](2,0|nand2Q)(2,0.75)(-2,1.75)(-2,0|nand11)(nand11)
+    \end{pspicture}
+  \end{pdfpic}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsection
+
+%  Wir können jetzt addieren, subtrahieren und multiplizieren.\\
+%  Wie bauen wir daraus einen Turing-vollständigen Computer?
+  Bau eines Turing-vollständigen Computers
+  \begin{itemize}
+    \pause
+    \item
+      Rechenwerk: Arithmetisch-logische Einheit (ALU)
+      \only<2>{\\[\bigskipamount]\strut\hfill\includegraphics[width=9.5cm]{alu.jpg}\vspace*{-10cm}\hfill\strut}
+    \pause
+    \item
+      Speicher: Register, adressierbarer Hauptspeicher
+      \only<3>{\\[\smallskipamount]\strut\hfill\includegraphics[width=11cm]{speicheradressierung-3.png}\vspace*{-10cm}}
+    \pause
+    \item
+      Takt:
+      \begin{onlyenv}<4>
+        \begin{picture}(0,0)
+          \put(3.5,-0.4){\makebox(0,0)[tl]{\includegraphics[width=7cm]{astabile-kippstufe.png}}}
+          \put(-1.0,-0.5){\makebox(0,0)[tl]{\includegraphics[width=4cm]{schwingquarz.jpg}}}
+          \put(-1.0,-3.5){\makebox(0,0)[tl]{\includegraphics[width=4cm]{schwingquarz-geoeffnet.jpg}}}
+        \end{picture}
+      \end{onlyenv}
+      \pause
+      Speicher durchgehen
+      \only<5>{\\[\smallskipamount]\strut\hfill\includegraphics[width=11cm]{takt-zaehler-4.png}\vspace*{-10cm}}%
+      \pause
+      und Befehle abarbeiten
+      \begin{onlyenv}<6-8>
+        \begin{itemize}\itemsep\smallskipamount
+          \item
+            Register-Ladebefehl:\\
+            "`Lade Speicherzelle 42 an den A-Eingang der ALU."'
+          \item
+            Rechenbefehl:\\
+            "`Berechne die Summe der beiden Register an der ALU."'
+          \item
+            Register-Speicherbefehl:\\
+            "`Speichere den Status-Ausgang der ALU in Speicherzelle 137."'
+          \pause
+          \item
+            Sprungbefehl:\\
+            "`Lade den Inhalt der Speicherzelle 1117\\
+            in das Adressregister für den nächsten Befehl."'
+          \pause
+          \item
+            Bedingter Sprungbefehl:\\
+            "`Wenn das \Cout-Bit der ALU den Wert 1 hat,\\
+            springe nach Speicherzelle 23."'
+        \end{itemize}
+        \vspace*{-10cm}
+      \end{onlyenv}
+    \pause
+    \item
+      Peripherie: Kommunikation mit der Außenwelt
+      \begin{onlyenv}<9>
+        \begin{itemize}\itemsep\smallskipamount
+          \item
+            Output-Port:\\
+            Ausgang einer Speicherzelle nach draußen führen
+          \item
+            Input-Port:\\
+            Anstelle einer Speicherzelle einen eingehenden Draht abfragen
+        \end{itemize}
+        \vspace*{-10cm}
+      \end{onlyenv}
+    \pause
+    \arrowitem
+      in Maschinensprache programmierbar
+  \end{itemize}
+
+\end{frame}
+
+% Fortsetzung: 20141016
+
+\sectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \showsectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+    \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer}
+      \begin{itemize}
+        \item[2.1] Logik-Schaltkreise
+        \item[2.2] Binärdarstellung von Zahlen
+        \item[2.3] Vom Logik-Schaltkreis zum Addierer
+        \item[2.4] Negative Zahlen
+        \color{medgreen}
+        \item[2.5] Vom Addierer zum Computer
+        \color{red}
+        \item[2.6] Computer-Sprachen
+        \item[2.7] Struktur von Assembler-Programmen
+      \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{\dots\hspace{-0.75em}}]
+%    \item[\textbf{9}] \textbf{Ausblick}
+  \end{itemize}
+
+\end{frame}
+
+\setcounter{subsection}{5}
+\subsection{Computer-Sprachen}
+\subsubsection{Maschinensprache}
+
+\begin{frame}
+
+  \showsubsection
+  \showsubsubsection
+
+  \strut\hfill
+  \begin{minipage}{6.5cm}
+    \vspace*{-1.7cm}
+    \small
+    Computer
+    \begin{itemize}\itemsep0pt
+      \item Rechenwerk (ALU)
+      \item Speicher: Register,\\
+            adressierbarer Hauptspeicher
+      \item Takt: Befehle abarbeiten
+      \item Peripherie: Kommunikation\\
+            mit der Außenwelt
+      \arrowitem in Maschinensprache programmierbar
+    \end{itemize}
+  \end{minipage}\hspace*{-0.5cm}
+
+  In jedem Takt:
+  \begin{itemize}
+    \item
+      dort aus dem Hauptspeicher lesen, wohin das Register \lstinline{IP} zeigt\\
+      \textarrow\ \newterm{Befehl\/} (\newterm{Instruction\/} -- \lstinline{IP} = \newterm{Instruction Pointer\/})
+    \item
+      den \newterm{Befehl\/} an den \newterm{Funktion\/}-Eingang der \newterm{ALU\/} legen
+    \item
+      auf ähnliche Weise weitere Daten an den \newterm{Akkumulator\/}-\\
+      und den \newterm{Daten\/}-Eingang der \newterm{ALU\/} legen
+    \item
+      auf ähnliche Weise den \newterm{Ergebnis\/}-Ausgang der \newterm{ALU}\\
+      in den Hauptspeicher schreiben
+      \textarrow\ Befehl ausgeführt
+    \item
+      Register \lstinline{IP} hochzählen
+      \textarrow\ nächster Befehl
+    \arrowitem
+      Maschinensprache
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsection
+  \showsubsubsection
+
+  \begin{itemize}
+    \item
+      Daten aus dem Speicher in Register einlesen
+    \item
+      Daten aus Register in den Speicher schreiben
+    \arrowitem
+      Lade- und Speicher-Befehle
+    \item
+      Daten aus Registern (oder Speicher) an ALU legen,\\
+      Ergebnis in Register (oder Speicher) schreiben
+    \arrowitem
+      arithmetische Befehle
+    \pause
+    \item
+      Daten aus Register oder Speicher in das \lstinline{IP}-Register laden
+    \arrowitem
+      \only<4->{unbedingter }Sprungbefehl
+    \pause
+    \item
+      Sprungbefehl nur dann, wenn im Status-Ausgang der ALU ein bestimmtes Bit gesetzt ist
+    \arrowitem
+      bedingter Sprungbefehl
+    \pause
+    \pause
+    \bigskip
+    \arrowitem
+      Der Computer kann "`alles"' -- \newterm{Turing-Vollständigkeit}
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsubsection
+  \showsubsubsection
+
+  \begin{itemize}
+    \item
+      Lade- und Speicher-Befehle\\
+      arithmetische Befehle\\
+      unbedingte und bedingte Sprungbefehle
+    \arrowitem
+      Der Computer kann "`alles"' -- \newterm{Turing-Vollständigkeit}
+    \bigskip
+    \item
+      Maschinensprache = Zahlen \textarrow\ für Menschen schwer handhabbar
+    \arrowitem
+      Namen für die Befehle: \newterm{Mnemonics}
+    \arrowitem
+      \newterm{Assembler\/}-Sprache
+  \end{itemize}
+
+\end{frame}
+
+\subsubsection{\strut{\protect\color{gray}Maschinensprache \protect\textarrow\ }Assembler}
+
+\begin{frame}[fragile]
+
+  \showsubsubsection
+
+  Beispiel: Intel-x86-16-Bit-Assembler
+
+  \begin{itemize}
+    \item
+      Lade- und Speicher-Befehle\hfill
+        \lstinline{mov}, \dots\\
+      arithmetische Befehle\hfill
+        \lstinline{add}, \lstinline{sub}, \lstinline{inc}, \lstinline{dec},
+        \lstinline{xor}, \lstinline{cmp}, \dots\\
+      unbedingte und bedingte Sprungbefehle\hfill
+        \lstinline{jmp}, \lstinline{jz}, \lstinline{jae}, \dots
+    \item
+      Register\hfill
+        \lstinline{ax}, \lstinline{bx}, \dots
+  \end{itemize}
+
+  \begin{onlyenv}<1>
+    \begin{center}
+%      \includegraphics[width=10cm]{programm-screenshot.png}
+      \vspace*{-0.5cm}
+    \end{center}
+  \end{onlyenv}
+  \begin{onlyenv}<2->
+
+    \bigskip
+
+    Beispiel: Atmel-AVR-8-Bit-Assembler
+
+    \begin{itemize}
+      \item
+        Lade- und Speicher-Befehle\hfill
+          \lstinline{ldi}, \lstinline{lds}, \lstinline{sti}, \dots\\
+        arithmetische Befehle\hfill
+          \lstinline{add}, \lstinline{sub}, \lstinline{subi},
+          \lstinline{eor}, \lstinline{cp}, \dots\\
+        unbedingte und bedingte Sprungbefehle\hfill
+          \lstinline{rjmp}, \lstinline{brsh}, \lstinline{brlo}, \dots
+      \item
+        Register\hfill
+          \lstinline{r0}, \lstinline{r1}, \dots
+    \end{itemize}
+
+    \bigskip
+
+    \textarrow\ für jeden Prozessor anders
+
+  \end{onlyenv}
+
+\end{frame}
+
+\subsubsection{\strut{\protect\color{gray}Maschinensprache \protect\textarrow\ Assembler \protect\textarrow\ }Hochsprachen}
+
+\begin{frame}[fragile]
+
+  \showsubsubsection
+
+  Beispiel: Intel-x86-16-Bit-Assembler
+
+  \begin{itemize}
+    \item
+      Lade- und Speicher-Befehle\hfill
+        \lstinline{mov}, \dots\\
+      arithmetische Befehle\hfill
+        \lstinline{add}, \lstinline{sub}, \lstinline{inc}, \lstinline{dec},
+        \lstinline{xor}, \lstinline{cmp}, \dots\\
+      unbedingte und bedingte Sprungbefehle\hfill
+        \lstinline{jmp}, \lstinline{jz}, \lstinline{jae}, \dots
+    \item
+      Register\hfill
+        \lstinline{ax}, \lstinline{bx}, \dots
+  \end{itemize}
+
+  \bigskip
+
+  Beispiel: Atmel-AVR-8-Bit-Assembler
+
+  \begin{itemize}
+    \item
+      Lade- und Speicher-Befehle\hfill
+        \lstinline{ldi}, \lstinline{lds}, \lstinline{sti}, \dots\\
+      arithmetische Befehle\hfill
+        \lstinline{add}, \lstinline{sub}, \lstinline{subi},
+        \lstinline{eor}, \lstinline{cp}, \dots\\
+      unbedingte und bedingte Sprungbefehle\hfill
+        \lstinline{rjmp}, \lstinline{brsh}, \lstinline{brlo}, \dots
+    \item
+      Register\hfill
+        \lstinline{r0}, \lstinline{r1}, \dots
+  \end{itemize}
+
+  \bigskip
+
+  \textarrow\ für jeden Prozessor anders
+
+  \bigskip
+
+  Hochsprache \textarrow\ für jeden Prozessor gleich
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsubsection
+
+  Compiler-Sprachen
+  \begin{itemize}
+    \item
+      \newterm{Compiler\/} übersetzt Hochsprachen-\newterm{Quelltext\/} in die Assembler-Sprache
+    \item
+      \newterm{Assembler\/} übersetzt Assembler-Quelltext in die Maschinensprache
+    \item
+      Compiler und Assembler sind Programme,\\
+      geschrieben in Maschinensprache, Assembler oder einer Hochsprache
+    \item
+      Beispiele: Fortran, Algol, Pascal, Ada, C, C++, \dots
+  \end{itemize}
+
+  \pause
+  \medskip
+  Interpreter- oder Skript-Sprachen
+  \begin{itemize}
+    \item
+      \newterm{Interpreter\/} liest Hochsprachen-\newterm{Quelltext\/} und führt ihn sofort aus
+    \item
+      Der Interpreter ist ein Programm,\\
+      geschrieben in Maschinensprache, Assembler oder einer Hochsprache
+    \item
+      Beispiele: Unix-Shell, BASIC, Perl, Python, \dots
+  \end{itemize}
+
+  \pause
+  \medskip
+  Kombinationen
+  \begin{itemize}
+    \item
+      \newterm{Compiler\/} erzeugt \newterm{Zwischencode\/} für eine \newterm{virtuelle Maschine}
+    \item
+      \newterm{Interpreter\/} liest Hochsprachen-\newterm{Zwischencode\/} und führt ihn sofort aus
+    \item
+      Die virtuelle Maschine ist ein Programm,
+      geschrieben in Maschinensprache, Assembler, einer Hoch- oder Skript-Sprache
+    \item
+      Beispiele: UCSD-Pascal, Java, \dots
+  \end{itemize}
+  \medskip
+
+\end{frame}
+
+\sectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \showsectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+    \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer}
+      \begin{itemize}
+        \item[2.1] Logik-Schaltkreise
+        \item[2.2] Binärdarstellung von Zahlen
+        \item[2.3] Vom Logik-Schaltkreis zum Addierer
+        \item[2.4] Negative Zahlen
+        \color{medgreen}
+        \item[2.5] Vom Addierer zum Computer
+        \item[2.6] Computer-Sprachen
+        \color{red}
+        \item[2.7] Struktur von Assembler-Programmen
+      \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{\dots\hspace{-0.75em}}]
+%    \item[\textbf{9}] \textbf{Ausblick}
+  \end{itemize}
+
+\end{frame}
+
+\setcounter{subsection}{6}
+\subsection{Struktur von Assembler-Programmen}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel 1: IA-32-Assembler \only<3>{-- Adressierungsarten}
+
+  \vspace{2cm}
+
+  \begin{lstlisting}
+    addl    $1, %eax
+    movb    %al, b
+    cmpb    (%ebx), %dl
+    jbe     .L2
+  \end{lstlisting}
+
+  \begin{onlyenv}<2-3>
+    \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<2>{%
+        \put(1.4,2.8){\vector(-1,-1){0.7}}
+        \put(2.3,2.9){\makebox(0,0)[b]{Größen-Suffix}}}
+      \only<3>{%
+        \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}<4>
+    \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}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel 2: Redcode (ICWS '88) -- 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}
+
+  \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}
+
+\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}
+
+\end{frame}
+
+\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
+      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}
+
+\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-88-Standard,\\
+    max.\ 64 Prozesse,\\
+    Speichergröße zufällig
+
+    \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}
+
+\end{document}