(defun rec(n_ func)
 (setq lst nil)
 (setq stk nil)
 (recurse lst stk 1 n_ func)
)

(defun recurse(lst stk k_ n_ func)
 (cond ( (> k_ n_) (funcall func lst) )
       ( 1 (setq c_ 0)
           (loop

            (cond ((eql c_ 10) (return T)))
            (push c_ stk)
            (recurse (append lst (list c_)) stk (+ k_ 1) n_ func) 
            (setq c_ (pop stk))
            (setq c_ (+ c_ 1))
           )
       )
 )
)

(defun trans(matr)
 (cond
       ((every 'NULL matr) nil )
       (1 (cons (mapcar 'car matr) (trans (mapcar 'cdr matr))))
 )
)

(defun sum (lst)
 (cond ( (eql lst nil) 0)
       ( (atom lst) lst )
       ( 1 (+ (car lst) (sum (cdr lst))))
 )
)

(defun chk (lst1 lst2)
 (cond ( (eql lst1 nil) (eql lst2 nil) )
       ( (eql (car lst1) (car lst2)) (chk (cdr lst1) (cdr lst2)) )
       ( 1 nil)
 ) 
)

(defun check (matr rgh btn)
 (cond 
       ( (chk rgh (mapcar 'sum matr)) (chk btn (mapcar 'sum (trans matr))) )
       ( 1 nil)
 )
)


;------------------------- Problem solution -------------------------------
(defun is_in (el lst)
 (cond ( (eql lst nil) nil) 
       ( (eql el (car lst)) T)
       ( 1  (is_in el (cdr lst)) )
 )
)

(defun union_lst (lst1 lst2)
 (cond ( (eql lst2 nil) lst1 )
       ( (eql lst1 nil) lst2 )
       ( (is_in (car lst1) lst1) (union_lst (cdr lst1) lst2) )
       ( (is_in (car lst2) lst1) (union_lst lst1 (cdr lst2)) )
       ( 1 (cons (car lst2) (union_lst lst1 (cdr lst2))) )
 )
)

(defun uni_union (lst)
 (cond ((eql lst nil) nil)
       (1 (union_lst (car lst) (uni_union (cdr lst))))
 )
)

(defun val_of (var vals alp)
 (cond ( (eql vals nil) nil )
       ( (eql alp nil) nil )
       ( (eql var (car alp)) (car vals) )
       ( 1 (val_of var (cdr vals) (cdr alp)) )
 )
)

(defun podstav (vars vals alp)
 (cond ( (eql vars nil) nil)
       ( 1 (cons (val_of (car vars) vals alp) (podstav (cdr vars) vals alp)) )
 )
)

(defun podstav_matr (matr vals alp)
 (cond ( (eql matr nil) nil)
       ( 1 (cons (podstav (car matr) vals alp) (podstav_matr (cdr matr) vals alp)) )
 )
)

(defun rec_func(matr rgh btn vals alp)
 (cond ( (check (podstav_matr matr vals alp) rgh btn) (print vals) ))
)

(defun solve (matr rgh btn)
 (setq alp (uni_union matr))
 (print alp)
 (rec (length alp) '(LAMBDA (lst) (rec_func matr rgh btn lst alp)))
)

(solve '((a a b) (b a c) (c b a)) '(4 6 6) '(6 4 6))
(system)