Papiercomputer

; Dieses Programm nullt das Register AwhileA: isz A ; Ist A=0?jmp decA      ; Nein, weiter bei decAjmp done      ; Ja, Sprung zum EndedecA: dec A   ; A um eins verringernjmp whileA    ; Sprung zum Anfang, wieder testen.done:stp           ; Fertig.

; Dieses Programm kopiert das Register A nach B; Es benutzt dabei das Register X und zerstört den Wert, der; dort gespeichert sein könnte.; Zuerst wird B ausgenullt.whileB: isz B ; Ist B=0?jmp decB      ; Nein, weiter bei decBjmp clearX    ; Ja, Sprung zum nächsten AbschnittdecB: dec B   ; B um eins verringernjmp whileB    ; Sprung zum Anfang, wieder testen.; Dann wird das temporär genutzte Register; X genullt.clearX:isz Xjmp decXjmp processAdecX:dec Xjmp clearX; Wir kopieren den Wert aus A nach X und CprocessA:isz A			; Ist A=0?jmp inc			; Nein, weiter bei incjmp restoreA	; Ja. Weiter zur Wiederherstellung von Ainc:dec Ainc Binc Xjmp processA; Wir restaurieren den Wert in A aus X.restoreA:isz Xjmp incAjmp doneincA:inc Adec Xjmp restoreAdone:stp           ; Fertig.

; Dieses Programm addiert die Werte in Register A und B und; speichert das Ergebnis in Register C. Dabei werden A und B; ausgenullt. Das macht das Programm gegenüber der erhaltenden; Addition (nächstes Beispiel) viel kürzer und braucht keine; Zusatzregister.; Im ersten Schritt wird das Zielregister C ausgenullt.clearC:isz Cjmp decCjmp processAdecC:dec Cjmp clearC; Wir kopieren den Wert aus A nach CprocessA:isz Ajmp incjmp processBinc:dec Ainc Cjmp processA; Jetzt kopieren wir den Wert aus B nach C.; In C steht nachher die Summe.processB:isz Bjmp inc2jmp doneinc2:dec Binc Cjmp processB; Fertig.done: stp;

; Dieses Programm addiert die Werte in Register A und B und; speichert das Ergebnis in Register C. Es benutzt dabei das Register X; und zerstört den Wert, der dort gespeichert sein könnte.; Im ersten Schritt wird das Zielregister C ausgenullt.clearC:isz Cjmp decCjmp clearXdecC:dec Cjmp clearC; Dann wird X genullt.clearX:isz Xjmp decXjmp processAdecX:dec Xjmp clearX; Wir kopieren den Wert aus A nach X und CprocessA:isz Ajmp incjmp restoreAinc:dec Ainc Xinc Cjmp processA; Jetzt steht A in X und C, aber A=0; Wir restaurieren den Wert in A aus X.restoreA:isz Xjmp incAjmp processBincA:inc Adec Xjmp restoreA; Jetzt kopieren wir den Wert aus B nach X und C; X ist 0, wird also wieder eine Sicherheitskopie.; Und in C steht nachher die Summe.processB:isz Bjmp inc2jmp restoreBinc2:dec Binc Xinc Cjmp processB; Wir restaurieren den Wert in B aus X.restoreB:isz Xjmp incBjmp doneincB:inc Bdec Xjmp restoreB; Fertig.done: stp;

; Dieses Programm brechnet A - B und speichert das Ergebnis in; Register C. Ist B größer als A ist das Ergebnis 0. Dabei wird; A ausgenullt und B auch verändert. Das macht das Programm gegenüber; der erhaltenden Subtraktion (nächstes Beispiel) viel kürzer und; braucht keine Zusatzregister.; Im ersten Schritt wird das Zielregister C ausgenullt.clearC:isz Cjmp decCjmp processAdecC:dec Cjmp clearC; Wir kopieren den Wert aus A nach CprocessA:isz Ajmp incjmp processBinc:dec Ainc Cjmp processA; Jetzt ziehen wir den Wert aus B von C ab.; In C steht nachher die Differenz oder 0.processB:isz Bjmp checkCjmp donecheckC:; Optimierung: Falls C vor B 0 wird können wir; aufhören. Als Nebeneffekt enthält B dann außerdem; B-A, aber das war nicht gesucht.isz Cjmp decjmp donedec:dec Cdec Bjmp processB; Fertig.done: stp;

; Dieses Programm berechnet die Differenz von A und B und; speichert sie in Register C. Ist B größer als A, so ist; das Ergebnis 0 . Es benutzt dabei das Register X; und zerstört den Wert, der dort gespeichert sein könnte.; Im ersten Schritt wird das Zielregister C ausgenullt.clearC:isz Cjmp decCjmp clearXdecC:dec Cjmp clearC; Dann wird X genullt.clearX:isz Xjmp decXjmp processAdecX:dec Xjmp clearX; Wir kopieren den Wert aus A nach X und CprocessA:isz Ajmp incjmp restoreAinc:dec Ainc Xinc Cjmp processA; Jetzt steht A in X und C, aber A=0; Wir restaurieren den Wert in A aus X.restoreA:isz Xjmp incAjmp processBincA:inc Adec Xjmp restoreA; Jetzt kopieren wir den Wert aus B nach X und; verringern dabei C. X startet bei 0, wird also; wieder eine Sicherheitskopie. Und in C steht; nachher die Differenz.processB:isz Bjmp checkCjmp restoreBcheckC:isz Cjmp decjmp restoreBdec:dec Binc Xdec Cjmp processB; Wir restaurieren den Wert in B aus X.restoreB:isz Xjmp incBjmp doneincB:inc Bdec Xjmp restoreB; Fertig.done: stp;

; Dieses Programm berechnet das Produkt der Werte in Register A; und B und speichert das Ergebnis in Register C. Es benutzt dabei; die Register X und Y und überschreibt Werte, die dort gespeichert; sein könnten.; Der verwendete Algorithmus ist wiederholtes Addieren: A wird B mal; zu C addiert. Damit die Begister A und B am Ende ihre Werte behalten; haben addieren wir auf dem Rückweg aus dem temporären Register.; Es gibt hier Optimierungsansätze, aber die machen das Programm; länger...; Im ersten Schritt wird das Zielregister C ausgenullt.clearC:isz Cjmp decCjmp clearXdecC:dec Cjmp clearC; Dann wird X genullt, es soll den temporären Wert von A halten.clearX:isz Xjmp decXjmp clearYdecX:dec Xjmp clearX; Dann wird Y genullt, es soll den temporären Wert von B halten.clearY:isz Yjmp decYjmp loopBdecY:dec Yjmp clearY; Für jedes Streichholz in B kopieren wir jetzt A nach X und dann; wieder zurück. Auf dem Rückweg schreiben wir auch in C. So ist am; Ende jedes Durchgangs A wieder auf dem alten Wert, X wieder 0 und; C um einmal A erhöht.loopB:isz Bjmp copyAXjmp restoreBcopyAX:isz Ajmp incXjmp copyXAincX:dec Ainc Xjmp copyAXcopyXA:isz Xjmp addjmp decBadd:inc Ainc Cdec Xjmp copyXAdecB:dec Binc Yjmp loopB; Wir restaurieren den Wert in B aus Y.restoreB:isz Yjmp incBjmp doneincB:inc Bdec Yjmp restoreB; Fertig.done: stp;

; Dieses Programm berechnet die Division.; Register C erhält den ganzzahligen Quotienten C = ⌊A/B⌋ und Register; den Rest D = A mod B.; Es verwendet die Register X, Y und Z für temporäre Daten und; überschreibt die Daten darin.; Ist B = 0 wird C = 0 und D = 0 ausgegeben.; 0 => CclearC:isz Cjmp decCjmp clearDdecC:dec Cjmp clearC; 0 => DclearD:isz Djmp decDjmp checkBdecD:dec Djmp clearDcheckB:; Falls B=0 ist sind wir hier schon fertig.isz Bjmp clearXjmp done;; 0 => XclearX:isz Xjmp decXjmp loopCopyAXdecX:dec Xjmp clearX; A => XloopCopyAX:isz Ajmp doCopyAXjmp clearYdoCopyAX:dec Ainc Xjmp loopCopyAX; 0 => YclearY:isz Yjmp decYjmp loopCopyBYZdecY:dec Yjmp clearY; B => YloopCopyBYZ:isz Bjmp doCopyBYZjmp loopDivdoCopyBYZ:inc Ydec Bjmp loopCopyBYZ; Jetzt haben wir C = 0 und so vorbereitet für den Quotienten; Das Ergebnisregister D für den Rest ist auch 0. A ist nach X; umgefüllt und B ist auch 0, sein Wert wurde nach Y umgefüllt.; Y werden wir für die wiederholte Subtraktion verwenden.; Hier steigen wir wieder ein, so lange X noch Streichhölzer hat,; also der Dividend nicht ganz verbraucht ist.loopDiv:; Wir legen Streichhölzer aus Z nach B und gleichzeitig aus X; zurück nach A.; Damit subtrahieren wir den Quotienten einmal vom Ergebnis.; Falls uns die Streichhölzer in X reichen erhöhen wir den Quotienten; einmal und legen sie für die nächste Iteration aus B zurück nach; Z.; Gehen unterwegs die Streichhölzer in X aus hat B jetzt den Rest. Wir; legen diese zurück nach Z und D damit am Ende der Rest in D steht.isz Xjmp sub1jmp doneDivsub1:; Müssen wir noch Divisor abziehen?isz Yjmp doSub1jmp doneSub1doSub1:; Haben wir noch Dividend übrig von dem wir abziehen können?isz Xjmp havejmp haveNothave:; Ein Streichholz aus X nach Adec Xinc A; Ein Streichholz aus Y nach Bdec Yinc Bjmp sub1; Einmal erfolgreich den ganzen Divisor abgezogen.doneSub1:; Quotient erhöheninc C; B zurück nach Y für die nächste Runde.loopRestoreY:isz Bjmp doRestoreYjmp loopDivdoRestoreY:dec Binc Yjmp loopRestoreYhaveNot:; Der Dividend ist uns ausgegangen. Der Rest ist jetzt in B.; Wir füllen ihn von dort ins Ergebnis nach D um und gleichzeitig; zurück nach Y.loopRestoreYD:isz Bjmp doRestoreYDjmp doneDivdoRestoreYD:dec Binc Yinc Djmp loopRestoreYDdoneDiv:; Wir sind fast fertig: Der ganze Dividend ist zurück nach A gewandert.; Der Quotient ist im Ergebnisregister C, und der Rest in D. Es fehlt nur; noch den Divisor von Y zurück nach B zu schieben.loopRestoreB:isz Yjmp doRestoreBjmp donedoRestoreB:inc Bdec Yjmp loopRestoreB; Fertig.done: stp;