; **experimental** data compression/decompression routines, API subject to change!!
; This file contains the shared routines that work on all targets.

compression {

    %option ignore_unused, merge

    sub encode_rle_outfunc(uword data, uword size, uword output_function, bool is_last_block) {
        ; -- Compress the given data block using ByteRun1 aka PackBits RLE encoding.
        ;    output_function = address of a routine that gets a byte arg in A,
        ;                      which is the next RLE byte to write to the compressed output buffer or file.
        ;    is_last_block = usually true, but you can set it to false if you want to concatenate multiple
        ;                    compressed blocks (for instance if the source data is >64Kb)
        ;    Worst case result storage size needed = (size + (size+126) / 127) + 1
        ;    This routine is not optimized for speed but for readability and ease of use.
        uword idx = 0
        uword literals_start_idx = 0
        ubyte literals_length = 0

        asmsub call_output_function(ubyte arg @A) {
            %asm {{
                jmp  (p8v_output_function)
            }}
        }

        sub next_same_span() {
            ; returns length in cx16.r1L, and the byte value in cx16.r1H
            cx16.r1H = data[idx]
            cx16.r1L = 0
            while data[idx]==cx16.r1H and cx16.r1L<128 and idx<size {
                idx++
                cx16.r1L++
            }
        }

        sub output_literals() {
            call_output_function(literals_length-1)
            uword dataptr = data + literals_start_idx
            ubyte i
            for i in 0 to literals_length-1 {
                call_output_function(@(dataptr))
                dataptr++
            }
            literals_length = 0
        }

        while idx<size {
            next_same_span()     ; count in r1L, value in r1H
            if cx16.r1L>1 {
                ; a replicate run
                if literals_length>0
                    output_literals()
                call_output_function((cx16.r1L^255)+2)        ;  257-cx16.r1L
                call_output_function(cx16.r1H)
            }
            else {
                ; add more to the literals run
                if literals_length==128
                    output_literals()
                if literals_length==0
                    literals_start_idx = idx-1
                literals_length++
            }
        }

        if literals_length>0
            output_literals()

        if is_last_block
            call_output_function(128)
    }

    sub encode_rle(uword data, uword size, uword target, bool is_last_block) -> uword {
        ; -- Compress the given data block using ByteRun1 aka PackBits RLE encoding.
        ;    Returns the size of the compressed RLE data. Worst case result storage size needed = (size + (size+126) / 127) + 1.
        ;    is_last_block = usually true, but you can set it to false if you want to concatenate multiple
        ;                    compressed blocks (for instance if the source data is >64Kb)
        ;    This routine is not optimized for speed but for readability and ease of use.
        uword idx = 0
        uword literals_start_idx = 0
        ubyte literals_length = 0
        uword orig_target = target

        sub next_same_span() {
            ; returns length in cx16.r1L, and the byte value in cx16.r1H
            cx16.r1H = data[idx]
            cx16.r1L = 0
            while data[idx]==cx16.r1H and cx16.r1L<128 and idx<size {
                idx++
                cx16.r1L++
            }
        }

        sub output_literals() {
            @(target) = literals_length-1
            target++
            uword dataptr = data + literals_start_idx
            ubyte i
            for i in 0 to literals_length-1 {
                @(target) = @(dataptr)
                target++
                dataptr++
            }
            literals_length = 0
        }

        while idx<size {
            next_same_span()     ; count in r1L, value in r1H
            if cx16.r1L>1 {
                ; a replicate run
                if literals_length>0
                    output_literals()
                @(target) = (cx16.r1L^255)+2        ;  257-cx16.r1L
                target++
                @(target) = cx16.r1H
                target++
            }
            else {
                ; add more to the literals run
                if literals_length==128
                    output_literals()
                if literals_length==0
                    literals_start_idx = idx-1
                literals_length++
            }
        }

        if literals_length>0
            output_literals()

        if is_last_block {
            @(target) = 128
            target ++
        }

        return target-orig_target
    }

    asmsub decode_rle_srcfunc(uword source_function @AY, uword target @R0, uword maxsize @R1) clobbers(X) -> uword @AY {
        ; -- Decodes "ByteRun1" (aka PackBits) RLE compressed data. Control byte value 128 ends the decoding.
        ;    Also stops decompressing when the maxsize has been reached. Returns the size of the decompressed data.
        ;    Instead of a source buffer, you provide a callback function that must return the next byte to compress in A.
        %asm {{
            sta  _cb_mod1+1
            sty  _cb_mod1+2
            sta  _cb_mod2+1
            sty  _cb_mod2+2
            sta  _cb_mod3+1
            sty  _cb_mod3+2
            lda  cx16.r0L
            ldy  cx16.r0H
            sta  P8ZP_SCRATCH_W2        ; target ptr
            sta  _orig_target
            sty  P8ZP_SCRATCH_W2+1
            sty  _orig_target+1
            lda  cx16.r0L
            clc
            adc  cx16.r1L
            sta  cx16.r1L
            lda  cx16.r0H
            adc  cx16.r1H
            sta  cx16.r1H        ; decompression limit

_loop
	        ; while target (W2) < limit (r1)
        	lda  P8ZP_SCRATCH_W2
	        ldy  P8ZP_SCRATCH_W2+1
	        cmp  cx16.r1L
	        tya
	        sbc  cx16.r1H
	        bcs  _end

            ; check control byte
_cb_mod1    jsr  $ffff      ; modified
            bpl  _literals
            cmp  #128
            beq  _end

            ; replicate next byte -n+1 times
            eor  #255
            clc
            adc  #2
            sta  P8ZP_SCRATCH_REG
_cb_mod2    jsr  $ffff      ; modified
            ldx  P8ZP_SCRATCH_REG
            ldy  #0
-           sta  (P8ZP_SCRATCH_W2),y
            iny
            dex
            bne  -
            ; add A to target
            lda  P8ZP_SCRATCH_REG
            clc
            adc  P8ZP_SCRATCH_W2
            sta  P8ZP_SCRATCH_W2
            bcc  _loop
            inc  P8ZP_SCRATCH_W2+1
            bcs  _loop

_literals
            ; copy the next n+1 bytes
            pha
            sta  P8ZP_SCRATCH_B1
            ldy  #0
            sty  P8ZP_SCRATCH_REG
_cb_mod3    jsr  $ffff      ; modified
            ldy  P8ZP_SCRATCH_REG
            sta  (P8ZP_SCRATCH_W2),y
            inc  P8ZP_SCRATCH_REG
            dec  P8ZP_SCRATCH_B1
            bpl  _cb_mod3
            ; add N+1 to target
            pla
            sec
            adc  P8ZP_SCRATCH_W2
            sta  P8ZP_SCRATCH_W2
            bcc  _loop
            inc  P8ZP_SCRATCH_W2+1
            bcs  _loop

_orig_target    .word  0
_end
            ; return w2-orig_target, the size of the decompressed data
            lda  P8ZP_SCRATCH_W2
            ldy  P8ZP_SCRATCH_W2+1
            sec
            sbc  _orig_target
            tax
            tya
            sbc  _orig_target+1
            tay
            txa
            rts
        }}
    }

    asmsub decode_rle(uword compressed @AY, uword target @R0, uword maxsize @R1) clobbers(X) -> uword @AY {
        ; -- Decodes "ByteRun1" (aka PackBits) RLE compressed data. Control byte value 128 ends the decoding.
        ;    Also stops decompressing if the maxsize has been reached.
        ;    Returns the size of the decompressed data.
        %asm {{
            sta  P8ZP_SCRATCH_W1        ; compressed data ptr
            sty  P8ZP_SCRATCH_W1+1
            lda  cx16.r0L
            ldy  cx16.r0H
            sta  P8ZP_SCRATCH_W2        ; target ptr
            sta  _orig_target
            sty  P8ZP_SCRATCH_W2+1
            sty  _orig_target+1
            lda  cx16.r0L
            clc
            adc  cx16.r1L
            sta  cx16.r1L
            lda  cx16.r0H
            adc  cx16.r1H
            sta  cx16.r1H        ; decompression limit

_loop       ; while target (W2) < limit (r1)
        	lda  P8ZP_SCRATCH_W2
	        ldy  P8ZP_SCRATCH_W2+1
	        cmp  cx16.r1L
	        tya
	        sbc  cx16.r1H
	        bcs  _end

            ; check control byte
            ldy  #0
            lda  (P8ZP_SCRATCH_W1),y
            bpl  _literals
            cmp  #128
            beq  _end

            ; replicate next byte -n+1 times
            eor  #255
            clc
            adc  #2
            pha
            tax
            iny
            lda  (P8ZP_SCRATCH_W1),y
            ldy  #0
-           sta  (P8ZP_SCRATCH_W2),y
            iny
            dex
            bne  -
            ; add A to target
            pla
            clc
            adc  P8ZP_SCRATCH_W2
            sta  P8ZP_SCRATCH_W2
            bcc  +
            inc  P8ZP_SCRATCH_W2+1
            clc
+
            ; increase source by 2
            lda  P8ZP_SCRATCH_W1
            adc  #2
            sta  P8ZP_SCRATCH_W1
            bcc  _loop
            inc  P8ZP_SCRATCH_W1+1
            bcs  _loop

_literals
            ; copy the next n+1 bytes
            pha
            tax
            inc  P8ZP_SCRATCH_W1
            bne  +
            inc  P8ZP_SCRATCH_W1+1
+           ldy  #0
-           lda  (P8ZP_SCRATCH_W1),y
            sta  (P8ZP_SCRATCH_W2),y
            iny
            dex
            bpl  -
            ; add N+1 to source
            pla
            tax
            sec
            adc  P8ZP_SCRATCH_W1
            sta  P8ZP_SCRATCH_W1
            bcc  +
            inc  P8ZP_SCRATCH_W1+1
+           ; add N+1 to target as well
            txa
            sec
            adc  P8ZP_SCRATCH_W2
            sta  P8ZP_SCRATCH_W2
            bcc  _loop
            inc  P8ZP_SCRATCH_W2+1
            bcs  _loop

_orig_target    .word  0
_end
            ; return w2-orig_target, the size of the decompressed data
            lda  P8ZP_SCRATCH_W2
            ldy  P8ZP_SCRATCH_W2+1
            sec
            sbc  _orig_target
            tax
            tya
            sbc  _orig_target+1
            tay
            txa
            rts
        }}
    }


	asmsub decode_zx0(uword compressed @R0, uword target @R1) clobbers(A,X,Y) {
        ; Decompress a block of data compressed in the ZX0 format
        ; This can be produced using the "salvador" compressor with -classic
        ; It has faster decompression than LZSA and a better compression ratio as well.
        ; see https://github.com/emmanuel-marty/salvador for the compressor tool
        ; see https://github.com/einar-saukas/ZX0  for the compression format
        ;
        ; NOTE: for speed reasons this decompressor is NOT bank-aware and NOT I/O register aware;
        ;       it only outputs to a memory buffer somewhere in the active 64 Kb address range
        ;

        %asm {{

; ***************************************************************************
; ***************************************************************************
;
; zx0_6502.asm
;
; NMOS 6502 decompressor for data stored in Einar Saukas's ZX0 format.
;
; The code is 196 bytes long, and is self-modifying.
;
; Copyright John Brandwood 2021.
;
; Distributed under the Boost Software License, Version 1.0.
; (See accompanying file LICENSE_1_0.txt or copy at
;  http://www.boost.org/LICENSE_1_0.txt)
;
; Adapted for Prog8 by Irmen de Jong
;
; ***************************************************************************
; ***************************************************************************



; ***************************************************************************
; ***************************************************************************
;
; Decompression Options & Macros
;



; ***************************************************************************
; ***************************************************************************
;
; Data usage is 8 bytes of zero-page.
;

.if cx16.r0 < $100
    ; r0-r15 registers are in zeropage just use those
zx0_srcptr      =       cx16.r0   ;$F8                     ; 1 word.
zx0_dstptr      =       cx16.r1   ;$FA                     ; 1 word.
zx0_length      =       cx16.r2   ;$FC                     ; 1 word.
zx0_offset      =       cx16.r3   ;$FE                     ; 1 word.
.else
    .error "in decode_zx0: r0-15 are not in zeropage and no alternatives have been set up yet"     ; TODO
.endif


; ***************************************************************************
; ***************************************************************************
;
; zx0_unpack - Decompress data stored in Einar Saukas's ZX0 format.
;
; Args: zx0_srcptr = ptr to compessed data
; Args: zx0_dstptr = ptr to output buffer
; Uses: lots!
;

zx0_unpack:

.if cx16.r0>=$100
                ; set up the source and destination pointers
                lda  cx16.r0L
                sta  zx0_srcptr
                lda  cx16.r0H
                sta  zx0_srcptr+1
                lda  cx16.r1L
                sta  zx0_dstptr
                lda  cx16.r1H
                sta  zx0_dstptr+1
.endif


                ldy     #$FF                    ; Initialize default offset.
                sty     <zx0_offset+0
                sty     <zx0_offset+1
                iny                             ; Initialize source index.
                sty     <zx0_length+1           ; Initialize length to 1.

                ldx     #$40                    ; Initialize empty buffer.

zx0_next_cmd:   lda     #1                      ; Initialize length back to 1.
                sta     <zx0_length + 0

                txa                             ; Restore bit-buffer.

                asl     a                        ; Copy from literals or new offset?
                bcc     zx0_cp_literal

                ;
                ; Copy bytes from new offset.
                ;

zx0_new_offset: jsr     zx0_gamma_flag          ; Get offset MSB, returns CS.

                tya                             ; Negate offset MSB and check
                sbc     <zx0_length + 0         ; for zero (EOF marker).
                bcs     zx0_got_eof

                sec
                ror     a
                sta     <zx0_offset + 1         ; Save offset MSB.

                lda     (<zx0_srcptr),y         ; Get offset LSB.
                inc     <zx0_srcptr + 0
                beq     zx0_inc_of_src

zx0_off_skip1:  ror     a                        ; Last offset bit starts gamma.
                sta     <zx0_offset + 0         ; Save offset LSB.

                lda     #-2                     ; Minimum length of 2?
                bcs     zx0_get_lz_dst

                lda     #1                      ; Initialize length back to 1.
                sta     <zx0_length + 0

                txa                             ; Restore bit-buffer.

                jsr     zx0_gamma_data          ; Get length, returns CS.

                lda     <zx0_length + 0         ; Negate lo-byte of (length+1).
                eor     #$FF

;               bne     zx0_get_lz_dst          ; N.B. Optimized to do nothing!
;
;               inc     <zx0_length + 1         ; Increment from (length+1).
;               dec     <zx0_length + 1         ; Decrement because lo-byte=0.

zx0_get_lz_dst: tay                             ; Calc address of partial page.
                eor     #$FF                    ; Always CS from previous SBC.
                adc     <zx0_dstptr + 0
                sta     <zx0_dstptr + 0
                bcs     zx0_get_lz_win

                dec     <zx0_dstptr + 1

zx0_get_lz_win: clc                             ; Calc address of match.
                adc     <zx0_offset + 0         ; N.B. Offset is negative!
                sta     zx0_winptr + 0
                lda     <zx0_dstptr + 1
                adc     <zx0_offset + 1
                sta     zx0_winptr + 1

zx0_winptr      =       *+1

zx0_lz_page:    lda     $1234,y                 ; Self-modifying zx0_winptr.
                sta     (<zx0_dstptr),y
                iny
                bne     zx0_lz_page
                inc     <zx0_dstptr + 1

                lda     <zx0_length + 1         ; Any full pages left to copy?
                beq     zx0_next_cmd

                dec     <zx0_length + 1         ; This is rare, so slower.
                inc     zx0_winptr + 1
                bne     zx0_lz_page             ; Always true.

zx0_got_eof:    rts                             ; Finished decompression.

                ;
                ; Copy bytes from compressed source.
                ;

zx0_cp_literal: jsr     zx0_gamma_flag          ; Get length, returns CS.

                pha                             ; Preserve bit-buffer.

                ldx     <zx0_length + 0         ; Check the lo-byte of length
                bne     zx0_cp_byte             ; without effecting CS.

zx0_cp_page:    dec     <zx0_length + 1         ; Decrement # of pages to copy.

zx0_cp_byte:    lda     (<zx0_srcptr),y         ; CS throughout the execution of
                sta     (<zx0_dstptr),y         ; of this .cp_page loop.

                inc     <zx0_srcptr + 0
                beq     zx0_inc_cp_src

zx0_cp_skip1:   inc     <zx0_dstptr + 0
                beq     zx0_inc_cp_dst

zx0_cp_skip2:   dex                             ; Any bytes left to copy?
                bne     zx0_cp_byte

                lda     <zx0_length + 1         ; Any full pages left to copy?
                bne     zx0_cp_page             ; Optimized for branch-unlikely.

                inx                             ; Initialize length back to 1.
                stx     <zx0_length + 0

                pla                             ; Restore bit-buffer.

                asl     a                        ; Copy from last offset or new offset?
                bcs     zx0_new_offset

                ;
                ; Copy bytes from last offset (rare so slower).
                ;

zx0_old_offset: jsr     zx0_gamma_flag          ; Get length, returns CS.

                tya                             ; Negate the lo-byte of length.
                sbc     <zx0_length + 0
                sec                             ; Ensure CS before zx0_get_lz_dst!
                bne     zx0_get_lz_dst

                dec     <zx0_length + 1         ; Decrement because lo-byte=0.
                bcs     zx0_get_lz_dst          ; Always true!

                ;
                ; Optimized handling of pointers crossing page-boundaries.
                ;

zx0_inc_of_src: inc     <zx0_srcptr + 1
                bne     zx0_off_skip1           ; Always true.

zx0_inc_cp_src: inc     <zx0_srcptr + 1
                bcs     zx0_cp_skip1            ; Always true.

zx0_inc_cp_dst: inc     <zx0_dstptr + 1
                bcs     zx0_cp_skip2            ; Always true.

zx0_inc_ga_src: inc     <zx0_srcptr + 1
                bne     zx0_gamma_skip          ; Always true.

                ;
                ; Get 16-bit interlaced Elias gamma value.
                ;

zx0_gamma_data: asl     a                        ; Get next bit.
                rol     <zx0_length + 0
zx0_gamma_flag: asl     a
                bcc     zx0_gamma_data          ; Loop until finished or empty.
                bne     zx0_gamma_done          ; Bit-buffer empty?

zx0_gamma_load: lda     (<zx0_srcptr),y         ; Reload the empty bit-buffer
                inc     <zx0_srcptr + 0         ; from the compressed source.
                beq     zx0_inc_ga_src
zx0_gamma_skip: rol     a
                bcs     zx0_gamma_done          ; Finished?

zx0_gamma_word: asl     a                       ; Get next bit.
                rol     <zx0_length + 0
                rol     <zx0_length + 1
                asl     a
                bcc     zx0_gamma_word          ; Loop until finished or empty.
                beq     zx0_gamma_load          ; Bit-buffer empty?

zx0_gamma_done: tax                             ; Preserve bit-buffer.
                rts

        }}

    }


    asmsub decode_tscrunch(uword compressed @R0, uword target @R1) clobbers(A,X,Y) {
        ; Decompress a block of data compressed by TSCRUNCH
        ; see https://github.com/tonysavon/TSCrunch
        ; It has extremely fast decompression (approaching RLE speeds),
        ; better compression as RLE, but slightly worse compression ration than LZSA
        ;
        ; NOTE: for speed reasons this decompressor is NOT bank-aware and NOT I/O register aware;
        ;       it only outputs to a memory buffer somewhere in the active 64 Kb address range
        ;
        ; TODO: include the in-place decompression version as well?

        %asm {{

;NMOS 6502 decompressor for data stored in TSCrunch format.
;
;Copyright Antonio Savona 2022.
; Distributed under the Apache software License v2.0 https://www.apache.org/licenses/LICENSE-2.0
;
; Adapted for Prog8 and 6502 CMOS by Irmen de Jong.


.if cx16.r0 < $100
    ; r0-r15 registers are in zeropage just use those
tsget 	= cx16.r0	; 2 bytes
tsput 	= cx16.r1	; 2 bytes
tstemp	= cx16.r2
lzput 	= cx16.r3	; 2 bytes
.else
    .error "in decode_tscrunch: r0-15 are not in zeropage and no alternatives have been set up yet"     ; TODO
.endif


.if cx16.r0>=$100
            ; set up the source and destination pointers
            lda  cx16.r0L
            sta  tsget
            lda  cx16.r0H
            sta  tsget+1
            lda  cx16.r1L
            sta  tsput
            lda  cx16.r1H
            sta  tsput+1
.endif

			ldy #0
			lda (tsget),y
			sta optRun + 1
			inc tsget
			bne entry2
			inc tsget + 1

	entry2:
			; ILLEGAL lax (tsget),y
			lda (tsget),y
			tax

			bmi rleorlz

			cmp #$20
			bcs lz2

	; literal

			tay

		ts_delit_loop:

			lda (tsget),y
			dey
			sta (tsput),y

			bne ts_delit_loop

			txa
			inx

	updatezp_noclc:
			adc tsput
			sta tsput
			bcs updateput_hi
		putnoof:
			txa
		update_getonly:
			adc tsget
			sta tsget
			bcc entry2
			inc tsget+1
			bcs entry2

	updateput_hi:
			inc tsput+1
			clc
			bcc putnoof

	rleorlz:

			; ILLEGAL: alr #$7f
			and #$7f
			lsr a
			bcc ts_delz

		; RLE
			beq optRun

		plain:
			ldx #2
			iny
			sta tstemp		; number of bytes to de-rle

			lda (tsget),y	; fetch rle byte
			ldy tstemp
		runStart:
			sta (tsput),y

		ts_derle_loop:

			dey
			sta (tsput),y

			bne ts_derle_loop

			; update zero page with a = runlen, x = 2 , y = 0
			lda tstemp

			bcs updatezp_noclc

	   done:
			rts
	; LZ2
		lz2:
			beq done

			ora #$80
			adc tsput
			sta lzput
			lda tsput + 1
			sbc #$00
			sta lzput + 1

			; y already zero
			lda (lzput),y
			sta (tsput),y
			iny
			lda (lzput),y
			sta (tsput),y

			tya
			dey

			adc tsput
			sta tsput
			bcs lz2_put_hi
		skp:
			inc tsget
			bne entry2
			inc tsget + 1
			bne entry2

		lz2_put_hi:
			inc tsput + 1
			bcs skp

	; LZ
	ts_delz:

			lsr a
			sta lzto + 1

			iny

			lda tsput
			bcc long

			sbc (tsget),y
			sta lzput
			lda tsput+1

			sbc #$00

			ldx #2
			; lz MUST decrunch forward
	lz_put:
			sta lzput+1

			ldy #0

			lda (lzput),y
			sta (tsput),y

			iny
			lda (lzput),y
			sta (tsput),y

	ts_delz_loop:

			iny

			lda (lzput),y
			sta (tsput),y

	lzto:	cpy #0
			bne ts_delz_loop

			tya

			; update zero page with a = runlen, x = 2, y = 0
			ldy #0
			; clc not needed as we have len - 1 in A (from the encoder) and C = 1

			jmp updatezp_noclc

	optRun:
			ldy #255
			sty tstemp

			ldx #1
			; A is zero

			bne runStart

	long:
			; carry is clear and compensated for from the encoder
			adc (tsget),y
			sta lzput
			iny
			; ILLEGAL: lax (tsget),y
			lda  (tsget),y
			tax
			ora #$80
			adc tsput + 1

			cpx #$80
			rol lzto + 1
			ldx #3

			bne lz_put

            ; !notreached!
        }}

    }


/***
    ; prog8 source code for the RLE routines above:

    sub decode_rle_prog8(uword @zp compressed, uword @zp target, uword maxsize) -> uword {
        cx16.r0 = target    ; original target
        cx16.r1 = target+maxsize     ; decompression limit

        while target<cx16.r1 {
            cx16.r2L = @(compressed)
            if_neg {
                if cx16.r2L==128
                    break
                ; replicate the next byte -n+1 times
                compressed++
                cx16.r3L = @(compressed)
                repeat 2+(cx16.r2L^255) {
                    @(target) = cx16.r3L
                    target++
                }
                compressed++
            } else {
                ; copy the next n+1 bytes
                compressed++
                repeat cx16.r2L+1 {
                    @(target) = @(compressed)
                    compressed++
                    target++
                }
            }
        }
        return target-cx16.r0
    }

    sub decode_rle_callback_prog8(uword producer_callback, uword @zp target, uword maxsize) -> uword {
        cx16.r0 = target   ; original target
        cx16.r1 = target+maxsize     ; decompression limit

        while target<cx16.r1 {
            cx16.r2L = lsb(call(producer_callback))
            if_neg {
                if cx16.r2L==128
                    break
                ; replicate the next byte -n+1 times
                cx16.r3L = lsb(call(producer_callback))
                repeat 2+(cx16.r2L^255) {
                    @(target) = cx16.r3L
                    target++
                }
            } else {
                ; copy the next n+1 bytes
                repeat cx16.r2L+1 {
                    @(target) = lsb(call(producer_callback))
                    target++
                }
            }
        }
        return target-cx16.r0
    }
***/

}