(defun parse-number (num-string)
  (cond
    ((equal (subseq num-string 0 1) "0") (values 0 (subseq num-string 1)))
    ((equal (subseq num-string 0 1) "1") (values 1 (subseq num-string 1)))
    ((equal (subseq num-string 0 2) "22")
     (multiple-value-bind (len rest-string)
	 (parse-number (subseq num-string 2))
       (when (zerop len)
	 (return-from parse-number (values 2 rest-string)))
       (values
	 (+ (/ (1- (expt 3 len)) 2)
	    (read-from-string (format nil "#3R~A" (subseq rest-string 0 len)))
	    2)
	 (subseq rest-string len))))
    (t (error "Not a valid number"))))

(defun gen-number (num)
  (cond
    ((< num 2) (format nil "~A" num))
    ((eql num 2) "220")
    (t (let ((array-len (floor (log (- (* 2 num) 3) 3))))
	 (format nil
		 (concatenate 'simple-string
			      "22~A~3,"
			      (format nil "~A" array-len)
			      ",'0R")
		 (gen-number array-len)
		 (- num
		    (/ (1- (expt 3 array-len)) 2)
		    2))))))

(defun parse-whole-string (num-string)
  (if (equal num-string "")
      (format t "~%")
      (multiple-value-bind (num rest-string)
	  (parse-number num-string)
	(format t "~A " num)
	(when (< 1 (length rest-string))
	    (let ((x (subseq rest-string 0 2)))
	      (when (or (equal x "21") (equal x "20"))
		(format t "[~A] " (elt rest-string 0))
		(setf rest-string (subseq rest-string 1))))
	    (parse-whole-string rest-string))
	(when (and (= 1 (length rest-string))
		   (eq #\2 (elt rest-string 0)))
	  (format t "[2]")))))
	  

(defun gen-whole-string (&rest numbers)
  (apply #'concatenate 'simple-string
	 (mapcar (lambda (num)
		   (gen-number num))
		 numbers)))

(defun group-numbers (&rest numbers)
  (cond
    ((null numbers) (values nil (rest numbers)))
    ((zerop (first numbers)) (values nil (rest numbers)))
    (t (let ((rest-list (rest numbers)))
	 (values
	   (loop for i below (first numbers)
		 for sublis = (multiple-value-bind (sl rl)
				  (apply #'group-numbers (copy-list rest-list))
				(print rest-list)
				(setf rest-list rl)
				sl)
		 collecting sublis)
	   rest-list)))))

(defun encode-list (list)
  (cond
    ((numberp list) (cons list (make-list list :initial-element 0)))
    (t (cons (length list)
	     (mapcan (lambda (sublist)
		     (encode-list sublist))
		   list)))))


(defun gen-simple-car (num)
  (concatenate 'string 
	       (gen-whole-string 1 num)
	       (make-string (1+ num) :initial-element #\0)
	       "10"))