(vals (match vals

                 ((pos) (kanji-position (array-ref kanji pos)))

                 (() 0))))

         (serialize-trie (serialize-trie-single serialize-int int-size))

         (trie-size (trie-size-single int-size))

(define (uniq lst)

  (let loop ((lst lst) (res '()))

    (match lst

      (() res)

      ((elem lst ...)

       (if (member elem res)

           (loop lst res)

           (loop lst (cons elem res)))))))

                   (uniq (trie-vals trie)))))

         (let ((entry (sxml->result seed frq)))

           (set! results (cons entry results)))

         (let ((entry (sxml->result seed frq)))

           (set! results (cons entry results)))

  (match elem

    ('orth (let ((kanji (filter string? lst)))

             (if (null? kanji)

                 #f

                 `(kanji

                    ,(string-filter

                       (lambda (c)

                         ;; Remove characters that interfere with kanji

                         ;; based search

                         (not (member c '(#\??? #\??? #\??? #\??? #\??? #\??? #\???

                                          #\?? #\???))))

                       (car kanji))))))

    ('count #f)

    ('entry (sxml->result lst frq))

    ('hira `(reading ,(car lst)))

    ('hatsuon `(hatsuon ,(car lst)))

    ('accent `(pitch ,(car lst)))

    ('reading (sxml->reading lst))

    ('form lst)

    ('impli `(impli ,(car lst)))

    ('text (let loop ((text "") (lst lst))

             (match lst

               (() text)

               ((('hasPrecedingSpace . _) lst ...)

                (loop (string-append " " text) lst))

               ((('hasFollowingSpace . _) lst ...)

                (string-append (loop text lst) " "))

               (((? string? s) lst ...)

                (loop (string-append text s) lst)))))

    ('famn (sxml->string lst))

    ('expl (sxml->string lst))

    ('expli (filter list? lst))

    ('abbrev (filter list? lst))

    ('token (filter string? lst))

    ('tr (sxml->string lst))

    ('transcr `(transcr ,lst))

    ('trans

      (append (filter list? lst)

              (map (lambda (s) `(trans ,s)) (filter string? lst))))

    ('jap `(jap ,lst))

    ('emph lst)

    ('title (filter string? lst))

    ('transl (filter string? lst))

    ('topic (filter string? lst))

    ('iron (filter string? lst))

    ('specchar (filter string? lst))

    ('scientif (filter string? lst))

    ('wikide #f)

    ('wikija #f)

    ('link #f)

    ('ref (sxml->ref lst))

    ('sref (sxml->ref lst))

    ('etym (sxml->source lst))

    ('literal (sxml->string (list "???" (sxml->string lst) "???")))

    ('def (sxml->string (list "(" (sxml->string lst) ")")))

    ('date (sxml->string (list "(" (sxml->string lst) ")")))

    ('birthdeath (sxml->string (list "(" (sxml->string lst) ")")))

    ('descr (sxml->string (list "(" (sxml->string lst) ")")))

    ('bracket (sxml->string (list "[" (sxml->string lst) "]")))

    ('foreign (if (null? lst) #f `(foreign ,(car lst))))

    ('seasonword `(info ,(string-append "season: " (assoc-ref lst 'type))))

    ('usg `(infos . ,(usg->infos lst)))

    ('sense (sxml->meaning lst))

    ('steinhaus (let ((ref (sxml->string lst)))

                  (if (string? ref)

                      `(ref ,(sxml->string lst))

                      (throw 'not-steinhaus ref))))

    ('pos '()); TODO: actually find what info to use

    ('wordcomponent (cons 'wordcomponent lst))

    ('meishi (cons 'meishi lst))

    ('setsuzokushi (cons 'setsuzokushi lst))

    ('daimeishi (cons 'daimeishi lst))

    ('doushi (cons 'doushi lst))

    ('kandoushi (cons 'kandoushi lst))

    ('keiyoudoushi (cons 'keiyoudoushi lst))

    ('keiyoushi (cons 'keiyoushi lst))

    ('fukushi (cons 'fukushi lst))

    ('rengo (cons 'rengo lst))

    ('suffix (cons 'suffix lst))

    ('prefix (cons 'prefix lst))

    ('kanji (cons 'kanji lst))

    ('rentaishi (cons 'rentaishi lst))

    ('specialcharacter (cons 'specialcharacter lst))

    ('joshi (cons 'joshi lst))

    ('fukujoshi (cons 'fukujoshi lst))

    ('kakujoshi (cons 'kakujoshi lst))

    ('kakarijoshi (cons 'kakarijoshi lst))

    ('shuujoshi (cons 'shuujoshi lst))

    ('setsuzokujoshi (cons 'setsuzokujoshi lst))

    ('jokeiyoushi (cons 'jokeiyoushi lst))

    ('jodoushi (cons 'jodoushi lst))

    ('ruigos lst)

    ('ruigo (ruigo->ref lst))

    ('gramGrp (gram->info lst))))

      (let ((elem-gi (match elem-gi

                       ((_ . elem) elem)

                       (_ elem-gi))))

        (cond

          ((equal? elem-gi 'entries)

           results)

          ((equal? elem-gi 'entry)

           (let ((entry (sxml->result seed frq)))

             (set! results (cons entry results)))

           #f)

          (else

           (let* ((seed (reverse seed))

                  (element (sxml->element seed elem-gi frq)))

             (cons element parent-seed))))))