anchor.diff:  
   (defun getter-name (choice-name slot-name)
     (alexandria:symbolicate 'get- choice-name '- slot-name))
  -
  -
  -(defun generate-choice-encoder (name class tag alternatives)
  -  `(defun ,(encoder-name name) (stream choice) (encode-choice ',alternatives stream choice)))
  -
  -(defun generate-choice-decoder (name class tag alternatives)
  -  `(defun ,(decoder-name name) (stream)
  -
  -
  -     (decode-choice ',alternatives stream)
  -
  -     ))
  -
   
   (defmacro defchoice (name (&optional class tag) &rest alternatives)
     (unless (valid-alternatives-p alternatives)
  
positive.code:                   `(encode-tagged-type stream #'enc (,(accessor-name name '%value) choice)
                                         :class ,class :tag ,tag)
                    `(enc stream)))))
         (defun ,(decoder-name name) (stream)
           (declare (type stream stream))
           (flet ((dec (stream)
                    (decode-identifier stream)
                    (let ((value (,(alexandria:symbolicate 'make- name))))
                      ,(if (some (lambda (alternative) (find :tag alternative)) alternatives)
                           `(let ((v (nibbles:make-octet-vector (decode-length stream))))
                              (read-sequence v stream)
                              (flexi-streams:with-input-from-sequence (stream v)
                                (do ()
                                    ((not (listen stream)))
                                  (let ((tag (decode-identifier stream)))
                                    (decode-length stream)
                                    (ecase tag
                                      ,@(mapcar (lambda (slot)
                                                  (destructuring-bind (s-name s-type &key tag optional) slot
                                                    (declare (ignore optional))
                                                    `(,tag
                                                      (flet ((dec (stream)
                                                               ,@(cond
                                                                   ((symbolp s-type)
                                                                    `((,(decoder-name s-type) stream)))
                                                                   ((eq (car s-type) :integer)
                                                                    `((decode-integer stream)))
                                                                   ((eq (car s-type) :sequence-of)
                                                                    `((decode-sequence-of stream
                                                                                          #',(decoder-name (cadr s-type))))))))
                                                        (setf (,(accessor-name name s-name) value)
                                                              (dec stream))))))
                                         alternatives))))))
                           `(progn
                              (decode-length stream)
                              ,@(mapcar (lambda (slot)
                                          (destructuring-bind (s-name s-type) slot
                                            `(flet ((dec (stream)
                                                      ,@(cond
                                                          ((symbolp s-type)
                                                           `((,(decoder-name s-type) stream)))
                                                          ((eq (car s-type) :integer)
                                                           `((decode-integer stream)))
                                                          ((eq (car s-type) :sequence-of)
                                                           `((decode-sequence-of stream
                                                                                 #',(decoder-name (cadr s-type))))))))
                                               (setf (,(accessor-name name s-name) value)
                                                     (dec stream)))))
                                        alternatives)))
                      value)))
             ,(if (and class tag)
                  `(decode-tagged-type stream #'dec)
                  `(dec stream)))))))
  
  
  ;; -----------------------------------
  
  (defun gen (asn1 &optional (stream *standard-output*))
    (destructuring-bind (module-name assignments &key explicit implicit oid) (cdr asn1)
      (declare (ignore explicit implicit))
      (let ((*print-case* :downcase))
        (pprint `(defpackage ,(string-upcase module-name)
                   (:use #:cl #:asinine #:asinine))
                stream)
        (terpri stream)
        (pprint `(in-package ,(string-upcase module-name))
  
negative.code: ;;;; Copyright (c) Frank James 2015 <frank.a.james@gmail.com>
  ;;;; CHOICE implementation: Copyright (c) Pascal J. Bourguignon 2016 <pjb@informatimago.com>
  ;;;; This code is licensed under the MIT license.
  
  (in-package #:asinine)
  