А что, если Великая теорема Ферма - не верна?!

(defparameter *base* 10)
 
(defun normalize (l)
  (let ((res '())
        (carry 0)
        r)
    (dolist (x l)
      (multiple-value-setq (carry r) (floor (+ x carry) *base*))
      (push r res))
    (unless (zerop carry)
      (push carry res))
    (nreverse res)))
 
(defun l+ (l1 l2)
  (normalize (do ((l1 l1 (rest l1))
                  (l2 l2 (rest l2))
                  (sum '() (cons (+ (or (first l1) 0) (or (first l2) 0)) sum)))
               ((and (null l1) (null l2)) (nreverse sum)))))
 
(defun l* (l1 l2)
  (flet ((mult-by-digit (l d)
           (mapcar #'(lambda (x) (* x d)) l))
         (pad-with-zeroes (l n)
           (dotimes (i n l)
             (push 0 l))))
    (let ((prod nil)
          (n 0))
      (dolist (y l2)
        (setf prod (l+ prod (pad-with-zeroes (mult-by-digit l1 y) n)))
        (incf n))
      prod)))

(defparameter *l1* (loop repeat 100 collect (random *base*)))
(defparameter *l2* (loop repeat 100 collect (random *base*)))
 
CL-USER> *l1*
(1 8 9 3 5 3 8 0 0 8 0 7 7 2 5 9 1 1 9 7 0 8 5 8 5 1 4 4 4 1 7 0 1 0 4 4 8 0 1
 0 8 9 4 8 3 1 8 5 5 9 3 2 2 9 3 7 0 0 2 5 5 1 2 1 0 1 6 9 8 9 1 7 0 3 5 4 3 3
 9 4 2 1 8 0 6 6 6 3 8 2 4 2 8 7 0 6 2 5 5 8)
CL-USER> *l2*
(9 7 9 7 4 3 8 9 1 8 1 3 9 1 5 3 7 5 9 4 6 7 8 4 5 7 7 1 5 5 4 6 6 0 2 5 5 2 4
 3 3 9 2 6 7 1 3 4 0 0 4 0 4 1 2 6 7 6 4 6 9 1 1 0 5 0 9 6 2 4 1 0 0 1 8 0 7 9
 9 4 2 6 6 7 3 0 4 1 0 9 7 8 1 8 5 2 2 4 4 7)
CL-USER> (time (l* *l1* *l2*))
Real time: 0.059364 sec.
Run time: 0.060003 sec.
Space: 385624 Bytes
GC: 1, GC time: 0.008 sec.
(9 9 3 4 5 9 7 4 2 5 8 0 4 6 6 3 0 8 2 0 4 5 1 7 8 0 2 9 8 5 2 5 9 9 9 5 5 1 7
 8 0 6 9 2 6 0 9 9 4 0 2 4 0 6 5 3 5 0 8 5 7 1 9 5 2 9 8 2 9 2 4 9 7 1 8 8 5 4
 6 3 2 2 4 1 6 5 5 6 8 1 9 6 5 4 5 6 7 3 0 5 0 7 6 0 5 5 7 0 9 1 3 9 1 6 3 6 1
 8 4 9 2 2 3 8 2 9 5 1 1 4 9 8 3 2 4 0 1 2 4 7 6 8 5 2 6 6 2 9 4 0 0 1 5 2 0 6
 0 5 1 3 4 8 3 6 1 5 2 1 7 4 0 3 6 2 2 3 3 0 2 6 7 0 2 4 2 7 4 8 1 8 0 6 5 1 7
 0 5 6 3 6)

(defparameter *n1* (parse-integer (format nil "~{~A~}" (reverse *l1*))))
(defparameter *n2* (parse-integer (format nil "~{~A~}" (reverse *l2*))))
 
CL-USER> (time (* *n1* *n2*))
Real time: 1.5E-5 sec.
Run time: 0.0 sec.
Space: 96 Bytes
63650715608184724207620332263047125163843150602510049266258674210423894115928322948163619319075506705037654569186556142236458817942928925917580535604204990629608715599952589208715402803664085247954399