Разбить список на подсписки с элементами, кратными n

(defun func (var1 var2 / optional-var1 optional-var2)
  (progn
    (setq optional-var1 (<expression>))
    (setq optional-var2 (<expression>))
    ...))

(defun foo (lst /
            counter
            high-margin
            nested-lambda
            return-value
            compare-values)
  (progn
    (setq counter 2)
    (setq high-margin (apply 'max lst))
    (setq nested-lambda
           (lambda (/ ret-val)
             (foreach n lst
               (if (= (rem n counter) 0)
                 (setq ret-val (append ret-val (list n)))
                 nil)
               retval)))
    (setq return-value '(nil))
    (while (<= counter high-mrgin)
      (progn
        (setq return-value (append return-value (list (nested-lambda))))
        (setq counter (1+ counter))))
    return-value))

(defun FN (SP)
    (setq M 0 I 2)
    (foreach EL SP (cond ((> EL M) (setq M EL)))
    ) 
    (while (<= I M)
        (setq SP1 ())
        (foreach EL1 SP 
            (if (= (rem EL1 I) 0) (setq SP1 (cons EL1 SP1)))    
        )       
        (setq I (1+ I))  
        (print (reverse SP1))               
    ) 
)

(defun remove-d (lst n)
  (cond ((null lst) nil)
        ((> (rem (car lst) n) 0) (remove-d (cdr lst) n))
        (t (cons (car lst) (remove-d (cdr lst) n)))))
 
(defun func (lst n res lmax)
  (cond ((> n lmax) res)
        (t ((lambda (rst)
             (if (null rst)
                 (func lst (+ n 1) res lmax)
                 (func lst (+ n 1) (append res (list rst)) lmax)))
            (remove-d lst n))))) 
 
(defun task (lst)
  (func lst 2 nil (apply '+ lst)))
 
Command: (task '(1 2 3 4 11 2 3 4 7 23 18 19 11 17))
((2 4 2 4 18) (3 3 18) (4 4) (18) (7) (18) (11 11) (17) (18) (19) (23))