Как реализовать процедуры decode и unpack?

(define (packhelper lst acc)
  (cond ((null? acc) (packhelper (cdr lst) (list (car lst))))
        ((null? lst) (list acc))
        ((equal? (car lst) (car acc)) (packhelper (cdr lst) (cons (car lst) acc)))
        (else (cons acc (packhelper (cdr lst) (list (car lst)))))))
(define (pack xs)
  (if (null? xs)
      '()
      (packhelper xs '())))
 
(define (encodehelper xs)
  (cond ((null? xs) '())
        ((not (null? xs)) (cons (cons (car (car xs)) (cons (length (car xs)) '())) (encodehelper (cdr xs))))))
 
(define (encode xs)
  (let ((ys (pack xs)))
    (encodehelper ys)))

(defun unpack (w)
  (loop for a in w collect
        (loop repeat (cadr a) collect (car a))))
 
> (unpack '((a 3) (b 2) (c 1)))
((A A A) (B B) (C))

(defun decode (w &optional (a (caar w)) (n (cadar w)))
  (cond ((null w) nil)
        ((plusp n) (cons a (decode w a (1- n))))
        (t (decode (cdr w)))))
 
> (decode '((a 3) (b 2) (c 1)))
(A A A B B C)

(define (p2l p)
  (if (= 0 (cadr p)) '() (cons (car p) (p2l (list (car p) (- (cadr p) 1))))))
  
(define (decode lstp)
    (if (null? lstp) '() (append (p2l (car lstp)) (decode (cdr lstp)))))
 
(define (unpack lstp)
    (if (null? lstp) '() (append (list (p2l (car lstp))) (unpack (cdr lstp)))))
 
 
(display (unpack '((a 3) (b 2) (c 1))))

(defun tf (lst &optional tmp)
       (if (null lst)
           tmp
           (tf (cdr lst) 
           (append tmp 
               (list (make-list (nth 1 (car lst)) :initial-element (nth 0 (car lst))))))))
 
CL-USER> (tf '((a 3) (b 2) (c 1)))
((A A A) (B B) (C))

(defun tf (lst &optional tmp)
       (if (null lst)
           tmp
           (tf (cdr lst) 
           (append tmp (make-list (nth 1 (car lst)) :initial-element (nth 0 (car lst)))))))
 
CL-USER> (tf '((a 3) (d 10) (b 2) (c 1)))
(A A A D D D D D D D D D D B B C)

(defun encode (w &optional (b (car w )) (n 0))
  (cond ((null w) (list (list b n)))
        ((eq b (car w)) (encode (cdr w) b (1+ n)))
        (t (cons (list b n) (encode (cdr w) (car w) 1)))))
 
> (encode '(a a a b b c))
((A 3) (B 2) (C 1))

(defun decode (w)
  (loop for a in w nconc
        (loop repeat (cadr a) collect (car a))))
 
> (decode '((a 3) (b 2) (c 1)))
(A A A B B C)

(defun unpack (w)
  (mapcar #'(lambda (a)
              (loop repeat (cadr a) collect (car a)))
          w))
 
> (unpack '((a 3) (b 2) (c 1)))
((A A A) (B B) (C))

(defun decode (w &optional ac)
  (if w (decode (cdr w)
                (nconc ac (make-list (cadar w)
                                     :initial-element
                                     (caar w))))
      ac))
 
> (decode '((a 3) (b 2) (c 1)))
(A A A B B C)

(defun unpack (w &optional ac)
  (if w (unpack (cdr w)
                (nconc ac `(,(make-list (cadar w)
                                        :initial-element
                                        (caar w)))))
      ac))
 
> (unpack '((a 3) (b 2) (c 1)))
((A A A) (B B) (C))

(defun decode (w &optional ac)
  (if w (decode (cdr w) (nconc ac (loop repeat (cadar w) 
                                        collect (caar w))))
      ac))
 
> (decode '((a 3) (b 2) (c 1)))
(A A A B B C)

(defun unpack (w &optional ac)
  (if w (unpack (cdr w) (nconc ac `(,(loop repeat (cadar w) 
                                           collect (caar w)))))
      ac))
 
> (unpack '((a 3) (b 2) (c 1)))
((A A A) (B B) (C))

(defun decode (w)
  (mapcan #'(lambda (a)
              (loop repeat (cadr a) collect (car a)))
          w))
 
> (decode '((a 3) (b 2) (c 1)))
(A A A B B C)