(equal (times x (add1 y))

 		   (if (numberp y)

 		       (plus x (times x y))

 	    (equal (nth (nil)

 			i)

 		   (if (zerop i)

 			  (t (puzzle-remove i j))))))))))

 (defun definepiece (iclass ii jj kk)

   (let ((index 0))

     (declare (fixnum index))

     (do ((i 0 (1+ i)))

   (cond ((not (< y x)) z)

 	(t (tak77 (tak49 (the fixnum (1- x)) y z)

 		  (tak47 (the fixnum (1- y)) z x)

 (defun tak77 (x y z) 

   (declare (fixnum x y z))

   (cond ((not (< y x)) z)

 		 (tak0 (the fixnum (1- y)) z x)

 		 (tak0 (the fixnum (1- z)) x y)))))

   (time (tak0 18 12 6)))

 |#

     count))

 (defun init-traverse()

 (defun run-traverse ()

   (do ((i 50. (the fixnum (1- i))))

   (preference <q> ^role operator ^value reject

 	^goal <g4> ^problem-space <p> ^state <s>))

     (and (eq ce 1.) (go ph2))

     (setq x (cdr x))

     (and (eq ce 2.) (go ph2))

     (and (eq ce 3.) (go ph2))

     (setq x (cdr x))

     (and (eq ce 4.) (go ph2))

   (prog nil

     top  (and (not nl) (return nil))

     (setq *sendtocall* nil)

     (apply (caar nl) (cdar nl))		;; %%% here's the apply cdar nl must 

     					;; be the *cN* item, caar nl is test

     (setq nl (cdr nl))

     (setq v (car vlist))

     (setq ind (cadr vlist))

     (setq vlist (cddr vlist))

     (setq *ce-variable-memory*

 	  (cons (cons v r) *ce-variable-memory*))

     (go top))) 

 )

 (defun soarclearprops (sym)

 )

 (defun soarmachinetype ()

   (use-result-array))

 (defun remove-condition-trash (condition)

         (setq return-condition nil)

         (setq pand-flag nil)

         (setq disjunction-flag nil)

         (setq out (p-conds-to-sp (sppwm1 (append '(^ identifier) (list object)))))

         (setq out1 nil)

         (soarmapc

              (cond ((eq prefflag (eq (car x) 'preference))

                     (ppline x)

                     (soarpush x out1)

         (cond ((atom x) (soarwarn "Atomic Action" x) (return nil)))

         (setq a (setq *action-type* (car x)))

         (cond ((eq a 'bind) (check-bind x))

               ((eq a 'call2) (return nil))

               ((eq a 'tabstop) (check-bind x))

               ((eq a 'decide) (check-decide))

         (return array)))

 (defun process-decide (phase-set)

   (setq *new-chunks* nil)

   (soarmapcar #'classify-decide phase-set)

   (process-context-stack *context-stack*))

   window, up one screenfull.  If P is supplied then scroll that

   many lines."

   (if p

       (let ((height (- (window-height window)))

 	    (overlap (- (value scroll-overlap))))

 	(scroll-window window (if (>= height overlap) 

       ;; If we we didn't wrap then display some losers...

       (if xpos

 	  (display-losing-chars open-chars index left-open-pos dest xpos

 				(and done-p (= index left-open-pos)))

 	  (update-and-punt dis-line width nil 0 index)))

      (t

 (defsetf nn-last-read-message-number %set-nn-last-read-message-number)

 ;;; This macro binds a variable to each successive line of input from NNTP

 ;;; and exits when it sees the NNTP end-of-file-marker, a period by itself on

      (t

       (setf (ring-first ring) new)))

     (shiftf (aref vec first) nil)))

 ;;; ring-length  --  Public

 ;;;

 ;;;    Do modulo arithmetic to find the correct element.

 ;;;

 (defun ring-ref (ring index)

   "Return the index'th element of a ring.  This can be set with Setf."

   (let ((first (ring-first ring)))

     (declare (fixnum first))

 ;;;

 ;;;    This macro is used to define a new kind of search pattern.  Kind

 ;;; is the kind of search pattern to define.  Lambda-list is the argument 

 ;;; The arguments passed are the direction, the pattern, and either

 ;;; an old search-pattern of the same type or nil.  Documentation

 ;;; is put on the search-pattern-documentation property of the kind

 ;;; Create-Character-Set  --  Internal

 ;;;

 ;;; for no character.

 ;;;

 (defun create-character-set ()

        TOP

 	(cond ((null line)

 	       (go DONE))

 	       (go STEP)))

 	;;

 	;; We found a suspect line.