//
// Copyright (c) 2002 - 2005 Magnus Lind.
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from
// the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented// you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not
//   be misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any distribution.
//
//   4. The names of this software and/or it's copyright holders may not be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
//
// -------------------------------------------------------------------
// The decruncher jsr:s to the get_crunched_byte address when it wants to
// read a crunched byte. This subroutine has to preserve x and y register
// and must not modify the state of the carry flag.
// -------------------------------------------------------------------
// not needed for kickass... just defined it in client code as
// .var get_crunched_byte = get_crunched_byte_custom 
// where get_crunched_byte_custom is your routine
// -------------------------------------------------------------------
// .import get_crunched_byte  
// -------------------------------------------------------------------
// this function is the heart of the decruncher.
// It initializes the decruncher zeropage locations and precalculates the
// decrunch tables and decrunches the data
// This function will not change the interrupt status bit and it will not
// modify the memory configuration.
// -------------------------------------------------------------------
// Not needed for kickass
// .export decrunch

// -------------------------------------------------------------------
// if literal sequences is not used (the data was crunched with the -c
// flag) then the following line can be uncommented for shorter code.
// #define LITERAL_SEQUENCES_NOT_USED

//.var get_crunched_byte = get_crunched_byte_custom 

// -------------------------------------------------------------------
// zero page addresses used
// -------------------------------------------------------------------
.var zp_len_lo = exomizerzp

.var zp_src_lo  = zp_len_lo + 1
.var zp_src_hi  = zp_src_lo + 1

.var zp_bits_hi = zp_src_hi + 1

.var zp_bitbuf  = zp_bits_hi + 1
.var zp_dest_lo = zp_bitbuf + 1	// dest addr lo
.var zp_dest_hi = zp_dest_lo + 1	// dest addr hi

.var tabl_bi = decrunch_table
.var tabl_lo = decrunch_table + 52
.var tabl_hi = decrunch_table + 104

// -------------------------------------------------------------------
// no code below this comment has to be modified in order to generate
// a working decruncher of this source file.
// However, you may want to relocate the tables last in the file to a
// more suitable address.
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// jsr this label to decrunch, it will in turn init the tables and
// call the decruncher
// no constraints on register content, however the
// decimal flag has to be #0 (it almost always is, otherwise do a cld)
decrunch:
// -------------------------------------------------------------------
// init zeropage, x and y regs. (12 bytes)
//
				ldy #0
				ldx #3
init_zp:
				jsr get_crunched_byte
				sta zp_bitbuf - 1,x
				dex
				bne init_zp
// -------------------------------------------------------------------
// calculate tables (50 bytes)
// x and y must be #0 when entering
//
nextone:
				inx
				tya
				and #$0f
				beq shortcut		// starta pĺ ny sekvens

				txa			// this clears reg a
				lsr 			// and sets the carry flag
				ldx tabl_bi-1,y
rolle:
				rol 
				rol zp_bits_hi
				dex
				bpl rolle		// c = 0 after this (rol zp_bits_hi)

				adc tabl_lo-1,y
				tax

				lda zp_bits_hi
				adc tabl_hi-1,y
shortcut:
				sta tabl_hi,y
				txa
				sta tabl_lo,y

				ldx #4
				jsr get_bits		// clears x-reg.
				sta tabl_bi,y
				iny
				cpy #52
				bne nextone
				ldy #0
				beq begin
// -------------------------------------------------------------------
// get bits (29 bytes)
//
// args:
//   x = number of bits to get
// returns:
//   a = #bits_lo
//   x = #0
//   c = 0
//   z = 1
//   zp_bits_hi = #bits_hi
// notes:
//   y is untouched
// -------------------------------------------------------------------
get_bits:
				lda #$00
				sta zp_bits_hi
				cpx #$01
				bcc bits_done
bits_next:
				lsr zp_bitbuf
				bne ok
				pha
literal_get_byte:
				jsr get_crunched_byte
				bcc literal_byte_gotten
				ror 
				sta zp_bitbuf
				pla
ok:
				rol 
				rol zp_bits_hi
				dex
				bne bits_next
bits_done:
				rts
// -------------------------------------------------------------------
// main copy loop (18(16) bytes)
//
copy_next_hi:
				dex
				dec zp_dest_hi
				dec zp_src_hi
copy_next:
				dey
#if !LITERAL_SEQUENCES_NOT_USED
				bcc literal_get_byte
#endif
				lda (zp_src_lo),y
literal_byte_gotten:
				sta (zp_dest_lo),y
copy_start:
				tya
				bne copy_next
begin:
				txa
				bne copy_next_hi
// -------------------------------------------------------------------
// decruncher entry point, needs calculated tables (21(13) bytes)
// x and y must be #0 when entering
//
#if !LITERAL_SEQUENCES_NOT_USED
				inx
				jsr get_bits
				tay
				bne literal_start1
#else
				dey
#endif
begin2:
				inx
				jsr bits_next
				lsr 
				iny
				bcc begin2
#if LITERAL_SEQUENCES_NOT_USED
				beq literal_start
#endif
				cpy #$11
#if !LITERAL_SEQUENCES_NOT_USED
				bcc sequence_start
				beq bits_done
// -------------------------------------------------------------------
// literal sequence handling (13(2) bytes)
//
				ldx #$10
				jsr get_bits
literal_start1:
				sta <zp_len_lo
				ldx <zp_bits_hi
				ldy #0
				bcc literal_start
sequence_start:
#else
				bcs bits_done
#endif
// -------------------------------------------------------------------
// calulate length of sequence (zp_len) (11 bytes)
//
				ldx tabl_bi - 1,y
				jsr get_bits
				adc tabl_lo - 1,y	// we have now calculated zp_len_lo
				sta zp_len_lo
// -------------------------------------------------------------------
// now do the hibyte of the sequence length calculation (6 bytes)
				lda zp_bits_hi
				adc tabl_hi - 1,y	// c = 0 after this.
				pha
// -------------------------------------------------------------------
// here we decide what offset table to use (20 bytes)
// x is 0 here
//
				bne nots123
				ldy zp_len_lo
				cpy #$04
				bcc size123
nots123:
				ldy #$03
size123:
				ldx tabl_bit - 1,y
				jsr get_bits
				adc tabl_off - 1,y	// c = 0 after this.
				tay			// 1 <= y <= 52 here
// -------------------------------------------------------------------
// Here we do the dest_lo -= len_lo subtraction to prepare zp_dest
// but we do it backwards:	a - b == (b - a - 1) ^ ~0 (C-syntax)
// (16(16) bytes)
				lda zp_len_lo
literal_start:			// literal enters here with y = 0, c = 1
				sbc zp_dest_lo
				bcc noborrow
				dec zp_dest_hi
noborrow:
				eor #$ff
				sta zp_dest_lo
				cpy #$01		// y < 1 then literal
#if !LITERAL_SEQUENCES_NOT_USED
				bcc pre_copy
#else
				bcc literal_get_byte
#endif
// -------------------------------------------------------------------
// calulate absolute offset (zp_src) (27 bytes)
//
				ldx tabl_bi,y
				jsr get_bits//
				adc tabl_lo,y
				bcc skipcarry
				inc zp_bits_hi
				clc
skipcarry:
				adc zp_dest_lo
				sta zp_src_lo
				lda zp_bits_hi
				adc tabl_hi,y
				adc zp_dest_hi
				sta zp_src_hi
// -------------------------------------------------------------------
// prepare for copy loop (8(6) bytes)
//
				pla
				tax
#if !LITERAL_SEQUENCES_NOT_USED
				sec
pre_copy:
				ldy <zp_len_lo
				jmp copy_start
#else
				ldy <zp_len_lo
				bcc copy_start
#endif

get_crunched_byte:
    lda srcptr
    bne !+
    dec srcptr + 1
!:
    dec srcptr
    lda srcptr:$ffff
    rts
	
// -------------------------------------------------------------------
// two small static tables (6(6) bytes)
//
tabl_bit:
				.byte 2,4,4
tabl_off:
				.byte 48,32,16
// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// this 156 byte table area may be relocated. It may also be clobbered
// by other data between decrunches.
// -------------------------------------------------------------------
decrunch_table:
				.fill 156,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
				// .byte 0,0,0,0,0,0,0,0,0,0,0,0
// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------

//------------------------------------------------------------------------------ -------
// PROGRAM START
//------------------------------------------------------------------------------ -------
// -------------------------------------------------------------------
// this file is intended to be assembled with Kick Assembler.
// It has not been tested with any other assemblers or linkers.
// -------------------------------------------------------------------

.var DECRUNCH_FORWARDS = false

// -------------------------------------------------------------------
.pc = $3000 // <--- put wherever
      
// -------------------------------------------------------------------
exod_get_crunched_byte:
.if (!DECRUNCH_FORWARDS) {
        lda opbase+1
        bne _byte_skip_hi
        dec opbase+2
_byte_skip_hi:
        dec opbase+1
}

opbase:        lda $ffff               // needs to be set correctly before
.if (DECRUNCH_FORWARDS) {
        inc opbase+1
        bne _byte_skip_hi
        inc opbase+2
_byte_skip_hi:
}
        rts                     // decrunch_file is called.
// end_of_data needs to point to the address just after the address
// of the last byte of crunched data.
// -------------------------------------------------------------------

//
// Copyright (c) 2002 - 2019 Magnus Lind.
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from
// the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented// you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not
//   be misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any distribution.
//
//   4. The names of this software and/or it's copyright holders may not be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
//
// -------------------------------------------------------------------
// Known quirks:
//  Can't handle a sequence reference that ends at $ffff. It is left in
//  since it is a corner case and fixing it impacts negatively on
//  performance or backwards compatibility.
//  A simple way to work around this is to not decrunch to address $ffff.
// -------------------------------------------------------------------
// Controls if the shared get_bits routines should be inlined or not.
//INLINE_GET_BITS=1
.var INLINE_GET_BITS = false

// -------------------------------------------------------------------
// if literal sequences is not used (the data was crunched with the -c
// flag) then the following line can be uncommented for shorter and.
// slightly faster code.
.var LITERAL_SEQUENCES_NOT_USED = false

// -------------------------------------------------------------------
// if the sequence length is limited to 256 (the data was crunched with
// the -M256 flag) then the following line can be uncommented for
// shorter and slightly faster code.
.var MAX_SEQUENCE_LENGTH_256 = false

// -------------------------------------------------------------------
// if the sequence length 3 has its own offset table (the data was
// crunched with the -P+16 flag) then the following
// line must be uncommented.
.var EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE = false

// -------------------------------------------------------------------
// if sequence offsets are not reused (the data was crunched with the
// -P-32 flag) then the following line must be uncommented. Uncommenting the
// line will also result in shorter and slightly faster code.
.var DONT_REUSE_OFFSET = false


// -------------------------------------------------------------------
// The decruncher jsr:s to the exod_get_crunched_byte address when it wants to
// read a crunched byte into A. This subroutine has to preserve X and Y
// register and must not modify the state of the carry nor the overflow flag.
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// The exod_decrunch function is the heart of the decruncher.
// It initializes the decruncher zeropage locations and precalculates the
// decrunch tables and decrunches the data
// This function will not change the interrupt status bit and it will not
// modify the memory configuration.
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// zero page addresses used
// -------------------------------------------------------------------
.var exod_zp_len_lo = $9e
.var exod_zp_len_hi = $9f

.var exod_zp_src_lo  = $ae
.var exod_zp_src_hi  = exod_zp_src_lo + 1

.var exod_zp_bits_hi = $a7
.var exod_zp_ro_state = $a8



.var exod_zp_bitbuf  = $fd
.var exod_zp_dest_lo = exod_zp_bitbuf + 1      // dest addr lo
.var exod_zp_dest_hi = exod_zp_bitbuf + 2      // dest addr hi
.var encoded_entries = 52

//!zone exodecrunch
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
.eval encoded_entries = 68
} 

.var tabl_bi = exod_decrunch_table
.var tabl_lo = exod_decrunch_table + encoded_entries
.var tabl_hi = exod_decrunch_table + encoded_entries * 2

        //// refill bits is always inlined
.macro exod_mac_refill_bits() {
        pha
        jsr exod_get_crunched_byte
        rol
        sta exod_zp_bitbuf
        pla
}

.macro exod_mac_init_zp() {
// -------------------------------------------------------------------
// init zeropage and x reg. (8 bytes)
//
init_zp:
        jsr exod_get_crunched_byte
        sta exod_zp_bitbuf - 1,x
        dex
        bne init_zp
}

exod_get_bits:
        adc #$80                // needs c=0, affects v
        asl
        bpl !gb_skip+
!gb_next:
        asl exod_zp_bitbuf
        bne !gb_ok+
        :exod_mac_refill_bits()
!gb_ok:
        rol
        bmi !gb_next-
!gb_skip:
        bvs !gb_get_hi+
        rts
!gb_get_hi:
        sec
        sta exod_zp_bits_hi
        jmp exod_get_crunched_byte

// -------------------------------------------------------------------
// no code below this comment has to be modified in order to generate
// a working decruncher of this source file.
// However, you may want to relocate the tables last in the file to a
// more suitable address.
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// jsr this label to decrunch, it will in turn init the tables and
// call the decruncher
// no constraints on register content, however the
// decimal flag has to be cleared (it almost always is, otherwise do a cld)
exod_decrunch:

        ldx #3
        :exod_mac_init_zp()

// -------------------------------------------------------------------
// calculate tables (64 bytes) + get_bits macro
// x and y must be #0 when entering
//
        ldy #0
        clc
table_gen:
        tax
        tya
        and #$0f
        sta tabl_lo,y
        beq !shortcut+            // start a new sequence
// -------------------------------------------------------------------
        txa
        adc tabl_lo - 1,y
        sta tabl_lo,y
        lda exod_zp_len_hi
        adc tabl_hi - 1,y
!shortcut:
        sta tabl_hi,y
// -------------------------------------------------------------------
        lda #$01
        sta <exod_zp_len_hi
        lda #$78                // %01111000
        jsr exod_get_bits
// -------------------------------------------------------------------
        lsr
        tax
        beq !rolled+
        php
!rolle:
        asl exod_zp_len_hi
        sec
        ror
        dex
        bne !rolle-
        plp
!rolled:
        ror
        sta tabl_bi,y
        bmi !no_fixup_lohi+
        lda exod_zp_len_hi
        stx exod_zp_len_hi
        .byte $24
!no_fixup_lohi:
        txa
// -------------------------------------------------------------------
        iny
        cpy #encoded_entries
        bne table_gen
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// prepare for main decruncher
.if (!DONT_REUSE_OFFSET) {
        ror exod_zp_ro_state
        sec
}
        ldy exod_zp_dest_lo
        stx exod_zp_dest_lo
        stx exod_zp_bits_hi
// -------------------------------------------------------------------
// copy one literal byte to destination (11 bytes)
//
literal_start1:
.if (!DECRUNCH_FORWARDS) {
        tya
        bne no_hi_decr
        dec exod_zp_dest_hi
.if (!DONT_REUSE_OFFSET) {
        dec exod_zp_src_hi
}
no_hi_decr:
        dey
}
        jsr exod_get_crunched_byte
        sta (exod_zp_dest_lo),y
.if (DECRUNCH_FORWARDS) {
        iny
        bne skip_hi_incr
        inc exod_zp_dest_hi
.if (!DONT_REUSE_OFFSET) {
        inc exod_zp_src_hi
}
skip_hi_incr:
}
// -------------------------------------------------------------------
// fetch sequence length index (15 bytes)
// x must be #0 when entering and contains the length index + 1
// when exiting or 0 for literal byte
next_round:
.if (!DONT_REUSE_OFFSET) {
        ror exod_zp_ro_state
}
        dex
        lda exod_zp_bitbuf
no_literal1:
        asl
        bne nofetch8
        jsr exod_get_crunched_byte
        rol
nofetch8:
        inx
        bcc no_literal1
        sta exod_zp_bitbuf
// -------------------------------------------------------------------
// check for literal byte (2 bytes)
//
        beq literal_start1
// -------------------------------------------------------------------
// check for decrunch done and literal sequences (4 bytes)
//
        cpx #$11
.if (INLINE_GET_BITS) {
        bcc skip_jmp
        jmp exit_or_lit_seq
skip_jmp:
} else {
        bcs exit_or_lit_seq
}
// -------------------------------------------------------------------
// calulate length of sequence (zp_len) (18(11) bytes) + get_bits macro
//
        lda tabl_bi - 1,x
        jsr exod_get_bits
        adc tabl_lo - 1,x       // we have now calculated zp_len_lo
        sta exod_zp_len_lo
.if (!MAX_SEQUENCE_LENGTH_256) {
        lda exod_zp_bits_hi
        adc tabl_hi - 1,x       // c = 0 after this.
        sta exod_zp_len_hi
// -------------------------------------------------------------------
// here we decide what offset table to use (27(26) bytes) + get_bits_nc macro
// z-flag reflects zp_len_hi here
//
        ldx exod_zp_len_lo
} else {
        tax
}
.if (!MAX_SEQUENCE_LENGTH_256) {
        lda #0
}
.if (!DONT_REUSE_OFFSET) {
// -------------------------------------------------------------------
// here we decide to reuse latest offset or not (13(15) bytes)
//
        bit <exod_zp_ro_state
        bmi test_reuse
}
no_reuse:
// -------------------------------------------------------------------
// here we decide what offset table to use (17(15) bytes)
//
.if (!MAX_SEQUENCE_LENGTH_256) {
        sta <exod_zp_bits_hi
}
        lda #$e1
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
        cpx #$04
} else {
        cpx #$03
}
        bcs gbnc2_next
        lda tabl_bit - 1,x
gbnc2_next:
        asl exod_zp_bitbuf
        bne gbnc2_ok
        tax
        jsr exod_get_crunched_byte
        rol
        sta exod_zp_bitbuf
        txa
gbnc2_ok:
        rol
        bcs gbnc2_next
        tax
// -------------------------------------------------------------------
// calulate absolute offset (zp_src) (17 bytes) + get_bits macro
//
        lda tabl_bi,x
        jsr exod_get_bits
.if (!DECRUNCH_FORWARDS) {
        adc tabl_lo,x
        sta exod_zp_src_lo
        lda exod_zp_bits_hi
        adc tabl_hi,x
        adc exod_zp_dest_hi
        sta exod_zp_src_hi
} else {
        clc
        adc tabl_lo,x
        eor #$ff
        sta exod_zp_src_lo
        lda exod_zp_bits_hi
        adc tabl_hi,x
        eor #$ff
        adc exod_zp_dest_hi
        sta exod_zp_src_hi
        clc
}
// -------------------------------------------------------------------
// prepare for copy loop (2 bytes)
//
        ldx exod_zp_len_lo
// -------------------------------------------------------------------
// main copy loop (30 bytes)
//
copy_next:
.if (!DECRUNCH_FORWARDS) {
        tya
        bne !copy_skip_hi+
        dec exod_zp_dest_hi
        dec exod_zp_src_hi
!copy_skip_hi:
        dey
}
.if (!LITERAL_SEQUENCES_NOT_USED) {
        bcs get_literal_byte
}
        lda (exod_zp_src_lo),y
literal_byte_gotten:
        sta (exod_zp_dest_lo),y
.if (DECRUNCH_FORWARDS) {
        iny
        bne !copy_skip_hi+
        inc exod_zp_dest_hi
        inc exod_zp_src_hi
!copy_skip_hi:
}
        dex
        bne copy_next
.if (!MAX_SEQUENCE_LENGTH_256) {
        lda exod_zp_len_hi
.if (INLINE_GET_BITS) {
        bne copy_next_hi
}
}
        stx exod_zp_bits_hi
.if (!INLINE_GET_BITS) {
        beq next_round
} else {
        jmp next_round
}
copy_next_hi:
.if (!MAX_SEQUENCE_LENGTH_256) {
        dec exod_zp_len_hi
        jmp copy_next
}
test_reuse:
.if (!DONT_REUSE_OFFSET) {
// -------------------------------------------------------------------
// test for offset reuse (11 bytes)
//
        bvs no_reuse
.if (MAX_SEQUENCE_LENGTH_256) {
        lda #$00                // fetch one bit
}
        asl exod_zp_bitbuf
        bne gbnc1_ok
        pha
        jsr exod_get_crunched_byte
        rol
        sta exod_zp_bitbuf
        pla
gbnc1_ok:
        rol
        beq no_reuse            // bit == 0 => C=0, no reuse
        bne copy_next           // bit != 0 => C=0, reuse previous offset
}
// -------------------------------------------------------------------
// exit or literal sequence handling (16(12) bytes)
//
exit_or_lit_seq:
.if (!LITERAL_SEQUENCES_NOT_USED) {
        beq decr_exit
        jsr exod_get_crunched_byte
.if (!MAX_SEQUENCE_LENGTH_256) {
        sta exod_zp_len_hi
}
        jsr exod_get_crunched_byte
        tax
        bcs copy_next
decr_exit:
}
        rts
get_literal_byte:
.if (!LITERAL_SEQUENCES_NOT_USED) {
        jsr exod_get_crunched_byte
        bcs literal_byte_gotten
}
tabl_bit:
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
// -------------------------------------------------------------------
// the static stable used for bits+offset for lengths 1, 2 and 3 (3 bytes)
// bits 2, 4, 4 and offsets 64, 48, 32 corresponding to
// %10010000, %11100011, %11100010
        .byte $90, $e3, $e2
} else {
// -------------------------------------------------------------------
// the static stable used for bits+offset for lengths 1 and 2 (2 bytes)
// bits 2, 4 and offsets 48, 32 corresponding to %10001100, %11100010
        .byte $8c, $e2
}

// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------

// -------------------------------------------------------------------
// this 156 (204) byte table area may be relocated. It may also be
// clobbered by other data between decrunches.
// -------------------------------------------------------------------
exod_decrunch_table:
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.if (EXTRA_TABLE_ENTRY_FOR_LENGTH_THREE) {
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
}
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        .byte 0,0,0,0,0,0,0,0,0,0,0,0
// -------------------------------------------------------------------
// end of decruncher
// -------------------------------------------------------------------