(setq encode
   (   (lambda (rec expr / )
         (eval
            (list 'lambda '(data / key Out expr dotted-p) 
               (list
                  (lambda (rec expr data / )
                     (setq dotted-p (lambda (a / ) (and (listp a) (atom (cdr a)) (not (null (cdr a))))))
                     
                     (   (lambda (Out / )
                           (cons 
                              (cons 0 (cdr Out))
                              (reverse (car Out))
                           )
                        )
                        (rec rec (list data))
                     )
                     
                  )
                  rec
                  expr
                  'data
               )
            )
         )
      )
      (lambda (rec lst / key Out)
         (setq key "")
         (foreach l lst
            (cond
               ((null l) (setq key (strcat Key "N")))
               ((dotted-p l)
                  (setq key (strcat key "["))
                  (cond
                     ((atom (car l))
                        (   (lambda (a / )
                              (setq Key (strcat Key (cdr a)))
                              (setq Out (cons (car a) Out))
                           )
                           (expr (car l))
                        )
                     )
                     ('T
                        (   (lambda (a / )
                              (setq Key (strcat Key (cdr a)))
                              (setq Out (append (car a) Out))
                           )
                           (rec rec (list (car l)))
                        )
                     )
                  )
                  (   (lambda (a / )
                        (setq Key (strcat Key (cdr a)))
                        (setq Out (cons (car a) Out))
                     )
                     (expr (cdr l))
                  )
                  (setq key (strcat key "]"))
               )
               ((listp l)
                  (setq key (strcat key "{"))
                  (   (lambda (a / )
                        (setq key (strcat key (cdr a)))
                        (setq Out (append (car a) Out))
                     )
                     (rec rec l)
                  )
                  (setq key (strcat key "}"))
               )
               ('T 
                  (   (lambda (a / )
                        (setq key (strcat key (cdr a)))
                        (setq Out (cons (car a) Out))
                     )
                     (expr l)
                  )
               )
            )
         )
         (cons Out key)
      )
      (lambda (a / %type)   
         (setq %type (type a))
         (cond
            ((= %type 'SYM) (cons (cons 1 (vl-princ-to-string a)) "S"))
            ((= %type 'ENAME) (cons (cons 1 (cdr (assoc 5 (entget a)))) "E"))
            ((= %type 'VLA-Object) (cons (cons 1 (cdr (assoc 5 (entget (vlax-ename->vla-object a)))) "V")))         
            ((= %type 'INT) 
               (cons
                  (if (< -32768 a 32767)
                     (cons 70 a)
                     (cons 41 (float a))
                  )
                  "."
               )
            )
            ((= %type 'REAL) (cons (cons 40 a) "."))
            ((= %type 'STR) (cons (cons 1 a) "."))
         )
      )
   )
)
;-----------------------------------------------------------
(setq decode
   (   (lambda (rec expr / )
         (eval
            (list 'lambda '(data / )
               (list
                  (lambda (rec expr data / lst key expr)
                     (setq key (cdar data))
                     (setq lst (cdr data))
                     
                     (car (rec rec))
                     
                  )
                  rec
                  expr
                  'data
               )
            )
         )
      )
      (lambda (rec / Out K)
         (while (not (or (= key "") (= (setq K (substr key 1 1)) "}") (= K "]")))
            (cond
               ((eq K "{")
                  (setq key (substr key 2))
                  (setq Out (cons (rec rec) Out))
                  (setq key (substr key 2))
               )
               ((eq K "[")
                  (setq key (substr key 2))
                  (setq Out
                     (cons
                        (   (lambda (a / b c)
                              (cons (car a) (cadr a))
                           )
                           (rec rec)
                        )
                        Out
                     )
                  )
                  (setq key (substr key 2))
               )
               ('T 
                  (setq Out (cons (expr K (car lst)) Out))
                  (setq key (substr key 2))
                  (if (not (eq K "N"))
                     (setq lst (cdr lst))
                  )
               )
            )
         )
         (reverse Out)
      )
      (lambda (K V / )
         (cond
            ((eq K "N") nil)
            ((eq K "S") (read (cdr V)))
            ((eq K "E") (handent (cdr V)))
            ((eq K "V") (vlax-ename->vla-object (handent (cdr V))))
            ((eq K ".")
               (   (lambda (a / )
                     (cond
                        ((= (car a) 41) (fix (cdr a)))
                        ('T (cdr a))
                     )
                  )
                  V
               )
            )
         )
      )
   )
)