static block_t decode_block(block_t & block, block_t const& depth_table, uint16_t size)
{
   block_t out_buff;
   BitArrayRead b(block);

   for(uint16_t i=0; i<size; i++)
   {
      //Decode the input bitstream
      //This decoding method is slow, however it requires no extra RAM or variables,
      //which makes it interesting for embedded applications.

      unsigned int nbits = 0;
      //This hodls the currently read code, and the code we'll compare it to
      long code = 0, matchcode = 0;
      bool found = false;
      uint8_t value = 0;
      do
      {
         //We do the "clever algorithm" again but this time we search to which symbol
         //the code we have belongs to
         nbits++;
         code <<= 1;
         if(b) code |=1;
         matchcode <<= 1;

         //Search if the read code corresponds to something...
         for(unsigned int j = min; !found && j <= max; j++)
         {
            unsigned int match_len = depth_table[j-min];
            if(match_len != nbits) continue;

            if(matchcode == code)
            {
               found = true;
               value = j;
            }
            matchcode++;
         }
         //No -> continue searching among longer codes
      }
      while(!found);
      //Yes -> we decoded a byte
      out_buff.push_back(value);
   }
   return out_buff;
}

; Decode one symbol from a cannonical huffman encoded bistream
; (To decode multiple symbols this have to be called within a loop)
; Note that some variables must be inintialized before decoding the 1st symbol

Get_Huff_Value
        lda #$00
        sta nbits
        sta code_l
        sta code_m
        sta code_h              ; Needed only if some codes are longer than 16-bit
        sta match_code_l
        sta match_code_m
        sta match_code_h        ; Needed only if some codes are longer than 16-bit

main_loop:
        inc nbits

        jsr Read_bit_from_stream        ;Read one bit and shift in the current code variable
        rol code_l
        rol code_m
        rol code_h

        asl match_code_l
        rol match_code_m
        rol match_code_h

        ; Search if the read code correspond to something...
        ldy #$00
search_loop:
        lda Huffman_length_tbl, Y          ; Search for a node that has the current length
        cmp nbits
        bne not_found

found_length:
        lda match_code_l
        cmp code_l
        bne code_wrong
        lda match_code_m
        cmp code_m
        bne code_wrong
        lda match_code_h
        cmp code_h
        bne code_wrong

found:
        tya                ; Value in Y
        rts

code_wrong:
        inc match_code_l        ; If the code is not this one, match_code is incremented by '1' and continue searching
        bne not_found
        inc match_code_m
        bne not_found
        inc match_code_h

not_found:
        iny                    ; Next code
        bne search_loop        ; Continue for searching for same length
        beq main_loop          ; Searching for a longer length

Read_bit_from_stream:         ; Read a single bit from input stream and return it in C flag
        dec HuffBitCtr
        bpl _not_next_byte

        lda #$07
        sta HuffBitCtr
        inc HuffPointerL
        bne +
        inc HuffPointerH

+       lda (HuffPointerL),Y  ; Read next byte in shift register
        sta HuffShiftReg
_not_next_byte
        lsr HuffShiftReg
        rts

Read_bit_from_stream:          ; Read a single bit from input stream and return it in C flag
        lsr HuffShiftReg
        bne _not_next_byte

        lda (HuffPointerL),Y   ; Read next byte in shift register
        inc HuffPointerL
        bne +
        inc HuffPointerH
+       sec
        ror a
        sta HuffShiftReg
_not_next_byte
        rts

array: numCodesWithNumBits[maxBits]   ; for an index n, yields how many characters are represented by n+1 bits
array: codes[]   ; list of sorted canonical codes, smallest bit length first

inputCode = 0
firstCodeWithNumBits = 0
startIndexForCurrentNumBits = 0

for numBits = 0 to maxBits - 1

    ; build input code
    inputCode = (inputCode << 1) | getNextBit()

    ; get how many canonical codes have this many bits
    numCodes = numCodesWithNumBits[numBits]

    ; if input code so far is within the range of the first code with the current number of bits, it's a match
    indexForCurrentNumBits = inputCode - firstCodeWithNumBits
    if indexForCurrentNumBits < numCodes
        return codes[startIndexForCurrentNumBits + indexForCurrentNumBits];
    else
        ; otherwise, move to the next bit length
        firstCodeWithNumBits = (firstCodeWithNumBits + numCodes) << 1
        startIndexForCurrentNumBits += numCodes
    endif

next

; Shouldn't get here; means the codebook was invalid

OUTPUT-STRING-INDEX -> 0000
HUFFMAN-POP-TABLE -> 0001
HUFFMAN-PTR -> 0003
HUFFMAN-BITS -> 0005
DECODER:ACC-HI -> 000C
DECODER:ACC-LO -> 000D
DECODER:NEXT-BYTE -> 000E

HUFFMAN-NEXT 070E A000     LDY #$00
                     0710 840C     STY $0C   ;clear accumulator
                     0712 840D     STY $0D
                     0714 88       DEY       ;Start at zero in pop table, following the first INY
   DECODER:FETCH-BIT 0715 C605     DEC $05
                     0717 D014     BNE $072D ;DECODER:GOT-BITS
                     ;New byte required
                     ;Save our pop table index
                     0719 98       TYA
                     071A AA       TAX
                     071B A000     LDY #$00
                     071D B103     LDA ($03),Y
                     071F 850E     STA $0E
                     0721 E603     INC $03   ;PTR
                     0723 D002     BNE $0727 ;L1:INC16-DONE
                     0725 E604     INC $04   ;PTR + 1
       L1:INC16-DONE 0727 A908     LDA #$08
                     0729 8505     STA $05
                     ;Restore the pop table index
                     072B 8A       TXA
                     072C A8       TAY
                     ;Lets rotate a bit from the next byte
                     ;into the accumulator
    DECODER:GOT-BITS 072D 060E     ASL $0E
                     072F 260D     ROL $0D
                     0731 260C     ROL $0C
                     0733 C8       INY
                     0734 B101     LDA ($01),Y ;Any symbols at this length?
                     0736 F0DD     BEQ $0715 ;DECODER:FETCH-BIT
                     0738 C8       INY       ;Skip row indicator byte
                     ;We have some symbols- does the accumulator hold one?
                     ;It does if the accumulator is less than the max-code
                     ;for codes of this length. So let's compare it.
                     0739 B101     LDA ($01),Y
                     073B C50C     CMP $0C
                     073D 3014     BMI $0753 ;DECODER:GT1  ;acc-hi > max-code(len)-hi
                     073F C8       INY
                     0740 B101     LDA ($01),Y
                     0742 C50D     CMP $0D
                     0744 300E     BMI $0754 ;DECODER:GT2  ;acc-lo > max-code(len)-lo
                     0746 C8       INY
                     ;Now acc<=max-code(len), this means we have a symbol woo!
                     ;To get the symbol index we subtract the offset
                     ;which has kindly been pre-computed in the pop table
                     0747 38       SEC
                     0748 A50D     LDA $0D
                     074A F101     SBC ($01),Y ;- offset lo
                     074C AA       TAX
                     074D C8       INY
                     074E A50C     LDA $0C
                     0750 F101     SBC ($01),Y ;- offset hi
                     ;Return to caller with index-hi in A and index-lo in X
                     0752 60       RTS
                     ;Skip rest of row and get next bit
         DECODER:GT1 0753 C8       INY
         DECODER:GT2 0754 C8       INY
                     0755 C8       INY
                     0756 D0BD     BNE $0715 ;DECODER:FETCH-BIT
                     ;String Table
                     ;General strings huffman population
                     ;0 symbols of length 1
                     ;Max Code: NIL Offset: NIL
    STRING-POP-TABLE 0758 00       DB $00
                     ;1 symbols of length 2
                     ;Max Code: 0000 Offset: 0000
                     0759 FF0000.. DB $FF, $00, $00, $00, $00
                     ;0 symbols of length 3
                     ;Max Code: NIL Offset: NIL
                     075E 00       DB $00
                     ;6 symbols of length 4
                     ;Max Code: 0009 Offset: 0003
                     075F FF0009.. DB $FF, $00, $09, $03, $00
                     ;6 symbols of length 5
                     ;Max Code: 0019 Offset: 000D
                     0764 FF0019.. DB $FF, $00, $19, $0D, $00
                     ;7 symbols of length 6
                     ;Max Code: 003A Offset: 0027
                     0769 FF003A.. DB $FF, $00, $3A, $27, $00
                     ;8 symbols of length 7
                     ;Max Code: 007D Offset: 0062
                     076E FF007D.. DB $FF, $00, $7D, $62, $00
                     ;4 symbols of length 8
                     ;Max Code: 00FF Offset: 00E0
                     0773 FF00FF.. DB $FF, $00, $FF, $E0, $00
                 END 0778 00       BRK       ;HUFFMAN-PTR ;HUFFMAN-PTR + 1