anchor.diff:              (values value hold)
               (loop code hold)))))
   
  -; converts lengths array to code->value huffman ff
  -; вот по таким правилам:
  -;  [если воспринимать коды как числа, у которых первый бит кода это старший разряд, то] все коды одной длины должны быть последовательными значениями, упорядоченными так же, как символы, которые они кодируют
  -;  [если воспринимать коды как строки бит, то] коды меньшей длины лексикографически предшествуют кодам большей длины
  +; конвертируем массив длин в таблицу хафмана
   (define (make-huffman-table lengths)
      (let loop  ((codes #empty)
                  (pairs (sort (lambda (a b) (< (car a) (car b))) ; отсортированный и
  
positive.code: (define (bits n hold)
     (let loop ((hold hold))
        (tuple-apply hold (lambda (v i l)
           (unless (less? i n)
              (values (band v (- (<< 1 n) 1)) (tuple (>> v n) (- i n) l))
              ; если же не хватает бит, втянем из потока
              (loop (tuple
                 (bor v (<< (car l) i))
                 (+ i 8)
                 (cdr l))))))))
  
  ; code - huffman table (from make-huffman-table), hold - binary stream
  (define (huffman codes hold)
     (let loop ((code 1) (hold hold))
        (let*((bit hold (bits 1 hold))
  
negative.code:                                           65 97  129 193  257 385 ; 5, 6, 7 bits pairs
                                            513 769  1025 1537      ; 8, 9
                                            2049 3073  4097 6145    ; 10, 11 / and 12, 13
                                            8193 12289  16385 24577) shift))
                             ; декодированное смещение
                             (shift (+ delta clarf))
                             (shift (- shift)))
                          ; lz77, копируем строку
                          (let copy ((i i) (p (band (+ i #x10000 shift) #x7FFF)) (n length) (out #null))
                             (if (eq? n 0)
                                ; вернем скопированную строку в виде '(c c c ... c c . lambda)
                                (let reverse ((old out) (new (lambda () (loop i hold))))
                                   (if (null? old)
                                      new
                                      (reverse (cdr old) (cons (car old) new))))
                                ; скопируем строку в историю и продоллжим копирование
                                (let ((code (ref history p)))
                                   (set-ref! history i code)
                                   (copy (band (+ i 1) #x7FFF) (band (+ p 1) #x7FFF) (- n 1) (cons code out)))))))
                    ; temp
                    (else
                       (print-to stderr "INVALID STREAM DETECTED")
                       #null)))))))
  
     ; вернем поток с декодированным первым байтом
     (force
        (make-block-decoder 0 (tuple 0 0 l))))
  
  
  ;; (define port (fopen "15_0.lanim" 0)) ;stdin)
  ;; (define out (fopen "15_0.i.out" 1))
  ;; (define stream (port->byte-stream port))
  ;; (let loop ((s (inflate (ldrop stream 10))))
  ;;    (cond
  ;;       ((null? s)
  ;;          (print "\nEND."))
  ;;       ((pair? s)
  ;;          ;(display (string (car s)))
  ;;          (write-bytes out (list (car s)))
  ;;          (loop (cdr s)))
  ;;       (else
  ;;          (loop (force s)))))
  
  
  ;; (define port (fopen "hello" 0))
  ;; (define stream (port->byte-stream port))
  ;; (let loop ((s (inflate (ldrop stream 10))))
  ;;    ;(print "s: " s)
  ;;    ;(set-car! num (+ (car num) 1))
  ;;    ;(if (eq? (car num) 170) (shutdown 1))
  ;;    (cond
  ;;       ((null? s)
  ;;          (print "\nEND."))
  ;;       ((pair? s)
  ;;          ;(for-each display (list "[" (string (car s)) "]"))
  ;;          (display (string (car s)))
  ;;          (loop (cdr s)))
  ;;       (else
  ;;          (loop (force s)))))
  
  ;; (print "ok.")
  ;; (define stream (file->list "99"))
  
  ;; (let*((ID1 (car stream))
  ;;       (stream (cdr stream))
  