             ;
             ;
             ;      Erzeugt den Inline-Code fuer NEVER MIND CHAOS
             ;
             ;      Das assemblierte Programmm wird dann ganz
             ;        einfach mit INLINE-Help geladen.
             ;      Achtung: 28 Bytes Programmheader !!
             ;
             ;



             ;
             ;  DM: $4D05E      CSB: $1d048(a5)
             ;

crypt:       link       a6,#0
             movem.l    d5/d7/a3,-(sp)
             movea.l    $8(a6),a3     ; Anfangsadresse
             move.w     $c(a6),d7     ; Laenge in Words
             move.w     $e(a6),d5     ; Schluessel
             moveq.l    #0,d0
             move.w     d5,d0
.loop:       add.w      (a3),d0
             eor.w      d5,(a3)
             add.w      (a3)+,d0
             add.w      d7,d5
             subq.w     #1,d7
             bne.s      .loop
             movem.l    (sp)+,d5/d7/a3
             unlk       a6
             rts        


             ;
             ;  DM: $4D08C      CSB: $1d076(a5)
             ;

crypt_sum:   link       a6,#0
             movem.l    d2/d5/d7/a3,-(sp)
             movea.l    $8(a6),a3     ; Anfangsadresse
             move.w     $c(a6),d7     ; Laenge in Words
             move.w     $e(a6),d5     ; Schluessel
             moveq.l    #0,d0
             move.w     d5,d0
.loop:       move.w     (a3)+,d2
             add.w      d2,d0
             eor.w      d5,d2
             add.w      d2,d0
             add.w      d7,d5
             subq.w     #1,d7
             bne.s      .loop
             movem.l    (sp)+,d2/d5/d7/a3
             unlk       a6
             rts        


             ;
             ;  DM: $4D172      CSB: ???
             ;

check_sum1:  link       a6,#0
             movem.l    d1-d4/d7/a3,-(sp)
             movea.l    $8(a6),a3     ; Anfangsadresse
             move.w     $c(a6),d7     ; Laenge in Words
             moveq.l    #0,d0

             moveq.l    #%11,d3
             moveq.l    #0,d4         ; fuer btst d4,d1

             moveq.l    #-1,d1        ; Zaehler fuer add/eor/sub/eor
.loop:       addq.w     #1,d1
             and.w      d3,d1         ; Bereich 0-3
             beq.s      .add          ; Zaehler ist 0 -> add
             btst       d4,d1
             bne.s      .eor          ; Zaehler ist 1 oder 3 -> eor
.sub:        sub.w      (a3)+,d0      ; Zaehler ist 2 -> sub
             bra.s      .endloop
.add:        add.w      (a3)+,d0
             bra.s      .endloop
.eor:        move.w     (a3)+,d2
             eor.w      d2,d0
.endloop:    subq.w     #1,d7
             bne.s      .loop

             movem.l    (sp)+,d1-d4/d7/a3
             unlk       a6
             rts        


             ;
             ;  DM: $4D19C      CSB: ???
             ;

check_sum2:  link       a6,#0
             movem.l    d7/a3,-(sp)
             movea.l    $8(a6),a3     ; Anfangsadresse
             move.w     $c(a6),d7     ; Laenge in Words
             moveq.l    #0,d0
.loop:       add.w      (a3)+,d0
             subq.w     #1,d7
             bne.s      .loop
             movem.l    (sp)+,d7/a3
             unlk       a6
             rts        


             ;
             ;  CSB: $1d164(a5)
             ;

check_sum3:  link       a6,#0
             movem.l    d6/d7/a3,-(sp)
             movea.l    $8(a6),a3     ; Anfangsadresse
             move.l     $c(a6),d7     ; Laenge in Bytes
             moveq.l    #0,d0
             moveq.l    #0,d6
.loop:       move.b     (a3)+,d6
             add.w      d6,d0
             subq.l     #1,d7
             bne.s      .loop
             movem.l    (sp)+,d6/d7/a3
             unlk       a6
             rts        



             ;
             ; Optimierungen:
             ;   lsl.b  #1,dn   ->   add.b  dn,dn
             ;   lsl.w  #1,dn   ->   add.w  dn,dn
             ;   roxl.w #1,dn   ->   addx.w dn,dn
             ;   roxl.l #1,dn   ->   addx.l dn,dn
             ;

             ;
             ;  bytes_merge
             ;

bytes_merge: link       a6,#0
             movem.l    d1/d2,-(sp)
             move.w     $8(a6),d1     ; Byte 1
             move.w     $a(a6),d2     ; Byte 2
             moveq.l    #1,d0         ; Ende, wenn dieses Bit hinausfaellt
.loop:       add.b      d1,d1
             addx.w     d0,d0
             add.b      d2,d2
             addx.w     d0,d0
             bcc.s      .loop         ; hinausgeschobenes Bit gesetzt ?
             movem.l    (sp)+,d1/d2
             unlk       a6
             rts        


             ;
             ;  words_merge
             ;

words_merge: link       a6,#0
             movem.l    d1/d2,-(sp)
             move.w     $8(a6),d1     ; Word 1
             move.w     $a(a6),d2     ; Word 2
             moveq.l    #1,d0         ; Ende, wenn dieses Bit hinausfaellt
.loop:       add.w      d1,d1
             addx.l     d0,d0
             add.w      d2,d2
             addx.l     d0,d0
             bcc.s      .loop         ; hinausgeschobenes Bit gesetzt ?
             movem.l    (sp)+,d1/d2
             unlk       a6
             rts        


             ;
             ;  bits_mask
             ;

bits_mask:   link       a6,#0
             movem.l    d1-d3,-(sp)
             move.l     $8(a6),d0
             move.w     $c(a6),d1     ; untere Bitnummer
             move.w     $e(a6),d2     ; obere Bitnummer

             lsr.l      d1,d0         ; nach rechts schieben
             sub.w      d1,d2         ; Bitbreite

             moveq.l    #-2,d3        ; Maske in d3 berechnen
             lsl.l      d2,d3
             not.l      d3
             and.l      d3,d0         ; obere Bits wegblenden

             movem.l    (sp)+,d1-d3
             unlk       a6
             rts        




             ;
             ; Portrait-Konvertierungen aus 4 Planes
             ;   in einen GFA-Basic GET/PUT String.
             ;
             ;   portrait_2  ..  Mid-Rez   (2 Planes)
             ;   portrait_1  ..  High-Rez  (1 Plane)
             ;


             ;
             ; portrait_2(str_adr%,port_adr%,o1,o2,o3,o4,o5,o6,o7,o8)
             ;

portrait_2:  link       a6,#0
             movem.l    d1-d7/a0-a5,-(sp)

             movea.l    $8(a6),a1     ; String-Adresse
             movea.l    $c(a6),a0     ; Portrait-Adresse

             lea.l      $10(a6),a5    ; Zeiger die auf 8-Offsets fuer
             ;                            verschiedene Grafikdarstellungen

             moveq.l    #0,d1         ; die oberen Bits in d1 loeschen

             moveq.l    #29-1,d7      ; 29 Zeilen
.loop1:      moveq.l    #2-1,d6
.loop2:      movea.l    a5,a4         ; Zeiger auf Offset-Tabelle
             moveq.l    #4-1,d5       ; 4 Durchgaenge
.loop3:      move.l     (a4)+,d0      ; 2 Offsets holen
             move.b     0(a0,d0.w),d1 ; Byte laut Offset 1
             move.w     d1,-(sp)      ; auf den Stack
             swap.w     d0
             move.b     0(a0,d0.w),d1 ; Byte laut Offset 2
             move.w     d1,-(sp)      ; auf den Stack
             bsr        bytes_merge
             addq.w     #4,sp
             move.w     d0,(a1)+      ; im String eintragen
             dbra       d5,.loop3
             addq.l     #8,a0
             dbra       d6,.loop2
             dbra       d7,.loop1

             movem.l    (sp)+,d1-d7/a0-a5
             unlk       a6
             rts        




             ;
             ; portrait_1(str_adr%,port_adr%,o1,o2,o3,o4)
             ;

portrait_1:  link       a6,#0
             movem.l    d1-d7/a0-a5,-(sp)

             movea.l    $8(a6),a1     ; String-Adresse
             lea.l      8(a1),a2      ;   eine Zeile im PUT-String darunter

             movea.l    $c(a6),a0     ; Portrait-Adresse

             move.w     $10(a6),d1    ; 4 Offsets fuer verschiedene
             move.w     $12(a6),d2    ;   Grafikdarstellungen
             move.w     $14(a6),d3
             move.w     $16(a6),d4

             moveq.l    #29-1,d7      ; 29 Zeilen
.loop1:      moveq.l    #2-1,d6
.loop2:      move.w     0(a0,d2.w),-(sp)
             move.w     0(a0,d1.w),-(sp)
             bsr        words_merge
             addq.l     #4,sp
             move.l     d0,(a1)+      ; *a1++ = words_merge(*(a0+d1),*(a0+d2))
             move.w     0(a0,d4.w),-(sp)
             move.w     0(a0,d3.w),-(sp)
             bsr        words_merge
             addq.l     #4,sp
             move.l     d0,(a2)+      ; *a2++ = words_merge(*(a0+d3),*(a0+d4))
             addq.l     #8,a0
             dbra       d6,.loop2
             addq.w     #8,a1         ; 1 Zeile uebersprinegen
             addq.w     #8,a2         ; 1 Zeile ueberspringen
             dbra       d7,.loop1

             movem.l    (sp)+,d1-d7/a0-a5
             unlk       a6
             rts        




             ;
             ; m_mask_x(data%,mask%)
             ;

m_mask_x:    link       a6,#0
             movem.l    d1/d2/a1/a2,-(sp)

             movea.l    $8(a6),a1     ; data
             movea.l    $c(a6),a2     ; mask

             moveq.l    #16-1,d0      ; 16 Zeilen
.loop:       move.w     (a1)+,d1
             move.w     d1,d2         ; -- d2 = d1 = data
             add.w      d2,d2         ;   (statt lsl.w #1,d2)
             or.w       d1,d2
             lsr.w      #1,d1
             or.w       d1,d2         ; -- d2 = (d2<<1) | d1 | (d1>>1)
             or.w       d2,(a2)+      ; mask  |=  data | (data<<1) | (data>>1)
             dbf        d0,.loop

             movem.l    (sp)+,d1/d2/a1/a2
             unlk       a6
             rts        


             ;
             ; m_mask_y(data%,mask%)
             ;

m_mask_y:    link       a6,#0
             movem.l    d1/a0-a3,-(sp)

             movea.l    $8(a6),a1     ; data
             movea.l    $c(a6),a2     ; mask

             lea.l      2(a2),a3      ; 1 Zeile weiter

             ; 1. Zeile:
             move.w     (a1)+,d1
             or.w       d1,(a3)+

             ; Zeilen 2-15:

             moveq.l    #14-1,d0      ; 14 Zeilen
.loop:       move.w     (a1)+,d1
             or.w       d1,(a2)+
             or.w       d1,(a3)+
             dbf        d0,.loop

             ; 16. Zeile:
             move.w     (a1)+,d1
             or.w       d1,(a2)+

             movem.l    (sp)+,d1/a0-a3
             unlk       a6
             rts        




             ;
             ; Ende von NEVER_MC.IS
             ;

