10 ; PROGRAMM ZUR DEMONSTRATION DER
20 ; FUNKTIONSWEISE VON PACKERN
30 ;
40 ;     BY DIRK NEUMEISTER
50 ;        IM  TRIESCH  28
60 ;        3503  LOHFELDEN
70 ;        TEL.: KS/518475
80 ;
120 ;
130 ;
140 ;
150 ;
160 ; PROGRAMMSTART AUF $C000 = 49152
170 ;
180  +$C000
190 ;
200 ; DEFINITION VON ROM-ROUTINEN
210 ;
220  TOSTRAUSG=$AB1E
230  TOGETBYTE=$B79E
240  TOPRINTFAC=$BDD7
250  TOKOMMA=$AEFD
260  TOINTHOLEN=$AD8A
270  TOWANDELN=$B7F7
280  TOFACMAL10=$BAE2
290  TOINFAC=$B395
300  TOCOPYFACII=$BC0C
310  TOFACDIV=$BB14
1000 ;
1010 ; ALLGEMEINER COMPACTOR START
1020 ;
1030 ; SYS 49152, ADR2, ADR3, ADR4, MODE
1040 ; MIT AUSGAGE DER LAENGE IN % UND DER ENDADRESSE
1050 ;
1060  MID$#<(REST); ZEIGER FUER DEN TEXT LADEN, UM DEN
1070  LEN#>(REST); HINWEIS AUF DIE RESTLAENGE AUSZUGEBEN
1080  (null)STRAUSG; TEXT AUSGEBEN
1090  (null)HOLEN; STARTADRESSE DER UNGEPACKTEN DATEN HOLEN
1100  MID$#$FB
1110  (null)COPY; UND DIESE NACH $FB/$FC COPIEREN
1120  (null)HOLEN; ENDADRESSE DER UNGEPACKTEN DATEN HOLEN
1130  RIGHT$$14; DIE ENDADRESSE UM EINS ERHOEHEN
1140  (null)COMP3;
1150  RIGHT$$15;
1160 COMP3 MID$#$FD
1170  (null)COPY; UND NACH $FD/$FE COPIEREN
1180  (null)HOLEN; STARTADR. DER GEPACKTEN DATEN NACH $14/15 LADEN
1190  (null)KOMMA; DEN RESTLICHEN AUSDRUCK AUF KOMMA PRUEFEN
1200  (null)GETBYTE; EIN WEITERES BYTE IN X-REGISTER HOLEN (MODUS)
1210  MID$#$F7; DIE STARTADRESSE DER GEPACKTEN DATEN
1220  (null)COPY; NACH $F7/$F8 COPIEREN
1230  (null)PROZENT; PROZENTROUTINE 1 AUFRUFEN (ERSTE BERECHNUNG)
1240  (null); MODUSBYTE IN AKKU COPIEREN
1250  LEFT$#$A8; MIT EXOR 10101000 VERKNUEPFEN
1260  (null)AUSGABE; MODUSBYTE SPEICHERN
1270  (null)AUSGABE; DUMMY FUER ENDADRESSE SETZEN
1280  (null)AUSGABE; DUMMY FUER ENDADRESSE SETZEN
1290  (null); X-REGISTER COPIEREN, FLAGS WERDEN GESETZT
1300  (null)COMP1; WENN <> 0, DANN MIT NIBBLER ARBEITEN
1310  (null)PACKEN; SONST MIT PACKER ARBEITEN
1320  (null)COMP2
1330 COMP1 (null)NIBBLER; NIBBLER AUFRUFEN
1340  MID$#$EE; AKKU MIT $EE LADEN UND NIBBLER ERNEUT AUFRUFEN
1350  (null)NIBBLER3; DAMIT DAS LETZTE BYTE AUCH GESPEICHERT WIRD
1360 COMP2 LEN#$01
1370  MID$$F7; ENDADRESSE SPEICHERN, WO VORHER DIE DUMMIES
1380  (null)($61),Y; GESTANDEN HABEN
1390  (null)
1400  MID$$F8
1410  (null)($61),Y
1420  (null)PROZENT2; PROZENTROUTINE 2 AUFRUFEN
1430  (null)PRINTFAC; RESTLAENGE DES PROGRAMMS AUSGEBEN
1440  (null)$AAD7; 2 MAL RETURN AUSGEBEN
1450  (null)$AAD7
1460  MID$$F8; ENDADRESSE DER GEPACKTEN DATEN LADEN
1470  PEEK$F7
1480  (null)$BDCD; UND EBENFALLS AUSGEBEN
1490  MID$#<(ENDADR); ZEIGER FUER DEN TEXT DER ENDADRESSE LADEN
1500  LEN#>(ENDADR)
1510  (null)STRAUSG; UND DEN TEXT AUSGEBEN
1520  (null)
2000 ;
2010 ; ALLGEMEINER DECOMPACTOR START
2020 ; SYS 49265, ADR2, ADR3
2030 ;
2040 DECOMP (null)HOLEN; STARTADRESSE DER GEPACKTEN DATEN HOLEN
2050  MID$#$FB
2060  (null)COPY; UND NACH $FB/$FC COPIEREN
2070  (null)NEXTBYTE; MODUSBYTE HOLEN
2080  (null); UND AUF STAPEL LEGEN
2090  (null)NEXTBYTE; ENDADRESSE DER GEPACKTEN DATEN AUS DEM
2100  (null)$35; SPEICHER LESEN UND NACH $35/$36 SPEICHERN
2110  (null)NEXTBYTE
2120  (null)$36
2130  (null)HOLEN; STARTADRESSE DER UNGEPACKTEN DATEN HOLEN
2140  MID$#$F7; CLOSE
2150  (null)COPY; NACH $F7/$F8 COPIEREN
2160  (null); STAPEL LESEN UND IN AKKU SPEICHERN
2170  LEFT$#$A8; CODIERUNG AUFHEBEN
2180  (null)DECOMP1; WENN AKKU <> 0, DANN NIBBLER AUFRUFEN
2190  (null)ENTPACKEN; SONST PACKER AUFRUFEN
2200  (null)
2210 DECOMP1 (null); AKKU IN X-REGISTER COPIEREN
2220  (null); X-REGISTER UM EINS VERRINGERN
2230  (null)DECOMP2; WENN X <> 0 (FEHLER), FALSCHE STARTADRESSE
2240  (null)DENI; SONST NIBBLER AUFRUFEN
2250  (null)
2260 DECOMP2 MID$#<(FEHLER); AUSGABE EINER FEHLERMELDUNG, DA DAS DECODIERTE
2270  LEN#>(FEHLER); MODUSBYTE WEDER NULL NOCH EINS WAR ==>
2280  (null)STRAUSG; FALSCHE STARTADRESSE ANGEGEBEN
2290  (null)
3000 ;
3010 ; UNTERROUTINEN FUER DIE
3020 ; ALLGEMEINEN EINSPRUNGADRESSEN
3030 ;
3040 HOLEN (null)KOMMA; PRUEFT AUF KOMMA
3050  (null)INTHOLEN; 16-BIT ZAHL IN FAC HOLEN
3060  (null)WANDELN; FAC WANDELN IN INTEGER $14/$15
3070  (null); ZURUECK
3080 ;
3090 COPY LEN#$01; ZAHLEN DER SPEICHERSTELLEN $14/$15
3100  (null)COPY1+1; IN DIE SPEICHERSTELLE COPIEREN, DIE IM
3110 COPY2 MID$$14,Y; AKKU (+1) STEHT
3120 COPY1 (null)$00,Y
3130  (null)
3140  (null)COPY2
3150  (null); UND WIEDER ZURUECK
4000 ;
4010 ;  PACKER
4020 ;  $FB/$FC = BEGINN DER UNGEPACKTEN DATEN
4030 ;  $FD/$FE = ENDE DER UNGEPACKTEN DATEN
4040 ;  $F7/$F8 = BEGINN DER GEPACKTEN DATEN
4050 ;
4060 PACKEN (null)NEXTBYTE; NAECHSTES BYTE IN AKKU HOLEN
4070  (null); BYTE VOM AKKU NACH X KOPIEREN
4080  (null)VERGLEICHE; BYTE IM AKKU MIT FOLGENDEN BYTES VERGLEICHEN
4090  (null)$A5; ANZAHL-1 DER GLEICHEN BYTES IN Y UND $A5
4100  ATN#03; ANZAHL-1 DER BYTES MIT #03 VERGLEICHEN
4110  (null)PACKEN1; WENN ANZAHL-1 < 3, DANN NICHT PACKEN
4120  (null); ANZAHL-1 IN DEN AKKU KOPIEREN
4130  (null); ADDITION VORBEREITEN
4140  VAL$FB; UM ANZAHL-1 DER GLEICHEN BYTES DEN
4150  (null)$FB; ZEIGER FUER UNGEPACKTE DATEN NACH VORNE, VER-
4160  (null)PACKEN2; SCHIEBEN, DAMIT NICHT DOPPELT ZUSAMMEN-
4170  RIGHT$$FC; GEFASST WIRD
4180 PACKEN2 TAN#00; VERGLEICHEN DER BYTES MIT $00
4190  (null)PACKEN3; WENN JA, DANN MIT $DB CODIEREN
4200  MID$#$DA; SONST MIT $DA BEGINNEN
4210  (null)AUSGABE; $DA SPEICHERN
4220  MID$$A5; ANZAHL-1 DER GLEICHEN BYTES IN AKKU
4230  (null)AUSGABE; UND ABSPEICHERN
4240  (null); CODE DER GLEICHEN BYTES IN AKKU
4250  (null)AUSGABE; UND EBENFALLS SPEICHERN
4260  (null)PACKEN4; UNBEDINGTER SPRUNG, DA AKKU = #$FF
4270 PACKEN3 MID$#$DB; #$DB ALS CODE FUER 00 IN AKKU LADEN
4280  (null)AUSGABE; UND IM SPEICHER ABLEGEN
4290  MID$$A5; ANZAHL-1 DER $00-BYTES IN AKKU
4300  (null)AUSGABE; UND EBENFALLS SPEICHERN
4310  (null)PACKEN4; UNBEDINGTER SPRUNG
4320 PACKEN1 TAN#$DA; VERGLEICHEN OB BYTE ZUFAELLIG $DA
4330  (null)PACKEN5
4340  TAN#$DB; ODER $DB IST
4350  (null)PACKEN6; WENN NICHT, VERZWEIGEN (EINFACHE AUSG.)
4360 PACKEN5 (null); $DA ODER $DB VOM X-REGISTER IN AKKU COPIEREN
4370  (null)AUSGABE; UND AUSGEBEN
4380  MID$#00; ANZAHL-1 LADEN
4390  (null)AUSGABE; UND EBENFALLS ABSPEICHERN
4400  (null)PACKEN4; UNBEDINGTER SPRUNG
4410 PACKEN6 (null); EINFACHE AUSGABE, D.H. CODE IN AKKU
4420  (null)AUSGABE; UND IM SPEICHERN ABLEGEN
4430 PACKEN4 MID$$FB
4440  PEEK$FC; VERGLEICHEN OB ENDE, WENN NEIN, DANN
4450  TAN$FE
4460  (null)PACKEN7
4470  STR$$FD
4480 PACKEN7 (null)PACKEN; VON VORNE WIEDER BEGINNEN
4490  (null); SONST RUECKSPRUNG AUS DER UNTERROUTINE
5000 ;
5010 ;  ENTPACKEN
5020 ;  $F7/$F8 = BEGINN DER UNGEPACKTEN DATEN
5030 ;  $FB/$FC = BEGINN DER GEPACKTEN DATEN
5040 ;  $35/$36 = ENDE DER GEPACKTEN DATEN
5050 ;
5060 ENTPACKEN (null)NEXTBYTE; NAECHSTES BYTE IN DEN AKKU LADEN
5070  STR$#$DB; MIT DEM ERKENNUNGSCODE $DB VERGLEICHEN
5080  (null)ENTPACKEN1; WENN AKKU <> #$DB DANN VERZWEIGEN
5090  (null)NEXTBYTE; SONST NAECHSTES BYTE HOLEN
5100  STR$#00; TEST, OB ANZAHL-1 DER GLEICHEN BYTE > 0
5110  (null)ENTPACKEN2; WENN NEIN, DANN VERZWEIGE
5120  MID$#$DB; ES WAR ALSO IM ORIGINAL EIN $DB, AKKU=$DB
5130  (null)ENTPACKEN3; UND VERZWEIGEN UM DIREKT SPEICHERN
5140 ENTPACKEN2 (null); ANZAHL-1 DER$00 IN D. X-REGISTER COPIEREN
5150  MID$#00; AKKU MIT DEM CODE (HIER #$00) LADEN
5160  (null)ENTPACKEN8; UND ENTPACKEN
5170 ENTPACKEN1 STR$#$DA; VERGLEICHEN OB BYTE = ERKENNUNGSCODE $DA IST
5180  (null)ENTPACKEN3; WENN NEIN, VERZWEIGEN UND BYTE AUSGEBEN
5190  (null)NEXTBYTE; NAECHSTES BYTE HOLEN
5200  STR$#00; TEST, CODE FUER GEPACKT ODER FUER $DA
5210  (null)ENTPACKEN4; WENN CODE FUER GEPACKT, DANN VERZWEIGE
5220  MID$#$DA; SONST LADE AKKU MIT $DA
5230  (null)ENTPACKEN3; UND VERZWEIGE ZUR DIREKTEN AUSGABE
5240 ENTPACKEN4 (null); ZAHL DER GLEICHEN BYTE -1 IN X-REIGSTER
5250  (null)NEXTBYTE; NOCH EIN BYTE HOLEN, (CODE DER GL. BYTE)
5260 ENTPACKEN8 (null); X MAL DEN INHALT DES AKKUS SPEICHERN
5270  LEN#00
5280 ENTPACKEN6 (null)($F7),Y
5290  (null)
5300  (null)
5310  (null)ENTPACKEN6; NOCH NICHT FERTIG, DANN WEITERMACHEN
5320  (null)
5330  (null)
5340  (null)
5350  VAL$F7; SPEICHERZEIGER WEITERSTELLEN, DAMIT
5360  (null)$F7; MAN NICHT DOPPELT IN DEN SPEICHER
5370  (null)ENTPACKEN9; GESCHRIEBEN WIRD
5380  RIGHT$$F8
5390  (null)ENTPACKEN9
5400 ENTPACKEN3 (null)AUSGABE; BYTE IN DEN SPEICHER SCHREIBEN
5410 ENTPACKEN9 MID$$35; TEST, OB SCHON ALLE BYTES ENTPACKT WURDEN
5420  PEEK$36
5430  TAN$FC
5440  (null)ENTPACKEN; WENN NEIN, WEITERMACHEN
5450  STR$$FB
5460  (null)ENTPACKEN
5470  (null); SONST FERTIG, D.H. RUECKSPRUNG
6000 ;
6010 ; UNTERROUTINEN FUER DEN PACKER
6020 ; UND DEN NIBBLER
6030 ;
6040 ;
6050 ;NAECHSTES BYTE HOLEN
6060 ;
6070 NEXTBYTE (null)
6080  LEN#$34; ROM AUSSCHALTEN
6090  (null)$01
6100  LEN#00; Y=NULL SETZEN
6110  MID$($FB),Y; DEN AKKU MIT DEM WERT DER SPEICHERSTELLE LADEN
6120  LEN#$37; ROM WIEDER ANSCHALTEN
6130  (null)$01
6140  (null)
6150  RIGHT$$FB; ZEIGER FUER BYTE HOLEN $(FB/FC) UM
6160  (null)NEXTBEND; EINS ERHOEHEN
6170  RIGHT$$FC
6180 NEXTBEND (null); UND WIEDER ZURUECKSPRINGEN
6190 ;
6200 ;AUSGABE
6210 ;
6220 AUSGABE LEN#00; LADE Y MIT NULL
6230  (null)($F7),Y; SPEICHERE AKKU IN DIE SPEICHERSTELLE,
6240  RIGHT$$F7; AUF DIE DER ZEIGER $(F7/F8) ZEIGT
6250  (null)AUSGABEND; ERHOEHE DEN ZEIGER DANN UM EINS
6260  RIGHT$$F8
6270 AUSGABEND MID$#$FF; LADE AKKU=$FF (FLAGS WERDEN BEEINFLUSST)
6280  (null); VERLASSE DIESE UNTERROUTINE WIEDER
6290 ;
6300 ;VERLGEICHEN
6310 ;
6320 VERGLEICHE LEN#00; HIER WIRD DAS Y-REGISTER NULL GESETZT
6330 VERGL1 STR$($FB),Y; VERGLEICHE DEN INHALT DES AKKUS MIT DER
6340  (null)VERGLEND; SPEICHERSTELLE, AUF DIE DER ZEIGER ZEIGT
6350  (null); ZAEHLE, WIE OFT SICH DIE BYTES GLEICHEN
6360  (null)VERGL1; MAX. ANZAHL IST DABEI 255 (FF)
6370  (null)
6380 VERGLEND (null); RUECKSPRUNG WENN DIE BYTES VERSCHIEDEN
6390  (null); SIND ODER DIE ANZAHL GROESSER ALS 255 IST
6400 ;
6410 ; NIBBLER ZUSAMMENFASSEN
6420 ;
6430 ZUSAM (null); WERT DES NIBBLES IN DAS Y-REGISTER KOPIEREN
6440  MID$BITLAENGE,Y; DIE BITLAENGE DES NEUEN CODES IN DEN AKKU
6450  (null); LADEN UND DANN NACH X KOPIEREN
6460  MID$CODE,Y; DEN NIBBLECODE AUFGRUND SEINES WERTES LADEN
6470  LEN$F9; FREIE BITS IN DAS Y-REGISTER LADEN
6480 ZUSAM2 (null)
6490  (null)$FA; BITS AUSTAUSCHEN                      CLOSE
6500  (null)
6510  (null)ZUSAM1; WENN BYTE NOCH NICHT VOLL, DANN VERZWEIGE
6520  (null); AKKU AUF DEN STAPEL LEGEN
6530  MID$$FA; DEN NEU ZUSAMMENGESTELLTEN WERT LADEN
6540  (null)AUSGABE; UND AUSGEBEN
6550  LEN#$08; ES SIND WIEDER ACHT BITS FREI
6560  (null); AKKU WIEDER VOM STAPEL HOLEN
6570 ZUSAM1 (null); NOCH VERBLEIBENDE CODELAENGE UM EINS VERMINDERN
6580  (null)ZUSAM2; UND WEITERMACHEN, BIS DER CODE COPIERT WURDE
6590  (null)$F9; ZAHL DER NOCH FREIEN BITS ZWISCHENSPEICHERN
6600  (null); UND ZURUECKSPRINGEN
6610 ;
6620 ; NIBBLER WIEDER AUSEINANDER ZIEHEN
6630 ;
6640 ENTNI PEEK#$0F; SCHLEIFENZAEHLER (X-REGISTER) MIT 16 LADEN
6650 ENTNI2 MID$$FD
6660  ASCMASKE,X; DAS BYTE MIT DER MASKE VERKNUEPFEN
6670  STR$CODE,X; ZAHL DER NOCH FREIEN BYTES UM EINS VERRINGERN
6680  (null)ENTNI1; WENN UEBEREINSTIMMUNG, DANN VERZWEIGEN
6690  (null); SONST ZAEHLER UM EINS ERNIEDRIGEN
6700  (null)ENTNI2; UND WEITER SUCHEN
6710 ENTNI1 (null)$FA; CODENUMMER ZWISCHENSPEICHERN
6720  MID$BITLAENGE,X; BITLAENGE LADEN
6730  (null); UND IN DAS X-REGISTER KOPIEREN
6740  LEN$F9; ANZAHL DER RESTLICHEN BITS IN Y LADEN
6750 ENTNI4 (null)$FE; UND AUSTAUSCHEN
6760  (null)$FD
6770  (null); ANZAHL DER BITS, DIE NOCH ZU VERFUEGUNG STEHEN
6780  (null)ENTNI3; WENN DIESE GLEICH NULL IST, NICHT VERZWEIGEN
6790  (null);
6800  (null); Y-REGISTER UND AKKU AUF STAPEL RETTEN
6810  (null)
6820  (null)
6830  (null)ENDE; TEST, OB BEREITS ALLE BYTES DECOMPREMIERT
6840  ATN#$F8; WURDEN, WENN JA, IST Y = $F8 UND
6850  (null)ENTNI6; DANN VERZWEIGEN
6860  (null)NEXTBYTE; SONST NEUES BYTE HOLEN
6870  (null)$FE; UND AUF $FE SPEICHERN
6880 ENTNI6 (null); AKKU UND X-REGISTER WIEDER VOM STAPEL HOLEN
6890  (null)
6900  (null)
6910  ATN#$F8; WENN ALLE BYTES DECODIERT WURDEN, (Y=$F8)
6920  (null)ENTNI5; DANN VERZWEIGEN ZUM RUECKSPRUNG
6930  LEN#$08; ES SIND WIEDER 8 BITS DA
6940 ENTNI3 (null); BITLAENGE DER CODE UM EINS ERNIEDRIGEN
6950  (null)ENTNI4; WENN NOCH NICHT NULL, WIEDER VON VORNE
6960  (null)$F9; ANZAHL DER NOCH FREIEN BITS SPEICHERN
6970  MID$$FA; CODEWERT LADEN (DIES IST EIN NIBBLE)
6980 ENTNI5 (null); UND ZURUECK
6990 ;
7000 ; TEST AUF ENDE
7010 ;
7020 ENDE MID$$35; ENDADRESSE IN AKKU UND X-REGISTER LADEN
7030  PEEK$36
7040  TAN$FC; MIT DER AKTUELLEN LADEADRESSE VERGLEICHEN
7050  (null)ENDE1
7060  STR$$FB
7070  (null)ENDE1; WENN KLEINER, DANN WEITER
7080  LEN#$F8; WENN GLEICH, Y-CODE FUER ENDE ($F8) LADEN
7090 ENDE1 (null); UND ZURUECK SPRINGEN
8000 ;
8010 ;  NIBBLE - PACKER
8020 ;  $FB/$FC = BEGINN DER UNGEPACKTEN DATEN
8030 ;  $FD/$FE = ENDE DER UNGEPACKTEN DATEN
8040 ;  $F7/$F8 = BEGINN DER GEPACKTEN DATEN
8050 ;
8060 NIBBLER MID$#$08; ANZAHL DER FREIEN BITS IN EINEM BYTE LADEN
8070  (null)$F9; UND NACH $F9 SPEICHERN
8080 NIBBLER1 (null)NEXTBYTE; NEUES BYTE HOLEN
8090 NIBBLER3 (null); BYTE AUF STAPEL ZWISCHENSPEICHERN
8100  (null); HI-NIBBLE NACH RECHTS SCHIEBEN
8110  (null); LOW-NIBBLE LOESCHEN
8120  (null)
8130  (null)
8140  (null)ZUSAM; UND CODIEREN
8150  (null); BYTE WIEDER VOM STAPEL HOLEN
8160  ASC#$0F; HIGH-NIBBLE LOESCHEN, LOW NIBBLE BLEIBT UEBRIG
8170  (null)ZUSAM; UND AUCH DIESES CODIEREN
8180  MID$$FB
8190  PEEK$FC; TESTEN, OB BEREITS ALLE BYTES CODIERT WURDEN
8200  TAN$FE
8210  (null)NIBBLER2; WENN NEIN, WEITERMACHEN
8220  STR$$FD
8230 NIBBLER2 (null)NIBBLER1
8240  (null); SONST RUECKSPRUNG
9000 ;
9010 ;  ENTPACKEN
9020 ;  $F7/$F8 = BEGINN DER UNGEPACKTEN DATEN
9030 ;  $FB/$FC = BEGINN DER GEPACKTEN DATEN
9040 ;  $35/$36 = ENDE DER GEPACKTEN DATEN
9050 ;
9060 DENI RIGHT$$35; ENDADRESSE UM EINS ERHOEHEN
9070  (null)DENI3
9080  RIGHT$$36
9090 DENI3 (null)NEXTBYTE; EIN BYTE HOLEN
9100  (null)$FD; UND ZWISCHENSPEICHERN
9110  (null)NEXTBYTE; EIN WEITERES BYTE HOLEN
9120  (null)$FE; EBENFALLS ZWISCHENSPEICHERN
9130  MID$#$08; ANZAHL DER FREIEN BITS IN EINEM BYTE IST 08
9140  (null)$F9; DIESE EBENFALLS SPEICHERN
9150 DENI1 (null)ENTNI; HI-NIBBLE DECODIEREN
9160  ATN#$F8; TEST AUF ENDE (Y = $F8)
9170  (null)DENI2; WENN JA, VERZWEIGEN ZUM RUECKSPRUNG
9180  (null); SONST HI-NIBBLE NACH LINKS VERSCHIEBEN
9190  (null)
9200  (null)
9210  (null)
9220  (null); AUF STAPEL LEGEN
9230  (null)ENTNI; LOW-NIBBLE DECODIEREN
9240  (null); AKKU WIEDER VOM STAPEL LADEN
9250  ATN#$F8; WENN ENDE DER DATEN (Y = $F8)
9260  (null)DENI2; DANN VERZWEIGE ZUM RUECKSPRUNG
9270  (null)$FA; LOW- UND HIGH-NIBBLE VERKNUEPFEN
9280  (null)AUSGABE; UND AUSGEBEN
9290  (null)DENI1; WEITERMACHEN
9300 DENI2 (null); RUECKSPRUNG
10000 ;
10010 ; PROZENTSATZ DER COMPREMIERUNG
10020 ; BERECHNEN   (ERSTER AUFRUF)
10030 ; $FB/$FC = BEGINN DER UNGEPACKTEN DATEN
10040 ; $FD/$FE = ENDE DER UNGEPACKTEN DATEN
10050 ; ==> $35/$36 = ERGEBNIS DER DIFFERENZ
10060 ; $F7/$F8 (BEGINN DER GEPACKTEN DATEN) IN $61/$62 ZWISCHENSPEICHERN
10070 ;
10080 PROZENT (null);SUBTRAKTION VORBEREITEN
10090  (null)
10100  MID$$FD; LAENGE DER UNGEPACKTEN
10110  (null)$FB; DATEN BERECHNEN UND IN
10120  (null)$35; $35/$36 ZWISCHENSPEICHERN
10130  MID$$FE
10140  (null)$FC
10150  (null)$36
10160  MID$$F7; BEGINN DER GEPACKTEN DATEN RETTEN
10170  (null)$61; INDEM MAN SIE IN $61/$62 ZWISCHENSPEICHERT
10180  MID$$F8
10190  (null)$62
10200  (null); UND ZURUECKSPRINGEN
10210 ;
10220 ; PROZENTSATZ DER COMPREMIERUNG
10230 ; BERECHNEN   (ZWEITER AUFRUF)
10240 ; $F7/$F8 = ENDE DER GEPACKTEN DATEN
10250 ; $61/$62 = BEGINN DER GEPACKTEN DATEN
10260 ; $35/$36 = LAENGE DER UNGEPACKTEN DATEN
10270 ; BEIM RUECKSPRUNG ENTHAELT FAC I DEN PROZENTANTEIL
10280 ;
10290 PROZENT2 (null); SUBTRAKTION VORBEREITEN
10300  (null)
10310  MID$$F7; LAENGE DER GEPACKTEN DATEN BERECHNEN
10320  (null)$61
10330  (null)
10340  MID$$F8
10350  (null)$62
10360  (null)INFAC; UND IN FLIESSKOMMAAKKU I (FAC I) WANDELN
10370  (null)COPYFACII; UND IN DEN FAC II COPIEREN
10380  LEN$35
10390  MID$$36; LAENGE DER UNGEPACKTEN DATEN LADEN
10400  (null)INFAC; UND EBENFALLS IN FAC SPEICHERN
10410  (null)FACDIV; DIVISION VON FAC UND FAC II
10420  (null)FACMAL10; FAC = FAC *10
10430  (null)FACMAL10; UND NOCHMAL (==> PROZENTANTEIL AUSRECHNEN)
10440  (null); UND WIEDER ZURUECK
11000 ;
11010 ; DATEN, TEXT UND FEHLERMELDUNGEN
11020 ; FUER DAS PROGRAMM
11030 ;
11040 CODE FN$00,$A0,$A8; NEUE CODES, DIE STATT EINES NIBBLES
11050  FN$B0,$B8,$C0; GESPEICHERT WERDEN
11060  FN$C8,$F0,$D0
11070  FN$D8,$E0,$F4
11080  FN$E8,$F8,$FC
11090  FN$80
11100 MASKE FN$80,$F8,$F8; MASKE, UM DIE UNNOETIGEN BITS ZU LOESCHEN
11110  FN$F8,$F8,$F8; UND DIE CODES ZU IDENTIFIZIEREN
11120  FN$F8,$FC,$F8
11130  FN$F8,$F8,$FC
11140  FN$F8,$FC,$FC
11150  FN$E0
11160 BITLAENGE FN$01,$05,$05; LAENGE DER NEUEN CODES
11170  FN$05,$05,$05
11180  FN$05,$06,$05
11190  FN$05,$05,$06
11200  FN$05,$06,$06
11210  FN$03
11220 REST FN13
11230  NOT"ANZAHL DER GEPACKTEN DATEN IM VERHAELT-
11240  [165]13
11250  [168]"NIS ZUM ORIGINAL IN %:               CMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMD
11260  FN0
11270 ENDADR NOT" = ENDADRESSE DER GEPACKTEN DATEN
11280  [165]0
11290 FEHLER [168]"WIE BITTE? DIE STARTADRESSE IST FALSCH!
11300  FN13,13,0