*
 * Mesa 3-D graphics library
 * Copyright (C) 1995  Brian Paul  (brianp@ssec.wisc.edu)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *

* Assembler implementations of functions in ADisp_SWFS.c (Sam Jordan)

		mc68040
		fpu

		include "GL/Amigamesa.i"

		XDEF    _SWFSD_write_color_span_LUT8
		XDEF    _SWFSD_write_color_span_RGB15
		XDEF    _SWFSD_write_color_span_RGB15PC
		XDEF    _SWFSD_write_color_span_RGB16
		XDEF    _SWFSD_write_color_span_RGB16PC
		XDEF    _SWFSD_write_color_span_ARGB
		XDEF    _SWFSD_write_color_span_BGRA
		XDEF    _SWFSD_write_color_span3_LUT8
		XDEF    _SWFSD_write_color_span3_RGB15
		XDEF    _SWFSD_write_color_span3_RGB15PC
		XDEF    _SWFSD_write_color_span3_RGB16
		XDEF    _SWFSD_write_color_span3_RGB16PC
		XDEF    _SWFSD_write_color_span3_ARGB
		XDEF    _SWFSD_write_color_span3_BGRA
		XDEF    _SWFSD_write_monorgba_span_LUT8
		XDEF    _SWFSD_write_monoci_span_LUT8
		XDEF    _SWFSD_write_mono_span_RGB16
		XDEF    _SWFSD_write_mono_span_ARGB
		XDEF    _SWFSD_write_color_pixels_LUT8
		XDEF    _SWFSD_write_color_pixels_RGB15
		XDEF    _SWFSD_write_color_pixels_RGB15PC
		XDEF    _SWFSD_write_color_pixels_RGB16
		XDEF    _SWFSD_write_color_pixels_RGB16PC
		XDEF    _SWFSD_write_color_pixels_ARGB
		XDEF    _SWFSD_write_color_pixels_BGRA
		XDEF    _SWFSD_write_monorgba_pixels_LUT8
		XDEF    _SWFSD_write_monoci_pixels_LUT8
		XDEF    _SWFSD_write_mono_pixels_RGB16
		XDEF    _SWFSD_write_mono_pixels_ARGB
		XDEF    _SWFSD_write_index_span32_LUT8
		XDEF    _SWFSD_write_index_span32_RGB16
		XDEF    _SWFSD_write_index_span32_ARGB
		XDEF    _SWFSD_write_index_span_LUT8
		XDEF    _SWFSD_write_index_span_RGB16
		XDEF    _SWFSD_write_index_span_ARGB
		XDEF    _SWFSD_write_index_pixels_LUT8
		XDEF    _SWFSD_write_index_pixels_RGB16
		XDEF    _SWFSD_write_index_pixels_ARGB
		XDEF    _SWFSD_read_color_span_LUT8
		XDEF    _SWFSD_read_color_span_RGB15
		XDEF    _SWFSD_read_color_span_RGB15PC
		XDEF    _SWFSD_read_color_span_RGB16
		XDEF    _SWFSD_read_color_span_RGB16PC
		XDEF    _SWFSD_read_color_span_ARGB
		XDEF    _SWFSD_read_color_span_BGRA
		XDEF    _SWFSD_read_index_span_LUT8
		XDEF    _SWFSD_read_color_pixels_LUT8
		XDEF    _SWFSD_read_color_pixels_RGB15
		XDEF    _SWFSD_read_color_pixels_RGB15PC
		XDEF    _SWFSD_read_color_pixels_RGB16
		XDEF    _SWFSD_read_color_pixels_RGB16PC
		XDEF    _SWFSD_read_color_pixels_ARGB
		XDEF    _SWFSD_read_color_pixels_BGRA
		XDEF    _SWFSD_read_index_pixels_LUT8


;// EVALPTRN_D_SPAN (macro)
*
*       EVALPTRN_D_SPAN x,y
*
*       parameters must be passed in registers
*       x gets the starting index (unsigned word)
*

EVALPTRN_D_SPAN MACRO
		and.b   #$7,\2
		lsl.b   #4,\2
		and     #$7,\1
		add.b   \2,\1
		ENDM
;;/
;// EVALPEN_D_SPAN (macro)
*
*       EVALPEN_D_SPAN context,rgba,index,scratch,scratch2
*
*       parameters must be passed in registers
*       index must be unsigned word
*       the parameters y, rgba, scratch, scratch2 are trashed
*       result is returned in rgba as unsigned long
*

EVALPEN_D_SPAN  MACRO
		move.b  (AMC_DMATRIX,\1,\3.w),\5
		addq    #1,\3
		bclr    #3,\3
		lsr     #8,\2
		move    (AMC_DTABLE,\1,\2.w*2),\4
		sub.b   \5,\4
		sgt.b   \4
		addq    #1,\4
		lsr     #8,\4
		lsr.l   #8,\2
		lsr     #8,\2
		move    (AMC_DTABLE,\1,\2.w*2),\2
		sub.b   \5,\2
		sgt.b   \2
		addq    #1,\2
		lsr     #8,\2
		add     \2,\2
		add     \2,\4
		add     \2,\2
		add     \2,\4
		swap    \2
		move    (AMC_DTABLE,\1,\2.w*2),\2
		sub.b   \5,\2
		sgt.b   \2
		addq    #1,\2
		lsr     #8,\2
		mulu    #36,\2
		add     \2,\4
		move.l  (AMC_COLTABLE,\1,\4.w*4),\2
		ENDM
;;/
;// EVALPEN_D_PIX (macro)
*
*       EVALPEN_D_PIX context,rgba,x,y
*
*       parameters must be passed in registers
*       the parameters x, y, rgba are trashed
*       result is returned in rgba as unsigned long
*

EVALPEN_D_PIX   MACRO
		and     #$7,\4
		lsl     #4,\4
		and.b   #$7,\3
		add.b   \3,\4
		move.b  (AMC_DMATRIX,\1,\4.w),\4
		lsr     #8,\2
		move    (AMC_DTABLE,\1,\2.w*2),\3
		sub.b   \4,\3
		sgt.b   \3
		addq    #1,\3
		lsr     #8,\3
		lsr.l   #8,\2
		lsr     #8,\2
		move    (AMC_DTABLE,\1,\2.w*2),\2
		sub.b   \4,\2
		sgt.b   \2
		addq    #1,\2
		lsr     #8,\2
		add     \2,\2
		add     \2,\3
		add     \2,\2
		add     \2,\3
		swap    \2
		move    (AMC_DTABLE,\1,\2.w*2),\2
		sub.b   \4,\2
		sgt.b   \2
		addq    #1,\2
		lsr     #8,\2
		mulu    #36,\2
		add     \2,\3
		move.l  (AMC_COLTABLE,\1,\3.w*4),\2
		ENDM
;;/
;// EVALMPEN_D_SPAN (macro)
*
*       EVALMPEN_D_SPAN context,dmatrix,rgba,x,y,scratch3,scratch4,dest
*
*       parameters must be passed in registers
*       index must be unsigned word
*       the parameters dmatrix, rgba, x, y, scratch2, scratch3 are trashed
*       result is stored into dest
*

EVALMPEN_D_SPAN MACRO
		and.b   #$7,\5
		lsl.b   #4,\5
		and     #$7,\4
		add.b   \5,\4
		lea     (AMC_DMATRIX,\1,\4.w),\2
		lsr     #8,\3
		move    (AMC_DTABLE,\1,\3.w*2),\5
		lsr.l   #8,\3
		lsr     #8,\3
		move    (AMC_DTABLE,\1,\3.w*2),\4
		swap    \3
		move    (AMC_DTABLE,\1,\3.w*2),\3
		swap    \3
		move    #8-1,\3
.loop\@
		swap    \3
		move.b  (\2)+,\7
		move    \5,\6
		sub.b   \7,\6
		sgt.b   \6
		addq    #1,\6
		lsr     #8,\6
		swap    \5
		move    \4,\5
		sub.b   \7,\5
		sgt.b   \5
		addq    #1,\5
		lsr     #8,\5
		add     \5,\5
		add     \5,\6
		add     \5,\5
		add     \5,\6
		move    \3,\5
		sub.b   \7,\5
		sgt.b   \5
		addq    #1,\5
		lsr     #8,\5
		lsl     #2,\5
		add     \5,\6
		lsl     #3,\5
		add     \5,\6
		swap    \5
		move.b  (AMC_COLTABLE+3,\1,\6.w*4),(\8)+
		swap    \3
		dbra    \3,.loop\@
		subq.l  #8,\8
		ENDM
;;/
;// EVALVAL_D_PIX (macro)
*
*       EVALVAL_D_PIX context,rgba,g,b
*
*       parameters must be passed in registers
*       the results are returned in rgba,g,b
*

EVALVAL_D_PIX   MACRO
		lsr     #8,\2
		move    (AMC_DTABLE,\1,\2.w*2),\4
		lsr.l   #8,\2
		lsr     #8,\2
		move    (AMC_DTABLE,\1,\2.w*2),\3
		swap    \2
		move    (AMC_DTABLE,\1,\2.w*2),\2
		ENDM
;;/
;// EVALMPEN_D_PIX (macro)
*
*       EVALMPEN_D_PIX context,x,y,r,g,b,scratch1
*
*       parameters must be passed in registers
*       r,g,b contain the divmod51 values for rgb
*       the parameters x, y, scratch1 are trashed
*       result is returned in x as unsigned long
*

EVALMPEN_D_PIX  MACRO
		and     #$7,\3
		lsl     #4,\3
		and.b   #$7,\2
		add.b   \2,\3
		move.b  (AMC_DMATRIX,\1,\3.w),\3
		move    \6,\2
		sub.b   \3,\2
		sgt.b   \2
		addq    #1,\2
		lsr     #8,\2
		move    \5,\7
		sub.b   \3,\7
		sgt.b   \7
		addq    #1,\7
		lsr     #8,\7
		mulu    #6,\7
		add     \7,\2
		move    \4,\7
		sub.b   \3,\7
		sgt.b   \7
		addq    #1,\7
		lsr     #8,\7
		mulu    #36,\7
		add     \7,\2
		move.l  (AMC_COLTABLE,\1,\2.w*4),\2
		ENDM
;;/

;// SWFSD_write_color_span_LUT8
*
* void SWFSD_write_color_span_LUT8(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d6/a2/a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d3,a3
		EVALPTRN_D_SPAN d1,d2
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,(a3)
		bra.b   .skip
.next
		addq    #1,d1
		bclr    #3,d1
.skip
		addq.l  #4,a1
		addq.l  #1,a3
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d5
		neg.l   d5
		and.l   #$3,d5
		beq.b   .main
		cmp.l   d5,d0
		blt.b   .main
		sub.l   d5,d0
		subq    #1,d5
.first
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,(a3)+
		dbra    d5,.first
.main
		tst     d0
		beq     .end
		move    d0,d6
		lsr     #2,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		lsl     #8,d5
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		lsl.l   #8,d5
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		lsl.l   #8,d5
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		move.l  d5,(a3)+
		dbra    d0,.loop
.cont
		move    d6,d0
		and     #$3,d0
		beq     .end
		subq    #1,d0
.loop2
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,(a3)+
		dbra    d0,.loop2
.end
		movem.l (sp)+,d2-d6/a2/a3
		rts
;;/
;// SWFSD_write_color_span_RGB15
*
* void SWFSD_write_color_span_RGB15(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_RGB15

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)
.next
		addq.l  #4,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		move.l  d4,(a0)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span_RGB15PC
*
* void SWFSD_write_color_span_RGB15PC(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_RGB15PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)
.next
		addq.l  #4,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		move.l  d4,(a0)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span_RGB16
*
* void SWFSD_write_color_span_RGB16(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)
.next
		addq.l  #4,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		move.l  d4,(a0)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span_RGB16PC
*
* void SWFSD_write_color_span_RGB16PC(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_RGB16PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)
.next
		addq.l  #4,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		move.l  d4,(a0)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span_ARGB
*
* void SWFSD_write_color_span_ARGB(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    3
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2/d3/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		ror.l   #8,d1
		move.l  d1,(a0)
.next
		addq.l  #4,a1
		addq.l  #4,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  (a1)+,d1
		ror.l   #8,d1
		move.l  d1,(a0)+
		dbra    d0,.fullwrite
.end
		movem.l (sp)+,d2/d3/a2
		rts
;;/
;// SWFSD_write_color_span_BGRA
*
* void SWFSD_write_color_span_BGRA(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_write_color_span_BGRA

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    3
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2/d3/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		ror.l   #8,d1
		ror     #8,d1
		swap    d1
		ror     #8,d1
		move.l  d1,(a0)
.next
		addq.l  #4,a1
		addq.l  #4,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  (a1)+,d1
		ror.l   #8,d1
		ror     #8,d1
		swap    d1
		ror     #8,d1
		move.l  d1,(a0)+
		dbra    d0,.fullwrite
.end
		movem.l (sp)+,d2/d3/a2
		rts
;;/
;// SWFSD_write_color_span3_LUT8
*
* void SWFSD_write_color_span3_LUT8(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d6/a2/a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d3,a3
		EVALPTRN_D_SPAN d1,d2
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,(a3)
		bra.b   .skip
.next
		addq    #1,d1
		bclr    #3,d1
.skip
		addq.l  #3,a1
		addq.l  #1,a3
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d5
		neg.l   d5
		and.l   #$3,d5
		beq.b   .main
		cmp.l   d5,d0
		blt.b   .main
		sub.l   d5,d0
		subq    #1,d5
.first
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,(a3)+
		subq.l  #1,a1
		dbra    d5,.first
.main
		tst     d0
		beq     .end
		move    d0,d6
		lsr     #2,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		subq.l  #1,a1
		lsl     #8,d5
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		subq.l  #1,a1
		lsl.l   #8,d5
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		subq.l  #1,a1
		lsl.l   #8,d5
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,d5
		subq.l  #1,a1
		move.l  d5,(a3)+
		dbra    d0,.loop
.cont
		move    d6,d0
		and     #$3,d0
		beq     .end
		subq    #1,d0
.loop2
		move.l  (a1)+,d3
		EVALPEN_D_SPAN  a0,d3,d1,d2,d4
		move.b  d3,(a3)+
		subq.l  #1,a1
		dbra    d0,.loop2
.end
		movem.l (sp)+,d2-d6/a2/a3
		rts
;;/
;// SWFSD_write_color_span3_RGB15
*
* void SWFSD_write_color_span3_RGB15(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_RGB15

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)
.next
		addq.l  #3,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
		subq.l  #1,a1
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		subq.l  #1,a1
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		move.l  d4,(a0)+
		subq.l  #1,a1
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span3_RGB15PC
*
* void SWFSD_write_color_span3_RGB15PC(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_RGB15PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)
.next
		addq.l  #3,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
		subq.l  #1,a1
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		subq.l  #1,a1
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		move.l  d4,(a0)+
		subq.l  #1,a1
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #3,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span3_RGB16
*
* void SWFSD_write_color_span3_RGB16(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)
.next
		addq.l  #3,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
		subq.l  #1,a1
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		subq.l  #1,a1
		move    d1,d4
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		move.l  d4,(a0)+
		subq.l  #1,a1
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span3_RGB16PC
*
* void SWFSD_write_color_span3_RGB16PC(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_RGB16PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq     .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a2)+
		beq.b   .next
		moveq   #11,d2
		move.l  (a1),d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)
.next
		addq.l  #3,a1
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
		subq.l  #1,a1
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		subq.l  #1,a1
		ror     #8,d4
		swap    d4
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		move    d1,d4
		ror     #8,d4
		move.l  d4,(a0)+
		subq.l  #1,a1
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		moveq   #11,d2
		move.l  (a1)+,d1
		lsr.l   d2,d1
		move.l  d1,d2
		lsr.l   #2,d2
		move.l  d2,d3
		lsr.l   #3,d3
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d3
		or      d2,d1
		or      d3,d1
		ror     #8,d1
		move    d1,(a0)+
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_color_span3_ARGB
*
* void SWFSD_write_color_span3_ARGB(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    3
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2/d3/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		st      d1
		ror.l   #8,d1
		move.l  d1,(a0)
.next
		addq.l  #3,a1
		addq.l  #4,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  (a1)+,d1
		st      d1
		ror.l   #8,d1
		move.l  d1,(a0)+
		subq.l  #1,a1
		dbra    d0,.fullwrite
.end
		movem.l (sp)+,d2/d3/a2
		rts
;;/
;// SWFSD_write_color_span3_BGRA
*
* void SWFSD_write_color_span3_BGRA(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         const GLubyte rgba[][3], const GLubyte mask[])
*

_SWFSD_write_color_span3_BGRA

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    3
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2/d3/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0
		tst.l   a2
		beq.b   .fullwrite
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		st      d1
		ror.l   #8,d1
		ror     #8,d1
		swap    d1
		ror     #8,d1
		move.l  d1,(a0)
.next
		addq.l  #3,a1
		addq.l  #4,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  (a1)+,d1
		ror.l   #8,d1
		ror     #8,d1
		swap    d1
		ror     #8,d1
		move.l  d1,(a0)+
		subq.l  #1,a1
		dbra    d0,.fullwrite
.end
		movem.l (sp)+,d2/d3/a2
		rts
;;/

;// SWFSD_write_monorgba_span_LUT8
*
* void SWFSD_write_monorgba_span_LUT8(GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                       const GLubyte mask[])
*

_SWFSD_write_monorgba_span_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_PIXELARGB(a0),d5
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		lea     AMC_DMATRIX+128(a0),a2
		EVALMPEN_D_SPAN a0,a1,d5,d1,d2,d3,d4,a2
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .mask(sp),a1
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		move.l  AMC_DRAWBUFFER(a0),a0
		mulu    d2,d3
		add.l   d1,d3
		add.l   d3,a0
		tst.l   a1
		beq.b   .fullwrite
		subq    #1,d0
		moveq   #0,d1
.partial_write
		tst.b   (a1)+
		beq.b   .next
		move.b  0(a2,d1.w),(a0)
.next
		addq    #1,d1
		and     #$7,d1
		addq.l  #1,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  d0,d1
		and.l   #$7,d1
		lsr.l   #3,d0
		subq    #1,d0
		bmi.b   .cont
.loop2
		move.l  (a2),(a0)+
		move.l  4(a2),(a0)+
		dbra    d0,.loop2
.cont
		subq    #1,d1
		bmi.b   .end
.loop3
		move.b  (a2)+,(a0)+
		dbra    d1,.loop3
.end
		movem.l (sp)+,d2-d5/a2
		rts
;;/
;// SWFSD_write_monoci_span_LUT8
*
* void SWFSD_write_monoci_span_LUT8(GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                       const GLubyte mask[])
*

_SWFSD_write_monoci_span_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    2
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2/d3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .mask(sp),a1
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		add.l   d1,d3
		move.l  AMC_PIXEL(a0),d2
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0
		tst.l   a1
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a1)+
		beq.b   .next
		move.b  d2,(a0)
.next
		addq.l  #1,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  d2,d3
		lsl.l   #8,d3
		or.b    d2,d3
		move.l  d3,d2
		swap    d2
		or      d3,d2
		move.l  d0,d1
		and.l   #$f,d1
		lsr.l   #4,d0
		subq    #1,d0
		bmi.b   .cont
.loop2
		move.l  d2,(a0)+
		move.l  d2,(a0)+
		move.l  d2,(a0)+
		move.l  d2,(a0)+
		dbra    d0,.loop2
.cont
		subq    #1,d1
		bmi.b   .end
.loop3
		move.b  d2,(a0)+
		dbra    d1,.loop3
.end
		movem.l (sp)+,d2/d3
		rts
;;/
;// SWFSD_write_mono_span_RGB16
*
* void SWFSD_write_mono_span_RGB16(GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                       const GLubyte mask[])
*

_SWFSD_write_mono_span_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    2
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2/d3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .mask(sp),a1
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		add.l   d1,d3
		add.l   d1,d3
		move.l  AMC_PIXEL(a0),d2
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0
		tst.l   a1
		beq.b   .fullwrite
		subq    #1,d0
.partial_write
		tst.b   (a1)+
		beq.b   .next
		move    d2,(a0)
.next
		addq.l  #2,a0
		dbra    d0,.partial_write
		bra.b   .end
.fullwrite
		move.l  d2,d3
		swap    d3
		or      d2,d3
		move.l  d0,d1
		and.l   #$7,d1
		lsr.l   #3,d0
		subq    #1,d0
		bmi.b   .cont
.loop2
		move.l  d3,(a0)+
		move.l  d3,(a0)+
		move.l  d3,(a0)+
		move.l  d3,(a0)+
		dbra    d0,.loop2
.cont
		subq    #1,d1
		bmi.b   .end
.loop3
		move    d3,(a0)+
		dbra    d1,.loop3
.end
		movem.l (sp)+,d2/d3
		rts
;;/
;// SWFSD_write_mono_span_ARGB
*
* void SWFSD_write_mono_span_ARGB(GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                       const GLubyte mask[])
*

_SWFSD_write_mono_span_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    2
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2/d3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .mask(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_PIXEL(a0),d2
		move.l  AMC_DRAWBUFFER(a0),a0
		add.l   d3,a0

		tst.l   a1
		beq.b   .fullwrite
		subq    #1,d0

.partial_write
		tst.b   (a1)+
		beq.b   .next
		move.l  d2,(a0)
.next
		addq.l  #4,a0
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		move.l  d0,d1
		and.l   #$3,d1
		lsr.l   #2,d0
		subq    #1,d0
		bmi.b   .cont
.loop2
		move.l  d2,(a0)+
		move.l  d2,(a0)+
		move.l  d2,(a0)+
		move.l  d2,(a0)+
		dbra    d0,.loop2
.cont
		subq    #1,d1
		bmi.b   .end
.loop3
		move.l  d2,(a0)+
		dbra    d1,.loop3
.end
		movem.l (sp)+,d2/d3
		rts
;;/

;// SWFSD_write_color_pixels_LUT8
*
* void SWFSD_write_color_pixels_LUT8(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    9
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d6/a2-a5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d1
		move.l  AMC_DRAWBUFFER(a0),a5
		subq.l  #1,d1
		move.l  AMC_BPROW(a0),d5
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  (a3),d4
		move.l  (a1),d2
		move.l  (a2),d3
		move.l  d1,d6
		sub.l   d3,d6
		mulu    d5,d6
		add.l   d2,d6
		EVALPEN_D_PIX   a0,d4,d2,d3
		move.b  d4,0(a5,d6.l)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d6/a2-a5
		rts
;;/
;// SWFSD_write_color_pixels_RGB15
*
* void SWFSD_write_color_pixels_RGB15(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_RGB15

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		moveq   #11,d4
		move.l  (a3),d1
		lsr.l   d4,d1
		move.l  d1,d4
		lsr.l   #3,d4
		move.l  d4,d5
		lsr.l   #3,d5
		and     #$1f,d1
		and     #$03e0,d4
		and     #$7c00,d5
		or      d4,d1
		or      d5,d1
		move.l  d3,d5
		sub.l   (a2),d5
		mulu    d2,d5
		add.l   (a1),d5
		move    d1,0(a0,d5.l*2);
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a4
		rts
;;/
;// SWFSD_write_color_pixels_RGB15PC
*
* void SWFSD_write_color_pixels_RGB15PC(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_RGB15PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		moveq   #11,d4
		move.l  (a3),d1
		lsr.l   d4,d1
		move.l  d1,d4
		lsr.l   #3,d4
		move.l  d4,d5
		lsr.l   #3,d5
		and     #$1f,d1
		and     #$03e0,d4
		and     #$7c00,d5
		or      d4,d1
		or      d5,d1
		move.l  d3,d5
		sub.l   (a2),d5
		mulu    d2,d5
		add.l   (a1),d5
		ror     #8,d1
		move    d1,0(a0,d5.l*2);
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a4
		rts
;;/
;// SWFSD_write_color_pixels_RGB16
*
* void SWFSD_write_color_pixels_RGB16(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		moveq   #11,d4
		move.l  (a3),d1
		lsr.l   d4,d1
		move.l  d1,d4
		lsr.l   #2,d4
		move.l  d4,d5
		lsr.l   #3,d5
		and     #$1f,d1
		and     #$07e0,d4
		and     #$f800,d5
		or      d4,d1
		or      d5,d1
		move.l  d3,d5
		sub.l   (a2),d5
		mulu    d2,d5
		add.l   (a1),d5
		move    d1,0(a0,d5.l*2);
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a4
		rts
;;/
;// SWFSD_write_color_pixels_RGB16PC
*
* void SWFSD_write_color_pixels_RGB16PC(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_RGB16PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		moveq   #11,d4
		move.l  (a3),d1
		lsr.l   d4,d1
		move.l  d1,d4
		lsr.l   #2,d4
		move.l  d4,d5
		lsr.l   #3,d5
		and     #$1f,d1
		and     #$07e0,d4
		and     #$f800,d5
		or      d4,d1
		or      d5,d1
		move.l  d3,d5
		sub.l   (a2),d5
		mulu    d2,d5
		add.l   (a1),d5
		ror     #8,d1
		move    d1,0(a0,d5.l*2);
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a4
		rts
;;/
;// SWFSD_write_color_pixels_ARGB
*
* void SWFSD_write_color_pixels_ARGB(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    6
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #2,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  (a3),d1
		ror.l   #8,d1
		move.l  d3,d4
		sub.l   (a2),d4
		mulu    d2,d4
		add.l   (a1),d4
		move.l  d1,0(a0,d4.l*4);
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a4
		rts
;;/
;// SWFSD_write_color_pixels_BGRA
*
* void SWFSD_write_color_pixels_BGRA(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                               const GLubyte rgba[][4], const GLubyte mask[] )
*

_SWFSD_write_color_pixels_BGRA

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    6
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #2,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  (a3),d1
		ror.l   #8,d1
		ror     #8,d1
		swap    d1
		ror     #8,d1
		move.l  d3,d4
		sub.l   (a2),d4
		mulu    d2,d4
		add.l   (a1),d4
		move.l  d1,0(a0,d4.l*4);
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a4
		rts
;;/

;// SWFSD_write_monorgba_pixels_LUT8
*
* void SWFSD_write_monorgba_pixels_LUT8(GLcontext *ctx, GLuint n,
*                                 const GLint x[], const GLint y[],
*                                 const GLubyte mask[] )
*

_SWFSD_write_monorgba_pixels_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    11
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2-d7/a2-a6,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_PIXELARGB(a0),d1
		EVALVAL_D_PIX   a0,d1,d4,d5
		move.l  .mask(sp),a1
		move.l  .x(sp),a2
		move.l  .y(sp),a3
		move.l  AMC_HEIGHT(a0),a4
		subq.l  #1,a4
		move.l  AMC_BPROW(a0),d2
		move.l  AMC_DRAWBUFFER(a0),a5
.loop
		tst.b   (a1)+
		beq.b   .next
		move.l  a4,d3
		move.l  (a3),d6
		sub.l   d6,d3
		mulu    d2,d3
		move.l  (a2),d7
		add.l   d7,d3
		move.l  d3,a6
		EVALMPEN_D_PIX  a0,d7,d6,d1,d4,d5,d3
		move.b  d7,0(a5,a6.l)
.next
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d7/a2-a6
		rts
;;/
;// SWFSD_write_monoci_pixels_LUT8
*
* void SWFSD_write_monoci_pixels_LUT8(GLcontext *ctx, GLuint n,
*                                 const GLint x[], const GLint y[],
*                                 const GLubyte mask[] )
*

_SWFSD_write_monoci_pixels_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .mask(sp),a1
		move.l  .x(sp),a2
		move.l  .y(sp),a3
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_PIXEL(a0),d1
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a1)+
		beq.b   .next
		move.l  d3,d4
		sub.l   (a3),d4
		mulu    d2,d4
		add.l   (a2),d4
		move.b  d1,0(a0,d4.l)
.next
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_mono_pixels_RGB16
*
* void SWFSD_write_mono_pixels_RGB16(GLcontext *ctx, GLuint n,
*                                 const GLint x[], const GLint y[],
*                                 const GLubyte mask[] )
*

_SWFSD_write_mono_pixels_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .mask(sp),a1
		move.l  .x(sp),a2
		move.l  .y(sp),a3
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_PIXEL(a0),d1
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a1)+
		beq.b   .next
		move.l  d3,d4
		sub.l   (a3),d4
		mulu    d2,d4
		add.l   (a2),d4
		move    d1,0(a0,d4.l*2)
.next
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_mono_pixels_ARGB
*
* void SWFSD_write_mono_pixels_ARGB(GLcontext *ctx, GLuint n,
*                                 const GLint x[], const GLint y[],
*                                 const GLubyte mask[] )
*

_SWFSD_write_mono_pixels_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .mask(sp),a1
		move.l  .x(sp),a2
		move.l  .y(sp),a3
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_PIXEL(a0),d1
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #2,d2
		move.l  AMC_DRAWBUFFER(a0),a0
.loop
		tst.b   (a1)+
		beq.b   .next
		move.l  d3,d4
		sub.l   (a3),d4
		mulu    d2,d4
		add.l   (a2),d4
		move.l  d1,0(a0,d4.l*4)
.next
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/

;// SWFSD_write_index_span32_LUT8
*
* void SWFSD_write_index_span32_LUT8(GLcontext *ctx, GLuint n,
*                                GLint x, GLint y,
*                                const GLuint index[],
*                                const GLubyte mask[])
*

_SWFSD_write_index_span32_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d3,a3
		lea     AMC_PENCONV(a0),a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0

.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		move.b  0(a0,d1.l),(a3)
.next
		addq.l  #4,a1
		addq.l  #1,a3
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		move.l  a3,d1
		neg.l   d1
		and.l   #$3,d1
		beq.b   .main
		cmp.l   d1,d0
		blt.b   .main
		sub.l   d1,d0
		subq    #1,d1
.first
		move.l  (a1)+,d3
		move.b  0(a0,d3.l),(a3)+
		dbra    d1,.first
.main
		tst     d0
		beq     .end
		move    d0,d1
		lsr     #2,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a1)+,d3
		move.b  0(a0,d3.l),d4
		lsl     #8,d4
		move.l  (a1)+,d3
		move.b  0(a0,d3.l),d4
		lsl.l   #8,d4
		move.l  (a1)+,d3
		move.b  0(a0,d3.l),d4
		lsl.l   #8,d4
		move.l  (a1)+,d3
		move.b  0(a0,d3.l),d4
		move.l  d4,(a3)+
		dbra    d0,.loop
.cont
		move    d1,d0
		and     #$3,d0
		beq     .end
		subq    #1,d0
.loop2
		move.l  (a1)+,d3
		move.b  0(a0,d3.l),(a3)+
		dbra    d0,.loop2
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_index_span32_RGB16
*
* void SWFSD_write_index_span32_RGB16(GLcontext *ctx, GLuint n,
*                                GLint x, GLint y,
*                                const GLuint index[],
*                                const GLubyte mask[])
*

_SWFSD_write_index_span32_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a3
		move.l  AMC_COLORTABLE2(a0),a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0

.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		move    2(a0,d1.l*4),(a3)
.next
		addq.l  #4,a1
		addq.l  #2,a3
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		move.l  (a1),d1
		move    2(a0,d1.l*4),(a3)+
.main
		tst     d0
		beq     .end
		move    d0,d1
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a1)+,d1
		move    2(a0,d1.l*4),d4
		swap    d4
		move.l  (a1)+,d1
		move    2(a0,d1.l*4),d4
		move.l  d4,(a3)+
		dbra    d0,.loop
.cont
		move    d1,d0
		and     #$1,d0
		beq     .end
		move.l  (a1)+,d1
		move    2(a0,d1.l*4),(a3)+
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_index_span32_ARGB
*
* void SWFSD_write_index_span32_ARGB(GLcontext *ctx, GLuint n,
*                                GLint x, GLint y,
*                                const GLuint index[],
*                                const GLubyte mask[])
*

_SWFSD_write_index_span32_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		lsl.l   #2,d1
		add.l   d1,d3
		add.l   d3,a3
		move.l  AMC_COLORTABLE2(a0),a0
		tst.l   a2
		beq.b   .fullwrite

.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.l  (a1),d1
		move.l  0(a0,d1.l*4),(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a3
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		move.l  (a1)+,d1
		move.l  0(a0,d1.l*4),(a3)+
		dbra    d0,.fullwrite
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_index_span_LUT8
*
* void SWFSD_write_index_span_LUT8(GLcontext *ctx, GLuint n,
*                                GLint x, GLint y,
*                                const GLubyte index[],
*                                const GLubyte mask[])
*

_SWFSD_write_index_span_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d3,a3
		lea     AMC_PENCONV(a0),a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
		moveq   #0,d1
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.b  (a1),d1
		move.b  0(a0,d1.l),(a3)
.next
		addq.l  #1,a1
		addq.l  #1,a3
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		moveq   #0,d3
		move.l  a3,d1
		neg.l   d1
		and.l   #$3,d1
		beq.b   .main
		cmp.l   d1,d0
		blt.b   .main
		sub.l   d1,d0
		subq    #1,d1
.first
		move.b  (a1)+,d3
		move.b  0(a0,d3.l),(a3)+
		dbra    d1,.first
.main
		tst     d0
		beq     .end
		move    d0,d1
		lsr     #2,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.b  (a1)+,d3
		move.b  0(a0,d3.l),d4
		lsl     #8,d4
		move.b  (a1)+,d3
		move.b  0(a0,d3.l),d4
		lsl.l   #8,d4
		move.b  (a1)+,d3
		move.b  0(a0,d3.l),d4
		lsl.l   #8,d4
		move.b  (a1)+,d3
		move.b  0(a0,d3.l),d4
		move.l  d4,(a3)+
		dbra    d0,.loop
.cont
		move    d1,d0
		and     #$3,d0
		beq     .end
		subq    #1,d0
.loop2
		move.b  (a1)+,d3
		move.b  0(a0,d3.l),(a3)+
		dbra    d0,.loop2
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_index_span_RGB16
*
* void SWFSD_write_index_span_RGB16(GLcontext *ctx, GLuint n,
*                                GLint x, GLint y,
*                                const GLubyte index[],
*                                const GLubyte mask[])
*

_SWFSD_write_index_span_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		add.l   d3,a3
		move.l  AMC_COLORTABLE2(a0),a0
		tst.l   a2
		beq.b   .fullwrite
		subq    #1,d0
		moveq   #0,d1
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.b  (a1),d1
		move    2(a0,d1.l*4),(a3)
.next
		addq.l  #1,a1
		addq.l  #2,a3
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		moveq   #0,d3
		move.l  a3,d1
		and.l   #$1,d1
		beq.b   .main
		subq.l  #1,d0
		move.b  (a1),d3
		move    2(a0,d3.l*4),(a3)+
.main
		tst     d0
		beq     .end
		move    d0,d1
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.b  (a1)+,d3
		move    2(a0,d3.l*4),d4
		swap    d4
		move.b  (a1)+,d3
		move    2(a0,d3.l*4),d4
		move.l  d4,(a3)+
		dbra    d0,.loop
.cont
		move    d1,d0
		and     #$1,d0
		beq     .end
		move.b  (a1)+,d3
		move    2(a0,d3.l*4),(a3)+
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/
;// SWFSD_write_index_span_ARGB
*
* void SWFSD_write_index_span_ARGB(GLcontext *ctx, GLuint n,
*                                GLint x, GLint y,
*                                const GLubyte index[],
*                                const GLubyte mask[])
*

_SWFSD_write_index_span_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    5
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1
		move.l  .mask(sp),a2

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a3
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		lsl.l   #2,d1
		add.l   d1,d3
		add.l   d3,a3
		move.l  AMC_COLORTABLE2(a0),a0
		moveq   #0,d1
		tst.l   a2
		beq.b   .fullwrite
.partial_write
		tst.b   (a2)+
		beq.b   .next
		move.b  (a1),d1
		move.l  0(a0,d1.l*4),(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a3
		dbra    d0,.partial_write
		bra.b   .end

.fullwrite
		move.b  (a1)+,d1
		move.l  0(a0,d1.l*4),(a3)+
		dbra    d0,.fullwrite
.end
		movem.l (sp)+,d2-d4/a2-a3
		rts
;;/

;// SWFSD_write_index_pixels_LUT8
*
* void SWFSD_write_index_pixels_LUT8(GLcontext *ctx, GLuint n,
*                                  const GLint x[], const GLint y[],
*                                  const GLuint index[],
*                                  const GLubyte mask[] )
*

_SWFSD_write_index_pixels_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .index(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a5
		move.l  AMC_HEIGHT(a0),d2
		subq.l  #1,d2
		move.l  AMC_BPROW(a0),d1
		lea     AMC_PENCONV(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d2,d3
		sub.l   (a2),d3
		mulu    d1,d3
		add.l   (a1),d3
		move.l  (a3),d4
		move.b  0(a0,d4.l),0(a5,d3.l)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a5
		rts
;;/
;// SWFSD_write_index_pixels_RGB16
*
* void SWFSD_write_index_pixels_RGB16(GLcontext *ctx, GLuint n,
*                                  const GLint x[], const GLint y[],
*                                  const GLuint index[],
*                                  const GLubyte mask[] )
*

_SWFSD_write_index_pixels_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .index(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a5
		move.l  AMC_HEIGHT(a0),d2
		subq.l  #1,d2
		move.l  AMC_BPROW(a0),d1
		lsr.l   #1,d1
		move.l  AMC_COLORTABLE2(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d2,d3
		sub.l   (a2),d3
		mulu    d1,d3
		add.l   (a1),d3
		move.l  (a3),d4
		move    2(a0,d4.l*4),0(a5,d3.l*2)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a5
		rts
;;/
;// SWFSD_write_index_pixels_ARGB
*
* void SWFSD_write_index_pixels_ARGB(GLcontext *ctx, GLuint n,
*                                  const GLint x[], const GLint y[],
*                                  const GLuint index[],
*                                  const GLubyte mask[] )
*

_SWFSD_write_index_pixels_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .index(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_DRAWBUFFER(a0),a5
		move.l  AMC_HEIGHT(a0),d2
		subq.l  #1,d2
		move.l  AMC_BPROW(a0),d1
		lsr.l   #2,d1
		move.l  AMC_COLORTABLE2(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d2,d3
		sub.l   (a2),d3
		mulu    d1,d3
		add.l   (a1),d3
		move.l  (a3),d4
		move.l  0(a0,d4.l*4),0(a5,d3.l*4)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a5
		rts
;;/

;// SWFSD_read_color_span_LUT8
*
* void SWFSD_read_color_span_LUT8(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    4
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2-d4/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_COLORTABLE2(a0),a2
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0
		moveq   #0,d1

		move.l  a0,d3
		neg.l   d3
		and.l   #$3,d3
		beq.b   .main
		cmp.l   d3,d0
		blt.b   .main
		sub.l   d3,d0
		subq    #1,d3
.first
		move.b  (a0)+,d1
		move.l  0(a2,d1.l*4),d2
		lsl.l   #8,d2
		st      d2
		move.l  d2,(a1)+
		dbra    d3,.first
.main
		tst     d0
		beq     .end
		move    d0,d3
		lsr     #2,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a0)+,d4
		rol.l   #8,d4
		move.b  d4,d1
		move.l  0(a2,d1.l*4),d2
		lsl.l   #8,d2
		st      d2
		move.l  d2,(a1)+
		rol.l   #8,d4
		move.b  d4,d1
		move.l  0(a2,d1.l*4),d2
		lsl.l   #8,d2
		st      d2
		move.l  d2,(a1)+
		rol.l   #8,d4
		move.b  d4,d1
		move.l  0(a2,d1.l*4),d2
		lsl.l   #8,d2
		st      d2
		move.l  d2,(a1)+
		rol.l   #8,d4
		move.b  d4,d1
		move.l  0(a2,d1.l*4),d2
		lsl.l   #8,d2
		st      d2
		move.l  d2,(a1)+
		dbra    d0,.loop
.cont
		move    d3,d0
		and     #$3,d0
		beq     .end
		subq    #1,d0
.loop2
		move.b  (a0)+,d1
		move.l  0(a2,d1.l*4),d2
		lsl.l   #8,d2
		st      d2
		move.l  d2,(a1)+
		dbra    d0,.loop2
.end
		movem.l (sp)+,d2-d4/a2
		rts
;;/
;// SWFSD_read_color_span_RGB15
*
* void SWFSD_read_color_span_RGB15(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_RGB15

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    4
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2-d5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0

		moveq   #0,d2
		moveq   #0,d4
		move.l  a0,d3
		and.l   #$1,d3
		beq.b   .main
		subq.l  #1,d0
.first
		move    (a0)+,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a0)+,d3
		swap    d3
		move    d3,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		swap    d3
		move    d3,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		move    (a0)+,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.end
		movem.l (sp)+,d2-d5
		rts
;;/
;// SWFSD_read_color_span_RGB15PC
*
* void SWFSD_read_color_span_RGB15PC(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_RGB15PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    4
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2-d5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0

		moveq   #0,d2
		moveq   #0,d4
		move.l  a0,d3
		and.l   #$1,d3
		beq.b   .main
		subq.l  #1,d0
.first
		move    (a0)+,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a0)+,d3
		swap    d3
		move    d3,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		swap    d3
		move    d3,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		move    (a0)+,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d2
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.end
		movem.l (sp)+,d2-d5
		rts
;;/
;// SWFSD_read_color_span_RGB16
*
* void SWFSD_read_color_span_RGB16(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    4
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2-d5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0

		moveq   #0,d2
		moveq   #0,d4
		move.l  a0,d3
		and.l   #$1,d3
		beq.b   .main
		subq.l  #1,d0
.first
		move    (a0)+,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a0)+,d3
		swap    d3
		move    d3,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		swap    d3
		move    d3,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		move    (a0)+,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.end
		movem.l (sp)+,d2-d5
		rts
;;/
;// SWFSD_read_color_span_RGB16PC
*
* void SWFSD_read_color_span_RGB16PC(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_RGB16PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    4
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2-d5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0

		moveq   #0,d2
		moveq   #0,d4
		move.l  a0,d3
		and.l   #$1,d3
		beq.b   .main
		subq.l  #1,d0
.first
		move    (a0)+,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.main
		tst     d0
		beq     .end
		move    d0,d5
		lsr     #1,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a0)+,d3
		swap    d3
		move    d3,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		swap    d3
		move    d3,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
		dbra    d0,.loop
.cont
		move    d5,d0
		and     #$1,d0
		beq     .end
		move    (a0)+,d1
		ror     #8,d1
		move    d1,d2
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d2
		and     #$f800,d4
		swap    d4
		lsr     #3,d2
		swap    d2
		ror     #5,d1
		or.l    d2,d4
		move    d1,d4
		st      d4
		move.l  d4,(a1)+
.end
		movem.l (sp)+,d2-d5
		rts
;;/
;// SWFSD_read_color_span_ARGB
*
* void SWFSD_read_color_span_ARGB(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    2
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2/d3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0

.loop
		move.l  (a0)+,d1
		rol.l   #8,d1
		move.l  d1,(a1)+
		dbra    d0,.loop
.end
		movem.l (sp)+,d2/d3
		rts
;;/
;// SWFSD_read_color_span_BGRA
*
* void SWFSD_read_color_span_BGRA(const GLcontext *ctx, GLuint n, GLint x, GLint y,
*                                         GLubyte rgba[][4])
*

_SWFSD_read_color_span_BGRA

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    2
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1

		movem.l d2/d3,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .rgba(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		mulu    d2,d3
		lsl.l   #2,d1
		add.l   d1,d3
		move.l  AMC_READBUFFER(a0),a0
		add.l   d3,a0
.loop
		move.l  (a0)+,d1
		ror     #8,d1
		swap    d1
		ror     #8,d1
		rol.l   #8,d1
		move.l  d1,(a1)+
		dbra    d0,.loop
.end
		movem.l (sp)+,d2/d3
		rts
;;/

;// SWFSD_read_index_span_LUT8
*
* void SWFSD_read_index_span_LUT8(GLcontext *ctx, GLuint n,
*                               GLint x, GLint y,
*                               GLuint index[])
*

_SWFSD_read_index_span_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    4
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1

		movem.l d2-d4/a2,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		beq.b   .end
		move.l  .x(sp),d1
		move.l  .y(sp),d2
		move.l  .index(sp),a1

		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_READBUFFER(a0),a2
		move.l  AMC_HEIGHT(a0),d3
		sub.l   d2,d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d4
		mulu    d4,d3
		add.l   d1,d3
		add.l   d3,a2
		lea     AMC_PENCONVINV(a0),a0

		moveq   #0,d1
		moveq   #0,d2
		move.l  a2,d3
		neg.l   d3
		and.l   #$3,d3
		beq.b   .main
		cmp.l   d3,d0
		blt.b   .main
		sub.l   d3,d0
		subq    #1,d3
.first
		move.b  (a2)+,d1
		move.b  0(a0,d1.l),d2
		move.l  d2,(a1)+
		dbra    d3,.loop
.main
		tst     d0
		beq     .end
		move    d0,d3
		lsr     #2,d0
		beq.b   .cont
		subq    #1,d0
.loop
		move.l  (a2)+,d4
		ror.l   #8,d4
		move.b  d4,d1
		move.b  0(a0,d1.l),d2
		move.l  d2,(a1)+
		ror.l   #8,d4
		move.b  d4,d1
		move.b  0(a0,d1.l),d2
		move.l  d2,(a1)+
		ror.l   #8,d4
		move.b  d4,d1
		move.b  0(a0,d1.l),d2
		move.l  d2,(a1)+
		ror.l   #8,d4
		move.b  d4,d1
		move.b  0(a0,d1.l),d2
		move.l  d2,(a1)+
		dbra    d0,.loop
.cont
		move    d3,d0
		and     #$3,d0
		beq     .end
		subq    #1,d0
.loop2
		move.b  (a2)+,d1
		move.b  0(a0,d1.l),d2
		move.l  d2,(a1)+
		dbra    d0,.loop2
.end
		movem.l (sp)+,d2-d4/a2
		rts
;;/

;// SWFSD_read_color_pixels_LUT8
*
* void SWFSD_read_color_pixels_LUT8(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    8
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		moveq   #0,d5
		move.l  AMC_READBUFFER(a0),a5
		move.l  AMC_COLORTABLE2(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d4
		sub.l   (a2),d4
		mulu    d2,d4
		add.l   (a1),d4
		move.b  0(a5,d4.l),d5
		move.l  0(a0,d5.l*4),d4
		lsl.l   #8,d4
		st      d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a5
		rts
;;/
;// SWFSD_read_color_pixels_RGB15
*
* void SWFSD_read_color_pixels_RGB15(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_RGB15

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    9
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a6,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_READBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d1
		sub.l   (a2),d1
		mulu    d2,d1
		add.l   (a1),d1
		move    0(a0,d1.l*2),d1
		move    d1,d5
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d5
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d5
		swap    d5
		ror     #5,d1
		or.l    d5,d4
		move    d1,d4
		st      d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a6
		rts
;;/
;// SWFSD_read_color_pixels_RGB15PC
*
* void SWFSD_read_color_pixels_RGB15PC(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_RGB15PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    9
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a6,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_READBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d1
		sub.l   (a2),d1
		mulu    d2,d1
		add.l   (a1),d1
		move    0(a0,d1.l*2),d1
		ror     #8,d1
		move    d1,d5
		move    d1,d4
		and     #$1f,d1
		and     #$03e0,d5
		and     #$7c00,d4
		add     d4,d4
		swap    d4
		lsr     #2,d5
		swap    d5
		ror     #5,d1
		or.l    d5,d4
		move    d1,d4
		st      d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a6
		rts
;;/
;// SWFSD_read_color_pixels_RGB16
*
* void SWFSD_read_color_pixels_RGB16(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_RGB16

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    9
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a6,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_READBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d1
		sub.l   (a2),d1
		mulu    d2,d1
		add.l   (a1),d1
		move    0(a0,d1.l*2),d1
		move    d1,d5
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d5
		and     #$f800,d4
		swap    d4
		lsr     #3,d5
		swap    d5
		ror     #5,d1
		or.l    d5,d4
		move    d1,d4
		st      d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a6
		rts
;;/
;// SWFSD_read_color_pixels_RGB16PC
*
* void SWFSD_read_color_pixels_RGB16PC(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_RGB16PC

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    9
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d5/a2-a6,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #1,d2
		move.l  AMC_READBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d1
		sub.l   (a2),d1
		mulu    d2,d1
		add.l   (a1),d1
		move    0(a0,d1.l*2),d1
		ror     #8,d1
		move    d1,d5
		move    d1,d4
		and     #$1f,d1
		and     #$07e0,d5
		and     #$f800,d4
		swap    d4
		lsr     #3,d5
		swap    d5
		ror     #5,d1
		or.l    d5,d4
		move    d1,d4
		st      d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d5/a2-a6
		rts
;;/
;// SWFSD_read_color_pixels_ARGB
*
* void SWFSD_read_color_pixels_ARGB(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_ARGB

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    6
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #2,d2
		move.l  AMC_READBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d4
		sub.l   (a2),d4
		mulu    d2,d4
		add.l   (a1),d4
		move.l  0(a0,d4.l*4),d4
		rol.l   #8,d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a4
		rts
;;/
;// SWFSD_read_color_pixels_BGRA
*
* void SWFSD_read_color_pixels_BGRA(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
*                                         GLubyte rgba[][4], const GLubyte mask[])
*

_SWFSD_read_color_pixels_BGRA

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    6
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.rgba           rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a4,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .rgba(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_HEIGHT(a0),d3
		subq.l  #1,d3
		move.l  AMC_BPROW(a0),d2
		lsr.l   #2,d2
		move.l  AMC_READBUFFER(a0),a0
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d3,d4
		sub.l   (a2),d4
		mulu    d2,d4
		add.l   (a1),d4
		move.l  0(a0,d4.l*4),d4
		ror     #8,d4
		swap    d4
		ror     #8,d4
		rol.l   #8,d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a4
		rts
;;/

;// SWFSD_read_index_pixels_LUT8
*
* void SWFSD_read_index_pixels_LUT8( GLcontext *ctx,GLuint n,
*                                  const GLint x[], const GLint y[],
*                                  GLuint index[], const GLubyte mask[] )
*

_SWFSD_read_index_pixels_LUT8

		rsreset
.fpuregs        rs.x    0
.regs           rs.l    7
		rs.l    1
.ctx            rs.l    1
.n              rs.l    1
.x              rs.l    1
.y              rs.l    1
.index          rs.l    1
.mask           rs.l    1

		movem.l d2-d4/a2-a5,-(sp)
		move.l  .ctx(sp),a0
		move.l  .n(sp),d0
		subq    #1,d0
		bmi.b   .end
		move.l  .x(sp),a1
		move.l  .y(sp),a2
		move.l  .index(sp),a3
		move.l  .mask(sp),a4
		move.l  GL_DRIVERCTX(a0),a0
		move.l  AMC_READBUFFER(a0),a5
		move.l  AMC_HEIGHT(a0),d2
		subq.l  #1,d2
		move.l  AMC_BPROW(a0),d1
		lea     AMC_PENCONVINV(a0),a0
		moveq   #0,d4
.loop
		tst.b   (a4)+
		beq.b   .next
		move.l  d2,d3
		sub.l   (a2),d3
		mulu    d1,d3
		add.l   (a1),d3
		move.b  0(a5,d3.l),d4
		move.b  0(a0,d4.l),d4
		move.l  d4,(a3)
.next
		addq.l  #4,a1
		addq.l  #4,a2
		addq.l  #4,a3
		dbra    d0,.loop
.end
		movem.l (sp)+,d2-d4/a2-a5
		rts
;;/