(let ((#:g188 self))
  (car (cdr (member #:g188 (kids (fm-parent #:g188))))))


(let ((#:g189 nil))
  (car (cdr (member #:g189 (kids (fm-parent #:g189))))))


Error while parsing arguments to DEFMACRO ^FM-NEXT-SIB:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (&OPTIONAL (SELF)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO ^FM-NEXT-SIB:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (&OPTIONAL (SELF)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO ^FM-NEXT-SIB:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (&OPTIONAL (SELF)):
  between 0 and 1 expected, but got 3


(let ((#:g190 'lol-gen::some-name))
  (car (cdr (member #:g190 (kids (fm-parent #:g190))))))


Error while parsing arguments to DEFMACRO EKO:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST TRCARGS) &REST BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO C??:
  too few elements in
    ()
  to satisfy lambda list
    ((&KEY (TAGP) (IN) (OUT)) &BODY BODY):
  at least 1 expected, but got 0


(make-c-dependent :code 'nil :value-state :unevaluated :rule
                  (c-lambda
                    (let ((#:g196 (gensym "tag")) (*trcdepth* (1+ *trcdepth*)))
                      (declare (ignorable self #:g196))
                      nil
                      (count-it :c?? (c-slot-name c) (md-name (c-model c)))
                      (let ((#:result (progn)))
                        (trc "c?? result:" #:result (c-slot-name c)
                             (when nil #:g196))
                        #:result))))


(make-c-dependent :code '(nil) :value-state :unevaluated :rule
                  (c-lambda
                    (let ((#:g197 (gensym "tag")) (*trcdepth* (1+ *trcdepth*)))
                      (declare (ignorable self #:g197))
                      nil
                      (count-it :c?? (c-slot-name c) (md-name (c-model c)))
                      (let ((#:result (progn nil)))
                        (trc "c?? result:" #:result (c-slot-name c)
                             (when nil #:g197))
                        #:result))))


(make-c-dependent :code '((progn)) :value-state :unevaluated :rule
                  (c-lambda
                    (let ((#:g198 (gensym "tag")) (*trcdepth* (1+ *trcdepth*)))
                      (declare (ignorable self #:g198))
                      nil
                      (count-it :c?? (c-slot-name c) (md-name (c-model c)))
                      (let ((#:result (progn (progn))))
                        (trc "c?? result:" #:result (c-slot-name c)
                             (when nil #:g198))
                        #:result))))


(make-c-dependent :code '(:key nil) :value-state :unevaluated :rule
                  (c-lambda
                    (let ((#:g199 (gensym "tag")) (*trcdepth* (1+ *trcdepth*)))
                      (declare (ignorable self #:g199))
                      nil
                      (count-it :c?? (c-slot-name c) (md-name (c-model c)))
                      (let ((#:result (progn :key nil)))
                        (trc "c?? result:" #:result (c-slot-name c)
                             (when nil #:g199))
                        #:result))))


Error while parsing arguments to C?? DEFMACRO:
  unknown keyword: QUOTE; expected one of :TAGP, :IN, :OUT


(c-input (:lazy :once-asked) (progn nil))


(c-input (:lazy :once-asked) (progn nil nil))


(c-input (:lazy :once-asked) (progn nil (progn)))


(c-input (:lazy :once-asked) (progn nil :key nil))


(c-input (:lazy :once-asked) (progn 'lol-gen::some-name))


Error while parsing arguments to DEFMACRO C-ASSERT:
  too few elements in
    ()
  to satisfy lambda list
    (ASSERTION &OPTIONAL PLACES FMT$ &REST FMT-ARGS):
  at least 1 expected, but got 0


(unless *stop* (unless nil (c-break "failed assertion: ~a" 'nil)))


(unless *stop*
  (unless 'lol-gen::some-name
    (c-break "failed assertion: ~a" ''lol-gen::some-name)))


Error while parsing arguments to DEFMACRO FM-COUNT-NAMED:
  too few elements in
    ()
  to satisfy lambda list
    (FAMILY MD-NAME &KEY (GLOBAL-SEARCH)):
  at least 2 expected, but got 0


Error while parsing arguments to DEFMACRO FM-COUNT-NAMED:
  too few elements in
    (NIL)
  to satisfy lambda list
    (FAMILY MD-NAME &KEY (GLOBAL-SEARCH)):
  at least 2 expected, but got 1


(length (fm-find-all nil nil :must-find nil :global-search t))


(length (fm-find-all nil (progn) :must-find nil :global-search t))


Error while parsing arguments to FM-COUNT-NAMED DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


Error while parsing arguments to DEFMACRO FM-COUNT-NAMED:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (FAMILY MD-NAME &KEY (GLOBAL-SEARCH)):
  at least 2 expected, but got 1


Error while parsing arguments to DEFMACRO FM-MAPC:
  too few elements in
    ()
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 0


Error while parsing arguments to DEFMACRO FM-MAPC:
  too few elements in
    (NIL)
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 1


Error while parsing arguments to DEFMACRO FM-MAPC:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 3


Error while parsing arguments to DEFMACRO FM-MAPC:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 1


Error while parsing arguments to DEFMACRO U^:
  too few elements in
    ()
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO U^:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO U^:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO U^:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO WITH-INTEGRITY:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL OPCODE DEFER-INFO DEBUG) &REST BODY):
  at least 1 expected, but got 0


(call-with-integrity nil nil
                     (lambda (opcode defer-info)
                       (declare (ignorable opcode defer-info)))
                     nil)


(call-with-integrity nil nil
                     (lambda (opcode defer-info)
                       (declare (ignorable opcode defer-info))
                       nil)
                     nil)


(call-with-integrity nil nil
                     (lambda (opcode defer-info)
                       (declare (ignorable opcode defer-info))
                       (progn))
                     nil)


(call-with-integrity nil nil
                     (lambda (opcode defer-info)
                       (declare (ignorable opcode defer-info))
                       :key
                       nil)
                     nil)


Invalid opcode for with-integrity: QUOTE. Allowed values: (TELL-DEPENDENTS
                                                           AWAKEN CLIENT
                                                           EPHEMERAL-RESET
                                                           CHANGE POST-CHANGE)


Error while parsing arguments to DEFMACRO FM!V:
  too few elements in
    ()
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO FM!V:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO FM!V:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO FM!V:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO ^VALUE:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO ^VALUE:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO ^VALUE:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO ^VALUE:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


Error while parsing arguments to DEFMACRO ^VALUE:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


(make-cell :inputp t :debug t :value-state :unbound :value nil)


(make-cell :inputp t :debug t :value-state :valid :value nil)


Error while parsing arguments to DEFMACRO C-INPUT-DBG:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (&OPTIONAL (VALUE)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO C-INPUT-DBG:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (&OPTIONAL (VALUE)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO C-INPUT-DBG:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (&OPTIONAL (VALUE)):
  between 0 and 1 expected, but got 3


(make-cell :inputp t :debug t :value-state :valid :value 'lol-gen::some-name)


(make-c-dependent :code '(without-c-dependency) :inputp nil :lazy t
                  :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil)
                  :inputp nil :lazy t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     nil)
                  :inputp nil :lazy t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     (progn))
                  :inputp nil :lazy t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      (progn))))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     :key
                     nil)
                  :inputp nil :lazy t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      :key
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     'lol-gen::some-name)
                  :inputp nil :lazy t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      'lol-gen::some-name)))


(lambda (self) (declare (ignorable self)) (list))


(lambda (self) (declare (ignorable self)) (list nil))


(lambda (self) (declare (ignorable self)) (list nil nil))


(lambda (self) (declare (ignorable self)) (list nil (progn)))


(lambda (self) (declare (ignorable self)) (list nil :key nil))


(lambda (self) (declare (ignorable self)) (list 'lol-gen::some-name))


Error while parsing arguments to DEFMACRO WTRC:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL (MIN) (MAX) &REST BANNER) &BODY BODY):
  at least 1 expected, but got 0


(let ((*trcdepth*
       (if *trcdepth*
           (1+ *trcdepth*)
           0)))
  nil
  (when (< *trcdepth* 50)))


(let ((*trcdepth*
       (if *trcdepth*
           (1+ *trcdepth*)
           0)))
  nil
  (when (< *trcdepth* 50) nil))


(let ((*trcdepth*
       (if *trcdepth*
           (1+ *trcdepth*)
           0)))
  nil
  (when (< *trcdepth* 50) (progn)))


(let ((*trcdepth*
       (if *trcdepth*
           (1+ *trcdepth*)
           0)))
  nil
  (when (< *trcdepth* 50) :key nil))


(let ((*trcdepth*
       (if *trcdepth*
           (1+ *trcdepth*)
           0)))
  nil
  (when (< *trcdepth* lol-gen::some-name)))


Error while parsing arguments to DEFMACRO F-FIND:
  too few elements in
    ()
  to satisfy lambda list
    (SYNAPSE-ID SOUGHT WHERE):
  exactly 3 expected, but got 0


Error while parsing arguments to DEFMACRO F-FIND:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SYNAPSE-ID SOUGHT WHERE):
  exactly 3 expected, but got 1


Error while parsing arguments to DEFMACRO F-FIND:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (SYNAPSE-ID SOUGHT WHERE):
  exactly 3 expected, but got 2


Error while parsing arguments to DEFMACRO F-FIND:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (SYNAPSE-ID SOUGHT WHERE):
  exactly 3 expected, but got 2


Error while parsing arguments to DEFMACRO F-FIND:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SYNAPSE-ID SOUGHT WHERE):
  exactly 3 expected, but got 1


(make-c-dependent :inputp t :code 'nil :value-state :unevaluated :rule
                  (c-lambda))


(make-c-dependent :inputp t :code '(nil) :value-state :unevaluated :rule
                  (c-lambda
                    nil))


(make-c-dependent :inputp t :code '(nil nil) :value-state :unevaluated :rule
                  (c-lambda
                    nil
                    nil))


(make-c-dependent :inputp t :code '(nil (progn)) :value-state :unevaluated
                  :rule
                  (c-lambda
                    nil
                    (progn)))


(make-c-dependent :inputp t :code '(nil :key nil) :value-state :unevaluated
                  :rule
                  (c-lambda
                    nil
                    :key
                    nil))


(make-c-dependent :inputp t :code '('lol-gen::some-name) :value-state
                  :unevaluated :rule
                  (c-lambda
                    'lol-gen::some-name))


Error while parsing arguments to DEFMACRO DEF-C-UNCHANGED-TEST:
  too few elements in
    ()
  to satisfy lambda list
    ((CLASS SLOTNAME) &BODY TEST):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO DEF-C-UNCHANGED-TEST:
  too few elements in
    ()
  to satisfy lambda list
    (CLASS SLOTNAME):
  exactly 2 expected, but got 0


(defmethod c-unchanged-test ((self quote) (slotname (eql 'lol-gen::some-name))))


Error while parsing arguments to DEFMACRO FM-OTHER:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &KEY (STARTING) SKIP-TREE (TEST)):
  at least 1 expected, but got 0


(fm-find-one self 'nil :must-find t :skip-tree nil :global-search t :test
             #'true-that)


Error while parsing arguments to FM-OTHER DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


Error while parsing arguments to FM-OTHER DEFMACRO:
  odd number of elements in keyword/value list: ((PROGN))


Error while parsing arguments to FM-OTHER DEFMACRO:
  unknown keyword: :KEY; expected one of :STARTING, :SKIP-TREE, :TEST


(fm-find-one self (list 'quote lol-gen::some-name) :must-find t :skip-tree nil
             :global-search t :test #'true-that)


Error while parsing arguments to DEFMACRO F-PLUSP:
  too few elements in
    ()
  to satisfy lambda list
    (KEY &REST BODY):
  at least 1 expected, but got 0


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn)))
    (values new-basis
            (if (xor prior-fire-value (plusp new-basis))
                (progn (setf prior-fire-value (plusp new-basis)) :propagate)
                :no-propagate))))


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn nil)))
    (values new-basis
            (if (xor prior-fire-value (plusp new-basis))
                (progn (setf prior-fire-value (plusp new-basis)) :propagate)
                :no-propagate))))


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn (progn))))
    (values new-basis
            (if (xor prior-fire-value (plusp new-basis))
                (progn (setf prior-fire-value (plusp new-basis)) :propagate)
                :no-propagate))))


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn :key nil)))
    (values new-basis
            (if (xor prior-fire-value (plusp new-basis))
                (progn (setf prior-fire-value (plusp new-basis)) :propagate)
                :no-propagate))))


(with-synapse 'lol-gen::some-name
    (prior-fire-value)
  (let ((new-basis (progn)))
    (values new-basis
            (if (xor prior-fire-value (plusp new-basis))
                (progn (setf prior-fire-value (plusp new-basis)) :propagate)
                :no-propagate))))


Error while parsing arguments to DEFMACRO BGO:
  too few elements in
    ()
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO BGO:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO BGO:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO BGO:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO C-INPUT:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST KEYS) &OPTIONAL (VALUE)):
  between 1 and 2 expected, but got 0


(make-cell :inputp t :value-state :unbound :value nil)


(make-cell :inputp t :value-state :valid :value nil)


(make-cell :inputp t :value-state :valid :value (progn))


Error while parsing arguments to DEFMACRO C-INPUT:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ((&REST KEYS) &OPTIONAL (VALUE)):
  between 1 and 2 expected, but got 3


(make-cell :inputp t :value-state :unbound :value nil quote lol-gen::some-name)


Error while parsing arguments to DEFMACRO FM^V:
  too few elements in
    ()
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO FM^V:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO FM^V:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO FM^V:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO WITH-LIKE-FM-PARTS:
  too few elements in
    ()
  to satisfy lambda list
    ((PARTS-VAR (SELF LIKE-CLASS)) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO WITH-LIKE-FM-PARTS:
  too few elements in
    ()
  to satisfy lambda list
    (PARTS-VAR (SELF LIKE-CLASS)):
  exactly 2 expected, but got 0


Error while parsing arguments to DEFMACRO WITH-LIKE-FM-PARTS:
  invalid number of elements in
    LOL-GEN::SOME-NAME
  to satisfy lambda list
    (SELF LIKE-CLASS):
  exactly 2 expected, but got a non-list


Error while parsing arguments to DEFMACRO C?-WITH-STORED:
  too few elements in
    ()
  to satisfy lambda list
    ((VAR KEY STORE &OPTIONAL DEFAULT) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO C?-WITH-STORED:
  too few elements in
    ()
  to satisfy lambda list
    (VAR KEY STORE &OPTIONAL DEFAULT):
  between 3 and 4 expected, but got 0


Error while parsing arguments to DEFMACRO C?-WITH-STORED:
  too few elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (VAR KEY STORE &OPTIONAL DEFAULT):
  between 3 and 4 expected, but got 2


Error while parsing arguments to DEFMACRO DEFOBSERVER:
  too few elements in
    ()
  to satisfy lambda list
    (SLOTNAME &REST ARGS):
  at least 1 expected, but got 0


Error while parsing arguments to DESTRUCTURING-BIND:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL (SELF-ARG) (NEW-VARG) (OLDVARG) (OLDVARGBOUNDP) (CELL-ARG))
     &BODY OUTPUT-BODY):
  at least 1 expected, but got 0


(progn
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (setf (get 'nil :output-defined) t))
 (defmethod slot-value-observe progn
            ((slotname (eql 'nil)) self new-value old-value old-value-boundp c)
   (declare (ignorable self new-value old-value old-value-boundp c))))


(progn
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (setf (get 'nil :output-defined) t))
 (defmethod slot-value-observe progn
            ((slotname (eql 'nil)) progn new-value old-value old-value-boundp
             c)
   (declare (ignorable progn new-value old-value old-value-boundp c))))


Error while parsing arguments to DESTRUCTURING-BIND:
  invalid number of elements in
    :KEY
  to satisfy lambda list
    (&OPTIONAL (SELF-ARG) (NEW-VARG) (OLDVARG) (OLDVARGBOUNDP) (CELL-ARG)):
  between 0 and 5 expected, but got a non-list


Error while parsing arguments to DEFMACRO WITH-NONE-AWAKE:
  too few elements in
    ()
  to satisfy lambda list
    ((&KEY DBG DIAG) &BODY BODY):
  at least 1 expected, but got 0


(call-with-none-awake nil (lambda ()) nil)


(call-with-none-awake nil (lambda () nil) nil)


(call-with-none-awake nil (lambda () (progn)) nil)


(call-with-none-awake nil (lambda () :key nil) nil)


Error while parsing arguments to WITH-NONE-AWAKE DEFMACRO:
  unknown keyword: QUOTE; expected one of :DBG, :DIAG


(make-c-dependent :code 'nil :value-state :unevaluated :lazy t :rule (c-lambda))


(make-c-dependent :code '(nil) :value-state :unevaluated :lazy t :rule
                  (c-lambda
                    nil))


(make-c-dependent :code '(nil nil) :value-state :unevaluated :lazy t :rule
                  (c-lambda
                    nil
                    nil))


(make-c-dependent :code '(nil (progn)) :value-state :unevaluated :lazy t :rule
                  (c-lambda
                    nil
                    (progn)))


(make-c-dependent :code '(nil :key nil) :value-state :unevaluated :lazy t :rule
                  (c-lambda
                    nil
                    :key
                    nil))


(make-c-dependent :code '('lol-gen::some-name) :value-state :unevaluated :lazy
                  t :rule
                  (c-lambda
                    'lol-gen::some-name))


(make-c-dependent :code 'nil :value-state :unevaluated :lazy :until-asked :rule
                  (c-lambda))


(make-c-dependent :code '(nil) :value-state :unevaluated :lazy :until-asked
                  :rule
                  (c-lambda
                    nil))


(make-c-dependent :code '(nil nil) :value-state :unevaluated :lazy :until-asked
                  :rule
                  (c-lambda
                    nil
                    nil))


(make-c-dependent :code '(nil (progn)) :value-state :unevaluated :lazy
                  :until-asked :rule
                  (c-lambda
                    nil
                    (progn)))


(make-c-dependent :code '(nil :key nil) :value-state :unevaluated :lazy
                  :until-asked :rule
                  (c-lambda
                    nil
                    :key
                    nil))


(make-c-dependent :code '('lol-gen::some-name) :value-state :unevaluated :lazy
                  :until-asked :rule
                  (c-lambda
                    'lol-gen::some-name))


Error while parsing arguments to DEFMACRO FM-MAP:
  too few elements in
    ()
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 0


Error while parsing arguments to DEFMACRO FM-MAP:
  too few elements in
    (NIL)
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 1


(mapcar nil (fm-find-all self '(progn)))


Error while parsing arguments to DEFMACRO FM-MAP:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 3


Error while parsing arguments to DEFMACRO FM-MAP:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (FN MD-NAME):
  exactly 2 expected, but got 1


Error while parsing arguments to DEFMACRO ^KIDS:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO ^KIDS:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO ^KIDS:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO ^KIDS:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


Error while parsing arguments to DEFMACRO ^KIDS:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO FM?:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING) (GLOBAL-SEARCH)):
  between 1 and 3 expected, but got 0


(fm-find-one self 'nil :must-find nil :global-search t)


(fm-find-one nil 'nil :must-find nil :global-search t)


(fm-find-one (progn) 'nil :must-find nil :global-search t)


(fm-find-one :key 'nil :must-find nil :global-search nil)


(fm-find-one self (list 'quote lol-gen::some-name) :must-find nil
             :global-search t)


Error while parsing arguments to DEFMACRO C?N-UNTIL:
  too few elements in
    ()
  to satisfy lambda list
    (ARGS &BODY BODY):
  at least 1 expected, but got 0


(make-c-dependent :optimize :when-value-t :code 'nil :inputp t :value-state
                  :unevaluated :rule (c-lambda))


(make-c-dependent :optimize :when-value-t :code '(nil) :inputp t :value-state
                  :unevaluated :rule
                  (c-lambda
                    nil))


(make-c-dependent :optimize :when-value-t :code '((progn)) :inputp t
                  :value-state :unevaluated :rule
                  (c-lambda
                    (progn)))


(make-c-dependent :optimize :when-value-t :code '(:key nil) :inputp t
                  :value-state :unevaluated :rule
                  (c-lambda
                    :key
                    nil))


(make-c-dependent :optimize :when-value-t :code 'nil :inputp t :value-state
                  :unevaluated :rule (c-lambda) quote lol-gen::some-name)


Error while parsing arguments to DEFMACRO FM^:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &KEY (SKIP-TREE) (MUST-FIND)):
  at least 1 expected, but got 0


(without-c-dependency
  (fm-find-one (fm-parent self) nil :skip-tree self :must-find t :global-search
               t))


Error while parsing arguments to FM^ DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


Error while parsing arguments to FM^ DEFMACRO:
  odd number of elements in keyword/value list: ((PROGN))


Error while parsing arguments to FM^ DEFMACRO:
  unknown keyword: :KEY; expected one of :SKIP-TREE, :MUST-FIND


(without-c-dependency
  (fm-find-one (fm-parent self) 'lol-gen::some-name :skip-tree self :must-find
               t :global-search t))


Error while parsing arguments to DEFMACRO TRCX:
  too few elements in
    ()
  to satisfy lambda list
    (TGT-FORM &REST OS):
  at least 1 expected, but got 0


(without-c-dependency
  (call-trc t #A((23) base-char . "TX> 'lol-gen::some-name") :|'SOME-NAME|
            'lol-gen::some-name))


(bwhen (#:g200 self)
  (find-prior #:g200 (kids (fm-parent #:g200))))


(bwhen (#:g201 nil)
  (find-prior #:g201 (kids (fm-parent #:g201))))


Error while parsing arguments to DEFMACRO PSIB:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (&OPTIONAL (SELF-FORM)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO PSIB:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (&OPTIONAL (SELF-FORM)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO PSIB:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (&OPTIONAL (SELF-FORM)):
  between 0 and 1 expected, but got 3


(bwhen (#:g202 'lol-gen::some-name)
  (find-prior #:g202 (kids (fm-parent #:g202))))


Error while parsing arguments to DEFMACRO FM-OTHER?:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING) (GLOBAL-SEARCH)):
  between 1 and 3 expected, but got 0


Error while parsing arguments to DEFMACRO F-DELTA:
  too few elements in
    ()
  to satisfy lambda list
    (SYNAPSE-ID (&KEY SENSITIVITY (TYPE)) &BODY BODY):
  at least 2 expected, but got 0


Error while parsing arguments to DEFMACRO F-DELTA:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SYNAPSE-ID (&KEY SENSITIVITY (TYPE)) &BODY BODY):
  at least 2 expected, but got 1


(call-f-delta nil nil 'number (lambda ()))


Error while parsing arguments to F-DELTA DEFMACRO:
  odd number of elements in keyword/value list: (PROGN)


Error while parsing arguments to F-DELTA DEFMACRO:
  :KEY is not a list


Error while parsing arguments to DEFMACRO F-DELTA:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SYNAPSE-ID (&KEY SENSITIVITY (TYPE)) &BODY BODY):
  at least 2 expected, but got 1


Error while parsing arguments to DEFMACRO BWHEN-C-STORED:
  too few elements in
    ()
  to satisfy lambda list
    ((VAR KEY STORE &OPTIONAL IF-NOT) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO BWHEN-C-STORED:
  too few elements in
    ()
  to satisfy lambda list
    (VAR KEY STORE &OPTIONAL IF-NOT):
  between 3 and 4 expected, but got 0


Error while parsing arguments to DEFMACRO BWHEN-C-STORED:
  too few elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (VAR KEY STORE &OPTIONAL IF-NOT):
  between 3 and 4 expected, but got 2


Error while parsing arguments to DEFMACRO CLL-OUTER:
  too few elements in
    ()
  to satisfy lambda list
    (VAL &BODY BODY):
  at least 1 expected, but got 0


(make-c-dependent :code '(without-c-dependency) :inputp t :value-state
                  :unevaluated :rule
                  (c-lambda
                    (without-c-dependency)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil)
                  :inputp t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     nil)
                  :inputp t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     (progn))
                  :inputp t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      (progn))))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     :key
                     nil)
                  :inputp t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      :key
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     'lol-gen::some-name)
                  :inputp t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      'lol-gen::some-name)))


Error while parsing arguments to DEFMACRO NEAREST:
  too few elements in
    ()
  to satisfy lambda list
    (SELF-FORM TYPE):
  exactly 2 expected, but got 0


Error while parsing arguments to DEFMACRO NEAREST:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SELF-FORM TYPE):
  exactly 2 expected, but got 1


Error while parsing arguments to DEFMACRO NEAREST:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (SELF-FORM TYPE):
  exactly 2 expected, but got 3


Error while parsing arguments to DEFMACRO NEAREST:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SELF-FORM TYPE):
  exactly 2 expected, but got 1


Error while parsing arguments to DEFMACRO EKO-IF:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST TRCARGS) &REST BODY):
  at least 1 expected, but got 0


(let ((#:g209))
  (when #:g209 (trc quote :res #:g209 lol-gen::some-name))
  #:g209)


Error while parsing arguments to DEFMACRO MK-PART:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME (MD-CLASS) &REST INITARGS):
  at least 2 expected, but got 0


Error while parsing arguments to DEFMACRO MK-PART:
  too few elements in
    (NIL)
  to satisfy lambda list
    (MD-NAME (MD-CLASS) &REST INITARGS):
  at least 2 expected, but got 1


Error while parsing arguments to DEFMACRO MK-PART:
  too few elements in
    ()
  to satisfy lambda list
    (MD-CLASS):
  exactly 1 expected, but got 0


(make-part 'nil 'progn :fm-parent
           (progn (assert self nil "mk-part null self for parent") self))


Error while parsing arguments to DEFMACRO MK-PART:
  invalid number of elements in
    :KEY
  to satisfy lambda list
    (MD-CLASS):
  exactly 1 expected, but got a non-list


Error while parsing arguments to DEFMACRO MK-PART:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (MD-NAME (MD-CLASS) &REST INITARGS):
  at least 2 expected, but got 1


Error while parsing arguments to DEFMACRO F-ZEROP:
  too few elements in
    ()
  to satisfy lambda list
    (KEY &REST BODY):
  at least 1 expected, but got 0


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn)))
    (values new-basis
            (if (xor prior-fire-value (zerop new-basis))
                (progn (setf prior-fire-value (zerop new-basis)) :propagate)
                :no-propagate))))


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn nil)))
    (values new-basis
            (if (xor prior-fire-value (zerop new-basis))
                (progn (setf prior-fire-value (zerop new-basis)) :propagate)
                :no-propagate))))


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn (progn))))
    (values new-basis
            (if (xor prior-fire-value (zerop new-basis))
                (progn (setf prior-fire-value (zerop new-basis)) :propagate)
                :no-propagate))))


(with-synapse nil
    (prior-fire-value)
  (let ((new-basis (progn :key nil)))
    (values new-basis
            (if (xor prior-fire-value (zerop new-basis))
                (progn (setf prior-fire-value (zerop new-basis)) :propagate)
                :no-propagate))))


(with-synapse 'lol-gen::some-name
    (prior-fire-value)
  (let ((new-basis (progn)))
    (values new-basis
            (if (xor prior-fire-value (zerop new-basis))
                (progn (setf prior-fire-value (zerop new-basis)) :propagate)
                :no-propagate))))


(make-c-dependent :code '(without-c-dependency) :inputp nil :value-state
                  :unevaluated :rule
                  (c-lambda
                    (without-c-dependency)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil)
                  :inputp nil :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     nil)
                  :inputp nil :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     (progn))
                  :inputp nil :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      (progn))))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     :key
                     nil)
                  :inputp nil :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      :key
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     'lol-gen::some-name)
                  :inputp nil :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      'lol-gen::some-name)))


Error while parsing arguments to DEFMACRO CLL-INNER:
  too few elements in
    ()
  to satisfy lambda list
    (EXPR):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO CLL-INNER:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (EXPR):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO CLL-INNER:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (EXPR):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO CLL-INNER:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (EXPR):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO FM-OTHERV?:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING) (GLOBAL-SEARCH)):
  between 1 and 3 expected, but got 0


Error while parsing arguments to DEFMACRO FM-COLLECT:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &KEY (MUST-FIND)):
  at least 1 expected, but got 0


Error while parsing arguments to FM-COLLECT DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


Error while parsing arguments to FM-COLLECT DEFMACRO:
  odd number of elements in keyword/value list: ((PROGN))


Error while parsing arguments to FM-COLLECT DEFMACRO:
  unknown keyword: :KEY; expected one of :MUST-FIND


(fm-find-all self ''lol-gen::some-name :must-find t)


Error while parsing arguments to DEFMACRO N^:
  too few elements in
    ()
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO N^:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO N^:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO N^:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (TYPE):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO ^K-LAST:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO ^K-LAST:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO ^K-LAST:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO ^K-LAST:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


Error while parsing arguments to DEFMACRO ^K-LAST:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


(c-input (:lazy :once-asked) (progn nil))


(c-input (:lazy :once-asked) (progn nil nil))


(c-input (:lazy :once-asked) (progn nil (progn)))


(c-input (:lazy :once-asked) (progn nil :key nil))


(c-input (:lazy :once-asked) (progn 'lol-gen::some-name))


Error while parsing arguments to DEFMACRO C...:
  too few elements in
    ()
  to satisfy lambda list
    ((VALUE) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO C...:
  too few elements in
    ()
  to satisfy lambda list
    (VALUE):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO C...:
  too many elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (VALUE):
  exactly 1 expected, but got 2


(make-c-dependent :code 'nil :value-state :unevaluated :debug t :rule
                  (c-lambda))


(make-c-dependent :code '(nil) :value-state :unevaluated :debug t :rule
                  (c-lambda
                    nil))


(make-c-dependent :code '(nil nil) :value-state :unevaluated :debug t :rule
                  (c-lambda
                    nil
                    nil))


(make-c-dependent :code '(nil (progn)) :value-state :unevaluated :debug t :rule
                  (c-lambda
                    nil
                    (progn)))


(make-c-dependent :code '(nil :key nil) :value-state :unevaluated :debug t
                  :rule
                  (c-lambda
                    nil
                    :key
                    nil))


(make-c-dependent :code '('lol-gen::some-name) :value-state :unevaluated :debug
                  t :rule
                  (c-lambda
                    'lol-gen::some-name))


(make-c-dependent :code 'nil :value-state :unevaluated :rule (c-lambda))


(make-c-dependent :code '(nil) :value-state :unevaluated :rule
                  (c-lambda
                    nil))


(make-c-dependent :code '(nil nil) :value-state :unevaluated :rule
                  (c-lambda
                    nil
                    nil))


(make-c-dependent :code '(nil (progn)) :value-state :unevaluated :rule
                  (c-lambda
                    nil
                    (progn)))


(make-c-dependent :code '(nil :key nil) :value-state :unevaluated :rule
                  (c-lambda
                    nil
                    :key
                    nil))


(make-c-dependent :code '('lol-gen::some-name) :value-state :unevaluated :rule
                  (c-lambda
                    'lol-gen::some-name))


Error while parsing arguments to DEFMACRO DEFMODEL:
  too few elements in
    ()
  to satisfy lambda list
    (CLASS DIRECTSUPERS SLOTSPECS &REST OPTIONS):
  at least 3 expected, but got 0


Error while parsing arguments to DEFMACRO DEFMODEL:
  too few elements in
    (NIL)
  to satisfy lambda list
    (CLASS DIRECTSUPERS SLOTSPECS &REST OPTIONS):
  at least 3 expected, but got 1


Error while parsing arguments to DEFMACRO DEFMODEL:
  too few elements in
    (NIL NIL)
  to satisfy lambda list
    (CLASS DIRECTSUPERS SLOTSPECS &REST OPTIONS):
  at least 3 expected, but got 2


Error while parsing arguments to DEFMACRO DEFMODEL:
  too few elements in
    (NIL (PROGN))
  to satisfy lambda list
    (CLASS DIRECTSUPERS SLOTSPECS &REST OPTIONS):
  at least 3 expected, but got 2


The value
  :KEY
is not of type
  SEQUENCE


Error while parsing arguments to DEFMACRO DEFMODEL:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (CLASS DIRECTSUPERS SLOTSPECS &REST OPTIONS):
  at least 3 expected, but got 1


Error while parsing arguments to DEFMACRO DEFMD:
  too few elements in
    ()
  to satisfy lambda list
    (CLASS SUPERCLASSES &REST MDSPEC):
  at least 2 expected, but got 0


Error while parsing arguments to DEFMACRO DEFMD:
  too few elements in
    (NIL)
  to satisfy lambda list
    (CLASS SUPERCLASSES &REST MDSPEC):
  at least 2 expected, but got 1


(defmodel nil (model) nil (:default-initargs))


(defmodel nil (progn model) nil (:default-initargs))


The value
  :KEY
is not of type
  LIST
when binding SB-IMPL::X


Error while parsing arguments to DEFMACRO DEFMD:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (CLASS SUPERCLASSES &REST MDSPEC):
  at least 2 expected, but got 1


Error while parsing arguments to DEFMACRO EKX:
  too few elements in
    ()
  to satisfy lambda list
    (EKX-ID &REST BODY):
  at least 1 expected, but got 0


The value
  'LOL-GEN::SOME-NAME
is not of type
  SYMBOL


Error while parsing arguments to DEFMACRO WITH-CC:
  too few elements in
    ()
  to satisfy lambda list
    (ID &BODY BODY):
  at least 1 expected, but got 0


(let ((*parent* self))
  (packed-flat!))


(let ((*parent* self))
  (packed-flat! nil))


(let ((*parent* self))
  (packed-flat! nil nil))


(let ((*parent* self))
  (packed-flat! nil (progn)))


(let ((*parent* self))
  (packed-flat! nil :key nil))


(let ((*parent* self))
  (packed-flat! 'lol-gen::some-name))


(make-c-dependent :code '(without-c-dependency) :inputp t :debug t :value-state
                  :unevaluated :rule
                  (c-lambda
                    (without-c-dependency)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil)
                  :inputp t :debug t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     nil)
                  :inputp t :debug t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     (progn))
                  :inputp t :debug t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      (progn))))


(make-c-dependent :code
                  '(without-c-dependency
                     nil
                     :key
                     nil)
                  :inputp t :debug t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      nil
                      :key
                      nil)))


(make-c-dependent :code
                  '(without-c-dependency
                     'lol-gen::some-name)
                  :inputp t :debug t :value-state :unevaluated :rule
                  (c-lambda
                    (without-c-dependency
                      'lol-gen::some-name)))


Error while parsing arguments to DEFMACRO WNOTRC:
  too few elements in
    ()
  to satisfy lambda list
    ((&OPTIONAL (MIN) (MAX) &REST BANNER) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO DO-LIKE-FM-PARTS:
  too few elements in
    ()
  to satisfy lambda list
    ((PART-VAR (SELF LIKE-CLASS) &OPTIONAL RETURN-VAR) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO DO-LIKE-FM-PARTS:
  too few elements in
    ()
  to satisfy lambda list
    (PART-VAR (SELF LIKE-CLASS) &OPTIONAL RETURN-VAR):
  between 2 and 3 expected, but got 0


Error while parsing arguments to DEFMACRO DO-LIKE-FM-PARTS:
  invalid number of elements in
    LOL-GEN::SOME-NAME
  to satisfy lambda list
    (SELF LIKE-CLASS):
  exactly 2 expected, but got a non-list


Error while parsing arguments to DEFMACRO UPPER:
  too few elements in
    ()
  to satisfy lambda list
    (SELF &OPTIONAL (TYPE)):
  between 1 and 2 expected, but got 0


Error while parsing arguments to DEFMACRO UPPER:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (SELF &OPTIONAL (TYPE)):
  between 1 and 2 expected, but got 3


Error while parsing arguments to DEFMACRO C-FORMULA:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST KEYS &KEY LAZY &ALLOW-OTHER-KEYS) &BODY FORMS):
  at least 1 expected, but got 0


(make-c-dependent :code 'nil :value-state :unevaluated :rule (c-lambda))


(make-c-dependent :code '(nil) :value-state :unevaluated :rule
                  (c-lambda
                    nil))


(make-c-dependent :code '((progn)) :value-state :unevaluated :rule
                  (c-lambda
                    (progn)))


(make-c-dependent :code '(:key nil) :value-state :unevaluated :rule
                  (c-lambda
                    :key
                    nil))


(make-c-dependent :code 'nil :value-state :unevaluated :rule (c-lambda) quote
                  lol-gen::some-name)


Error while parsing arguments to DEFMACRO |^K1|:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO |^K1|:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO |^K1|:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO |^K1|:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


Error while parsing arguments to DEFMACRO |^K1|:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO |^K2|:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


Error while parsing arguments to DEFMACRO |^K2|:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO |^K2|:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


Error while parsing arguments to DEFMACRO |^K2|:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


Error while parsing arguments to DEFMACRO |^K2|:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


(make-c-dependent :code 'nil :value-state :unevaluated :lazy :until-asked :rule
                  (c-lambda) :debug t)


(make-c-dependent :code '(nil) :value-state :unevaluated :lazy :until-asked
                  :rule
                  (c-lambda
                    nil)
                  :debug t)


(make-c-dependent :code '(nil nil) :value-state :unevaluated :lazy :until-asked
                  :rule
                  (c-lambda
                    nil
                    nil)
                  :debug t)


(make-c-dependent :code '(nil (progn)) :value-state :unevaluated :lazy
                  :until-asked :rule
                  (c-lambda
                    nil
                    (progn))
                  :debug t)


(make-c-dependent :code '(nil :key nil) :value-state :unevaluated :lazy
                  :until-asked :rule
                  (c-lambda
                    nil
                    :key
                    nil)
                  :debug t)


(make-c-dependent :code '('lol-gen::some-name) :value-state :unevaluated :lazy
                  :until-asked :rule
                  (c-lambda
                    'lol-gen::some-name)
                  :debug t)


Error while parsing arguments to DEFMACRO RG!:
  too few elements in
    ()
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO RG!:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO RG!:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO RG!:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO TRC:
  too few elements in
    ()
  to satisfy lambda list
    (TGT-FORM &REST OS):
  at least 1 expected, but got 0


(without-c-dependency
  (bif (#:g215 'lol-gen::some-name)
       (if (trcp #:g215)
           (progn
            (assert (stringp nil) nil
                    "trc with test expected string second, got ~a" nil)
            (call-trc t))
           (progn (count-it :trcfailed)))
       (count-it :tgtnileval)))


Error while parsing arguments to DEFMACRO MAKE-KID:
  too few elements in
    ()
  to satisfy lambda list
    (CLASS &REST IA):
  at least 1 expected, but got 0


(let ((#:c216 nil))
  (make-instance #:c216 :fm-parent
                 (progn
                  (assert self nil "make-kid: self nil making ~a" #:c216)
                  self)))


(let ((#:c217 nil))
  (make-instance #:c217 nil :fm-parent
                 (progn
                  (assert self nil "make-kid: self nil making ~a" #:c217)
                  self)))


(let ((#:c218 nil))
  (make-instance #:c218 (progn) :fm-parent
                 (progn
                  (assert self nil "make-kid: self nil making ~a" #:c218)
                  self)))


(let ((#:c219 nil))
  (make-instance #:c219 :key nil :fm-parent
                 (progn
                  (assert self nil "make-kid: self nil making ~a" #:c219)
                  self)))


(let ((#:c220 'lol-gen::some-name))
  (make-instance #:c220 :fm-parent
                 (progn
                  (assert self nil "make-kid: self nil making ~a" #:c220)
                  self)))


Error while parsing arguments to DEFMACRO C-ABS:
  too few elements in
    ()
  to satisfy lambda list
    (VALUE &BODY BODY):
  at least 1 expected, but got 0


(make-c-drifter-absolute :code 'nil :value-state :valid :value nil :rule
                         (c-lambda))


(make-c-drifter-absolute :code '(nil) :value-state :valid :value nil :rule
                         (c-lambda
                           nil))


(make-c-drifter-absolute :code '((progn)) :value-state :valid :value nil :rule
                         (c-lambda
                           (progn)))


(make-c-drifter-absolute :code '(:key nil) :value-state :valid :value nil :rule
                         (c-lambda
                           :key
                           nil))


(make-c-drifter-absolute :code 'nil :value-state :valid :value
                         'lol-gen::some-name :rule (c-lambda))


Error while parsing arguments to DEFMACRO FMV:
  too few elements in
    ()
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO FMV:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO FMV:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO FMV:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (NAME):
  exactly 1 expected, but got 3


Error while parsing arguments to DEFMACRO RG?:
  too few elements in
    ()
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO RG?:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO RG?:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO RG?:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ID):
  exactly 1 expected, but got 3


(fm-find-registered 'lol-gen::some-name self nil)


Error while parsing arguments to DEFMACRO FM-OTHER?!:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING)):
  between 1 and 2 expected, but got 0


(fm-find-one self 'nil :must-find nil :global-search nil)


(fm-find-one nil 'nil :must-find nil :global-search nil)


(fm-find-one (progn) 'nil :must-find nil :global-search nil)


Error while parsing arguments to DEFMACRO FM-OTHER?!:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING)):
  between 1 and 2 expected, but got 3


(fm-find-one self (list 'quote lol-gen::some-name) :must-find nil
             :global-search nil)


Error while parsing arguments to DEFMACRO C-IN:
  too few elements in
    ()
  to satisfy lambda list
    (VALUE):
  exactly 1 expected, but got 0


(make-cell :inputp t :value-state :valid :value nil)


Error while parsing arguments to DEFMACRO C-IN:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (VALUE):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO C-IN:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (VALUE):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO C-IN:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (VALUE):
  exactly 1 expected, but got 3


(make-cell :inputp t :value-state :valid :value 'lol-gen::some-name)


Error while parsing arguments to DEFMACRO FM-OTHERX:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &KEY (STARTING) SKIP-TREE):
  at least 1 expected, but got 0


(or (fm-find-one self 'nil :must-find t :skip-tree nil :global-search t))


Error while parsing arguments to FM-OTHERX DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


Error while parsing arguments to FM-OTHERX DEFMACRO:
  odd number of elements in keyword/value list: ((PROGN))


Error while parsing arguments to FM-OTHERX DEFMACRO:
  unknown keyword: :KEY; expected one of :STARTING, :SKIP-TREE


(or
 (fm-find-one self (list 'quote lol-gen::some-name) :must-find t :skip-tree nil
              :global-search t))


Error while parsing arguments to DEFMACRO MK-KID-SLOT:
  too few elements in
    ()
  to satisfy lambda list
    ((KS-NAME &KEY IF-MISSING) KS-RULE):
  exactly 2 expected, but got 0


Error while parsing arguments to DEFMACRO MK-KID-SLOT:
  too few elements in
    (NIL)
  to satisfy lambda list
    ((KS-NAME &KEY IF-MISSING) KS-RULE):
  exactly 2 expected, but got 1


Error while parsing arguments to DEFMACRO MK-KID-SLOT:
  too few elements in
    ()
  to satisfy lambda list
    (KS-NAME &KEY IF-MISSING):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO MK-KID-SLOT:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ((KS-NAME &KEY IF-MISSING) KS-RULE):
  exactly 2 expected, but got 3


Error while parsing arguments to DEFMACRO MK-KID-SLOT:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ((KS-NAME &KEY IF-MISSING) KS-RULE):
  exactly 2 expected, but got 1


(c-lambda-var (slot-c)
  nil
  :key
  nil)


(c-lambda-var (slot-c)
  'lol-gen::some-name)


Error while parsing arguments to DEFMACRO WITH-STORE-ITEM:
  too few elements in
    ()
  to satisfy lambda list
    ((ITEM KEY STORE) &BODY BODY):
  at least 1 expected, but got 0


Error while parsing arguments to DEFMACRO WITH-STORE-ITEM:
  too few elements in
    ()
  to satisfy lambda list
    (ITEM KEY STORE):
  exactly 3 expected, but got 0


Error while parsing arguments to DEFMACRO WITH-STORE-ITEM:
  too few elements in
    'LOL-GEN::SOME-NAME
  to satisfy lambda list
    (ITEM KEY STORE):
  exactly 3 expected, but got 2


Error while parsing arguments to DEFMACRO WITH-SYNAPSE:
  too few elements in
    ()
  to satisfy lambda list
    (SYNAPSE-ID (&REST CLOSURE-VARS) &BODY BODY):
  at least 2 expected, but got 0


Error while parsing arguments to DEFMACRO WITH-SYNAPSE:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SYNAPSE-ID (&REST CLOSURE-VARS) &BODY BODY):
  at least 2 expected, but got 1


(let* ((#:g221 nil)
       (synapse
        (or (find #:g221 (cd-useds *depender*) :key 'c-slot-name)
            (let ((new-syn
                   (let ()
                     (make-c-dependent :model (c-model *depender*) :slot-name
                                       #:g221 :code 'nil :synaptic t :rule
                                       (c-lambda)))))
              (record-caller new-syn)
              new-syn))))
  (prog1
      (multiple-value-bind (v p)
          (with-integrity nil
                          (ensure-value-is-current synapse :synapse
                                                   *depender*))
        (values v p))
    (record-caller synapse)))


(let* ((#:g222 nil)
       (synapse
        (or (find #:g222 (cd-useds *depender*) :key 'c-slot-name)
            (let ((new-syn
                   (let (progn)
                     (make-c-dependent :model (c-model *depender*) :slot-name
                                       #:g222 :code 'nil :synaptic t :rule
                                       (c-lambda)))))
              (record-caller new-syn)
              new-syn))))
  (prog1
      (multiple-value-bind (v p)
          (with-integrity nil
                          (ensure-value-is-current synapse :synapse
                                                   *depender*))
        (values v p))
    (record-caller synapse)))


(let* ((#:g223 nil)
       (synapse
        (or (find #:g223 (cd-useds *depender*) :key 'c-slot-name)
            (let ((new-syn
                   (let :key
                     (make-c-dependent :model (c-model *depender*) :slot-name
                                       #:g223 :code '(nil) :synaptic t :rule
                                       (c-lambda
                                         nil)))))
              (record-caller new-syn)
              new-syn))))
  (prog1
      (multiple-value-bind (v p)
          (with-integrity nil
                          (ensure-value-is-current synapse :synapse
                                                   *depender*))
        (values v p))
    (record-caller synapse)))


Error while parsing arguments to DEFMACRO WITH-SYNAPSE:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SYNAPSE-ID (&REST CLOSURE-VARS) &BODY BODY):
  at least 2 expected, but got 1


(bwhen (#:g224 self)
  (cadr (member #:g224 (kids (fm-parent #:g224)))))


(bwhen (#:g225 nil)
  (cadr (member #:g225 (kids (fm-parent #:g225)))))


Error while parsing arguments to DEFMACRO NSIB:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (&OPTIONAL (SELF-FORM)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO NSIB:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (&OPTIONAL (SELF-FORM)):
  between 0 and 1 expected, but got 2


Error while parsing arguments to DEFMACRO NSIB:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (&OPTIONAL (SELF-FORM)):
  between 0 and 1 expected, but got 3


(bwhen (#:g226 'lol-gen::some-name)
  (cadr (member #:g226 (kids (fm-parent #:g226)))))


(without-c-dependency
  nil
  :key
  nil)


(without-c-dependency
  'lol-gen::some-name)

(let (*depender*)
  'lol-gen::some-name)


Error while parsing arguments to DEFMACRO F-SENSITIVITY:
  too few elements in
    ()
  to satisfy lambda list
    (SYNAPSE-ID (SENSITIVITY &OPTIONAL SUBTYPENAME) &BODY BODY):
  at least 2 expected, but got 0


Error while parsing arguments to DEFMACRO F-SENSITIVITY:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SYNAPSE-ID (SENSITIVITY &OPTIONAL SUBTYPENAME) &BODY BODY):
  at least 2 expected, but got 1


Error while parsing arguments to DEFMACRO F-SENSITIVITY:
  too few elements in
    ()
  to satisfy lambda list
    (SENSITIVITY &OPTIONAL SUBTYPENAME):
  between 1 and 2 expected, but got 0


(call-f-sensitivity nil progn nil (lambda ()))


Error while parsing arguments to DEFMACRO F-SENSITIVITY:
  invalid number of elements in
    :KEY
  to satisfy lambda list
    (SENSITIVITY &OPTIONAL SUBTYPENAME):
  between 1 and 2 expected, but got a non-list


Error while parsing arguments to DEFMACRO F-SENSITIVITY:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SYNAPSE-ID (SENSITIVITY &OPTIONAL SUBTYPENAME) &BODY BODY):
  at least 2 expected, but got 1


(make-c-envaluer :envalue-rule
                 (c-lambda
                   nil))


(make-c-envaluer :envalue-rule
                 (c-lambda
                   nil
                   nil))


(make-c-envaluer :envalue-rule
                 (c-lambda
                   nil
                   (progn)))


(make-c-envaluer :envalue-rule
                 (c-lambda
                   nil
                   :key
                   nil))


(make-c-envaluer :envalue-rule
                 (c-lambda
                   'lol-gen::some-name))


Error while parsing arguments to DEFMACRO FM!:
  too few elements in
    ()
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING)):
  between 1 and 2 expected, but got 0


(without-c-dependency
  (fm-find-one self 'nil :must-find t :global-search nil))


(without-c-dependency
  (fm-find-one nil 'nil :must-find t :global-search nil))


(without-c-dependency
  (fm-find-one (progn) 'nil :must-find t :global-search nil))


Error while parsing arguments to DEFMACRO FM!:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (MD-NAME &OPTIONAL (STARTING)):
  between 1 and 2 expected, but got 3


(without-c-dependency
  (fm-find-one self (list 'quote lol-gen::some-name) :must-find t
               :global-search nil))


Error while parsing arguments to DEFMACRO BRKX:
  too few elements in
    ()
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 0


Error while parsing arguments to DEFMACRO BRKX:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO BRKX:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 2


Error while parsing arguments to DEFMACRO BRKX:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (MSG):
  exactly 1 expected, but got 3


(break "At ~a: OK?" ''lol-gen::some-name)