Нужно написать проги на мулиспе

(defun quadros (w n &optional ac acc (m n)) 
  (cond ((null w)  (reverse (cons (reverse ac) (reverse acc))))
        ((= m 1) (quadros (cdr w) n nil (cons (reverse (cons (car w) ac)) acc) n))
        ((quadros (cdr w) n (cons (car w) ac) acc (1- m)))))
 
> (quadros '(A B (C D) 1 2 NIL) 4)
((A B (C D) 1) (2 NIL))

(defun num-counter (lst sum num)
    (cond ((null lst) (list sum num))
          ((numberp (car lst)) (num-counter (cdr lst) (+ sum (car lst)) (+ num 1)))
          ((listp (car lst)) 
            (num-counter (cdr lst) (+ sum  (car (num-counter (car lst) 0 0))) (+ num (cadr (num-counter (car lst) 0 0)))))
          (t (num-counter (cdr lst) sum num))))

(defun div-list (lst n c a r)
  (cond ((null lst) (append r (list a)))
        ((< c n) (div-list (cdr lst) n (+ c 1) (append a (list (car lst))) r))  
        (t (div-list (cdr lst) n 1 (list (car lst)) (append r (list a))))))

(defun div-list! (lst n)
   (div-list lst n 0 nil nil)

(defun num-counter! (lst)
  (num-counter lst sum num)
)

(div-list! lst n)

(num-counter! lst)

(defun ncount (lst n c)
  (cond ((null lst) c)
        ((= n (car lst)) (ncount (cdr lst) n (+ c 1)))
        (t (ncount (cdr lst) n c))))  
 
(defun lcount (lst n m r)
  (cond ((null n) (lcount lst 1 (apply 'max lst) nil))
        ((<= n m) (lcount lst (+ n 1) m (append r (list (ncount lst n 0)))))
        (t r)))
        
(defun lcount! (lst)
   (lcount lst nil nil nil))
 
==> lcount!
 
(lcount! '(1 2 3 1 2 3 3 5 5 6 8))
 
==> (2 2 3 0 2 1 0 1)