anchor.diff:  (defun load (index-path &key (byte-order :native))
     (declare ((or string pathname file-stream) index-path)
              ((member :native :little :big) byte-order))
  -  (let ((sizes (read-array index-path :size 2 :element-type 'uint4 :offset 0 
  -                           :byte-order byte-order)))
  +  (let ((char-path (format nil "~a.char" index-path))
  +        (ext-path (format nil "~a.ext" index-path))
  +        (node-path (format nil "~a.node" index-path)))
       (make-dawg
  -     :node (read-array index-path :element-type 'uint8
  -                                  :size (/ (aref sizes 0) 8)
  -                                  :offset 1
  -                                  :byte-order byte-order)
  -     :ext  (read-array index-path :element-type 'uint4
  -                                  :size (/ (aref sizes 1) 4)
  -                                  :offset (+ 2 (/ (aref sizes 0) 4))
  -                                  :byte-order byte-order))))
  +     :node (read-array node-path :size (read-count node-path byte-order) 
  +                                 :element-type 'uint1 :offset 4 :byte-order byte-order)
  +     :ext (read-array ext-path :size (floor (read-count ext-path byte-order) 4)
  +                               :element-type 'uint4 :offset 1 :byte-order byte-order)
  +     :char-map (read-array char-path :size #x100 :element-type 'uint1 :byte-order byte-order))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;; auxiliary function(2)
   (declaim (inline %type))
  -(defun terminal? (node) (ldb-test (byte 1 31) (the uint8 node)))
  -(defun base (node) (ldb (byte 29  0) (the uint8 node)))
  -(defun chck (node) (ldb (byte  8 32) (the uint8 node)))
  -(defun %type (node) (ldb (byte 2 29) (the uint8 node)))
  +(defun terminal? (node) (ldb-test (byte 1 19) (the uint5 node)))
  +(defun base (node) (ldb (byte 19  0) (the uint5 node)))
  +(defun chck (node) (ldb (byte  7 20) (the uint5 node)))
  +(defun %type (node)
  +  (declare (uint5 node))
  +  (if (ldb-test (byte 1 39) node)
  +      (+ 2 (ldb (byte 1 38) node))
  +    0))
   
   (defun sibling-total (da node)
  -  (ecase (%type node)
  -    (0 (ldb (byte  8 56) node))
  -    (1 (ldb (byte 16 48) node))
  -    (2 (ldb (byte 24 40) node))
  -    (3 (aref (dawg-ext da)
  -             (ldb (byte 24 40) node)))))
  +  (case (%type node)
  +    (0 (ldb (byte  5 34) node))
  +    (2 (ldb (byte 11 27) node))
  +    (t (aref (dawg-ext da)
  +             (ldb (byte 11 27) node)))))
   
   (defun inc-id (id da node)
     (let ((terminal (if (terminal? node) 1 0))
           (sibling-total (sibling-total da node)))
       (the uint4 (+ id terminal sibling-total))))
   
  -(defun check-encoded-children (in node)
  -  (declare (uint8 node))
  -  (labels ((enc-chck (n)
  -             (ldb (byte 8 (+ 40 (* 8 n))) node))
  -           (check (n &aux (chck (enc-chck n)))
  +(defun arc (char dawg)
  +  (aref (dawg-char-map dawg) char))
  +
  +(defun check-encoded-children (in node dawg)
  +  (declare (uint5 node))
  +  (labels ((enc-chck ()
  +             (ldb (byte 7 27) node))
  +           (check (&aux (chck (enc-chck)))
                (or (zerop chck)
  -                  (and (= chck (stream:read in))
  +                  (and (= chck (arc (stream:read in) dawg))
                          (not (stream:eos? in))))))
       (declare (inline enc-chck check))
       (case (%type node)
  -      (0 (and (check 0) (check 1)))
  -      (1 (check 0))
  +      (0 (check))
         (t t))))
   
   (defun get-node (dawg index)
     (declare (dawg dawg)
              (positive-fixnum index))
  -  (aref (dawg-node dawg) index))
  +  (with-slots (node) (the dawg dawg)
  +    (let ((n 0)
  +          (i (* index 5)))
  +      (declare (uint5 n))
  +      (setf (ldb (byte 8 32) n) (aref node (+ i 0))
  +            (ldb (byte 8 24) n) (aref node (+ i 1))
  +            (ldb (byte 8 16) n) (aref node (+ i 2))
  +            (ldb (byte 8 08) n) (aref node (+ i 3))
  +            (ldb (byte 8 00) n) (aref node (+ i 4)))
  +      n)))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;
   ;;; external function(2)
  
positive.code:            build
             load
             member?
             get-id
             each-common-prefix
             each-predictive))
  (in-package :dawg)
  
  (package-alias :dawg.octet-stream :stream)
  
  ;;;;;;;;;;;;;;;;;;;;
  ;;; special variable
  
negative.code: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;; dawg (double-array format)
  (defstruct dawg
    (node #() :type (simple-array uint1))
    (ext  #() :type (simple-array uint4))
    (char-map #() :type (simple-array uint1)))
  
  (defmethod print-object ((o dawg) stream)
    (print-unreadable-object (o stream :type t :identity t)
  