Initializing population, size=5000...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 0
Best individual:
(INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE
                    QGATE.COMPOSE
                    INTEGER.FROMBOOLEAN
                    ((CODE.LIST) CODE.DO QGATE.END CODE.QUOTE FLOAT.YANK
                     ((QGATE.SRN) BOOLEAN.OR))
                    (INTEGER.> QGATE.YANKDUP)
                    FLOAT.%
                    (CODE.CAR))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 22

Average total errors in population: 2.9282e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 23.386
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 1
Best individual:
(((QGATE.LIMITED-ORACLE (INTEGER.FROMFLOAT CODE.STACKDEPTH))
  (QGATE.POP
   ((INTEGER.% (BOOLEAN.POP) (FLOAT.YANKDUP FLOAT.STACKDEPTH) QGATE.U-THETA)
    FLOAT./ QGATE.GATE CODE.NULL BOOLEAN.NOT
    (CODE.= (((BOOLEAN.DUP) BOOLEAN.STACKDEPTH) FLOAT./ BOOLEAN.FROMINTEGER)))
   ((QGATE.END CODE.DISCREPANCY) (FLOAT.FROMBOOLEAN QGATE.STACKDEPTH)
    BOOLEAN.OR ((CODE.CDR) NUMQUBITS))
   QGATE.SWAP
   QGATE.LIMITED-ORACLE
   (FLOAT.-))
  CODE.NULL)
 BOOLEAN.DUP)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 49

Average total errors in population: 2.732e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 19.957
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 2
Best individual:
(((FLOAT./ ((INTEGER.SHOVE) QGATE.YANKDUP)) BOOLEAN.POP CODE.=) CODE.APPEND
 INTEGER.DUP (QGATE.U2) QGATE.STACKDEPTH
 (FLOAT.% (INTEGER.DUP)
          (NUMQUBITS (INTEGER./ (INTEGER.YANK) (QGATE.SHOVE QGATE.SHOVE))
                     ((INTEGER.YANK) FLOAT.* (FLOAT.* NUMQUBITS) CODE.CDR
                      (CODE.DO*COUNT) BOOLEAN.=)
                     CODE.POP
                     BOOLEAN.AND)
          (CODE.QUOTE BOOLEAN.FROMINTEGER)
          (FLOAT.SHOVE)
          QGATE.LIMITED-ORACLE))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 47

Average total errors in population: 2.2550008e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 23.8972
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 3
Best individual:
(((FLOAT.TAN ((0.5542482137680054d0) QGATE.YANKDUP)) CODE.NTH CODE.=)
 CODE.APPEND INTEGER.DUP (QGATE.U2) QGATE.STACKDEPTH
 (FLOAT.% (INTEGER.DUP)
          (FLOAT.STACKDEPTH BOOLEAN.NOT
                            ((QGATE.GATE ((BOOLEAN.SHOVE) QGATE.SHOVE)
                                         QGATE.YANK)
                             BOOLEAN.NOT)
                            (CODE.DO* QGATE.LIMITED-ORACLE
                                      CODE.STACKDEPTH
                                      (CODE.DO*COUNT CODE.FROMFLOAT))
                            INTEGER.FROMBOOLEAN
                            CODE.DO
                            ((INTEGER.<
                              (QGATE.YANK BOOLEAN.FROMFLOAT
                                          (QGATE.CNOT CODE.SHOVE)
                                          (FLOAT.YANKDUP))
                              (CODE.FROMINTEGER)
                              QGATE.SWAP)
                             (QGATE.DUP (INTEGER.*))
                             (CODE.CAR
                              (INTEGER.- (CODE.SWAP)
                                         CODE.FROMINTEGER
                                         (QGATE.SRN)))
                             CODE.=))
          (CODE.QUOTE BOOLEAN.FROMINTEGER)
          (FLOAT.SHOVE)
          QGATE.LIMITED-ORACLE))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 74

Average total errors in population: 1.6706021e+7
Median total errors in population: 2.0e+7
Average program size in population (points): 29.818
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 4
Best individual:
((CODE.ATOM) (CODE.DO* 6 (QGATE.SHOVE INTEGER.STACKDEPTH)) CODE.ATOM CODE.=
 ((CODE.POP)
  ((CODE.SWAP
    ((CODE.ATOM BOOLEAN.DUP CODE.YANK BOOLEAN.DUP) QGATE.=
     (CODE.DO*TIMES (NUMQUBITS)) CODE.SHOVE
     (CODE.NTHCDR (FLOAT.* INTEGER.YANK BOOLEAN.DUP)) CODE.CDR))
   (FLOAT.YANKDUP ((CODE.CAR) CODE.STACKDEPTH FLOAT.DUP NUMQUBITS))
   FLOAT.FROMBOOLEAN QGATE.LIMITED-ORACLE)
  FLOAT.POP (INTEGER.YANK QGATE.MEASURE) INTEGER.STACKDEPTH
  ((FLOAT.POP) FLOAT.+ QGATE.CNOT) (QGATE.COMPOSE))
 (BOOLEAN.POP (FLOAT.FROMINTEGER) ((QGATE.=) BOOLEAN.OR)) (INTEGER.STACKDEPTH))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 68

Average total errors in population: 1.3202032e+7
Median total errors in population: 1.0000002999999999d+7
Average program size in population (points): 32.714
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 5
Best individual:
(((FLOAT.TAN ((0.5542482137680054d0) QGATE.YANKDUP)) CODE.NTH CODE.=)
 CODE.APPEND INTEGER.DUP (QGATE.U2) QGATE.STACKDEPTH
 (FLOAT.% (INTEGER.DUP)
          (FLOAT.STACKDEPTH BOOLEAN.NOT
                            ((QGATE.GATE ((BOOLEAN.SHOVE) QGATE.SHOVE)
                                         QGATE.YANK)
                             BOOLEAN.NOT)
                            (QGATE.U-THETA QGATE.LIMITED-ORACLE
                                           INTEGER.STACKDEPTH
                                           (CODE.DO*COUNT CODE.FROMFLOAT))
                            INTEGER.FROMBOOLEAN
                            CODE.DO
                            ((INTEGER.<
                              (QGATE.YANK BOOLEAN.FROMFLOAT
                                          (QGATE.CNOT CODE.SHOVE)
                                          (FLOAT.YANKDUP))
                              (CODE.FROMINTEGER)
                              QGATE.SWAP)
                             (QGATE.DUP (INTEGER.*))
                             (CODE.CAR
                              (INTEGER.- (CODE.SWAP)
                                         CODE.FROMINTEGER
                                         (QGATE.SRN)))
                             CODE.=))
          (CODE.QUOTE BOOLEAN.FROMINTEGER)
          (FLOAT.SHOVE)
          QGATE.LIMITED-ORACLE))
Errors for best individual: #(0 2.7230038807421666d0 59.0d0)
Total errors for best individual: 61.72300388074217d0
Size of best individual (points): 74

Average total errors in population: 1.2458035e+7
Median total errors in population: 62.0d0
Average program size in population (points): 34.2768
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 6
Best individual:
(((FLOAT.TAN ((0.5542482137680054d0) QGATE.YANKDUP)) CODE.NTH CODE.=)
 CODE.APPEND INTEGER.DUP (QGATE.U2) QGATE.STACKDEPTH
 (FLOAT.% (INTEGER.DUP)
          ((FLOAT.STACKDEPTH BOOLEAN.NOT
                             ((QGATE.GATE ((BOOLEAN.SHOVE) QGATE.SHOVE)
                                          QGATE.YANK)
                              BOOLEAN.NOT)
                             (QGATE.U-THETA QGATE.LIMITED-ORACLE
                                            INTEGER.STACKDEPTH
                                            (CODE.DO*COUNT CODE.FROMFLOAT))
                             INTEGER.FROMBOOLEAN
                             CODE.DO
                             ((INTEGER.<
                               (QGATE.YANK BOOLEAN.FROMFLOAT
                                           (QGATE.CNOT CODE.SHOVE)
                                           (FLOAT.YANKDUP))
                               (CODE.FROMINTEGER)
                               QGATE.SWAP)
                              (QGATE.DUP (INTEGER.*))
                              (CODE.CAR
                               (INTEGER.- (CODE.SWAP)
                                          CODE.FROMINTEGER
                                          (QGATE.SRN)))
                              CODE.=))
           ((((QGATE.COMPOSE (BOOLEAN.STACKDEPTH QGATE.SWP) (QGATE.SWAP))
              CODE.QUOTE (QGATE.U-THETA) QGATE.DUP)
             CODE.SWAP FLOAT.*)
            (BOOLEAN.FROMINTEGER) INTEGER.STACKDEPTH))
          (CODE.QUOTE BOOLEAN.FROMINTEGER)
          (FLOAT.SHOVE)
          QGATE.LIMITED-ORACLE))
Errors for best individual: #(0 2.7230038807421666d0 59.0d0)
Total errors for best individual: 61.72300388074217d0
Size of best individual (points): 94

Average total errors in population: 1.2672035e+7
Median total errors in population: 62.0d0
Average program size in population (points): 36.1338
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 7
Best individual:
((QGATE.YANK (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)
             QGATE.SWAP
             (QGATE.U-THETA)
             (((CODE.NTHCDR
                ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) FLOAT.TAN)
                QGATE.POP
                CODE.STACKDEPTH
                (CODE.DO*TIMES FLOAT.>))
               INTEGER.SWAP)
              (INTEGER.FROMFLOAT QGATE.LIMITED-ORACLE) (FLOAT.FROMBOOLEAN)
              (BOOLEAN.DUP FLOAT.STACKDEPTH) QGATE.TRANSPOSE)
             CODE.LIST
             (QGATE.TRANSPOSE QGATE.DUP)
             (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH ((QGATE.LIMITED-ORACLE) FLOAT.DUP))
Errors for best individual: #(1.1102230246251565d-16 2.7077098109826023d0
                              59.0d0)
Total errors for best individual: 61.7077098109826d0
Size of best individual (points): 47

Average total errors in population: 1.2202036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 37.6072
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 8
Best individual:
((QGATE.YANK (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)
             QGATE.SWAP
             (QGATE.U-THETA)
             (((CODE.NTHCDR
                ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) FLOAT.TAN)
                QGATE.POP
                CODE.STACKDEPTH
                (CODE.DO*TIMES FLOAT.>))
               INTEGER.SWAP)
              (INTEGER.FROMFLOAT QGATE.LIMITED-ORACLE) (FLOAT.FROMBOOLEAN)
              (((QGATE.LIMITED-ORACLE FLOAT.+ (CODE.YANKDUP)) BOOLEAN.DUP)
               FLOAT.STACKDEPTH)
              QGATE.TRANSPOSE)
             CODE.LIST
             (QGATE.TRANSPOSE QGATE.DUP)
             (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH ((QGATE.LIMITED-ORACLE) FLOAT.DUP))
Errors for best individual: #(1.1102230246251565d-16 2.7077098109826023d0
                              59.0d0)
Total errors for best individual: 61.7077098109826d0
Size of best individual (points): 53

Average total errors in population: 1.1946036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 39.8396
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 9
Best individual:
((QGATE.YANK (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)
             QGATE.SWAP
             (QGATE.U-THETA)
             (((CODE.NTHCDR
                ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) FLOAT.TAN)
                QGATE.POP
                CODE.STACKDEPTH
                (CODE.DO*TIMES FLOAT.>))
               INTEGER.SWAP)
              (INTEGER.FROMFLOAT QGATE.LIMITED-ORACLE) (FLOAT.FROMBOOLEAN)
              (((QGATE.LIMITED-ORACLE FLOAT.+ (CODE.YANKDUP)) BOOLEAN.DUP)
               FLOAT.STACKDEPTH))
             CODE.LIST
             (QGATE.TRANSPOSE QGATE.DUP)
             (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH ((QGATE.LIMITED-ORACLE) FLOAT.DUP))
Errors for best individual: #(1.1102230246251565d-16 2.7077098109826023d0
                              59.0d0)
Total errors for best individual: 61.7077098109826d0
Size of best individual (points): 52

Average total errors in population: 1.1608037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 42.5768
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 10
Best individual:
((((CODE.SWAP
    (BOOLEAN.SWAP CODE.NOOP
                  (NUMQUBITS QGATE.U-THETA (BOOLEAN.YANK) CODE.CONS)
                  INTEGER.DUP
                  (FLOAT.> 0.9234349727630615d0)))
   BOOLEAN.NOT (INTEGER.* BOOLEAN.FROMINTEGER))
  (BOOLEAN.STACKDEPTH))
 NUMQUBITS
 ((CODE.DO*TIMES QGATE.GATE CODE.NTH)
  ((NUMQUBITS (NUMQUBITS) QGATE.SWAP NUMQUBITS)
   (((CODE.NULL QGATE.LIMITED-ORACLE QGATE.=) (BOOLEAN.FROMFLOAT) INTEGER./)
    FLOAT.-
    ((CODE.=
      (QGATE.LIMITED-ORACLE CODE.NOOP
                            CODE.APPEND
                            ((QGATE.U-THETA CODE.NTH) BOOLEAN.NOT INTEGER.POP
                             (QGATE.END) CODE.YANKDUP)
                            (CODE.DUP INTEGER.FROMBOOLEAN)
                            FLOAT.=))
     QGATE.POP)
    (FLOAT.STACKDEPTH))
   CODE.DISCREPANCY))
 FLOAT.STACKDEPTH CODE.YANK)
Errors for best individual: #(1.1102230246251565d-16 2.63629002898847d0 59.0d0)
Total errors for best individual: 61.63629002898847d0
Size of best individual (points): 73

Average total errors in population: 1.1756037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 45.2756
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 11
Best individual:
(((QGATE.HADAMARD INTEGER.POP FLOAT.YANKDUP)
  (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN) QGATE.SWAP (QGATE.U-THETA)
  (((CODE.NTHCDR ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) CODE.DISCREPANCY)
                 QGATE.POP
                 CODE.STACKDEPTH
                 (CODE.DO*TIMES FLOAT.>))
    INTEGER.SWAP)
   (INTEGER.FROMFLOAT QGATE.LIMITED-ORACLE) (FLOAT.FROMBOOLEAN)
   (BOOLEAN.DUP FLOAT.STACKDEPTH) QGATE.TRANSPOSE)
  CODE.LIST (QGATE.TRANSPOSE QGATE.DUP) (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH
 (((QGATE.LIMITED-ORACLE)
   (((QGATE.QNOT FLOAT.+ CODE.FROMFLOAT) CODE.CONS) CODE.STACKDEPTH
    ((FLOAT.YANKDUP TRUE) INTEGER.< BOOLEAN.SWAP) (QGATE.YANK)))
  FLOAT.DUP))
Errors for best individual: #(0 2.553597072269958d0 59.0d0)
Total errors for best individual: 61.55359707226996d0
Size of best individual (points): 67

Average total errors in population: 1.1214038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 50.272
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 12
Best individual:
((QGATE.YANK (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)
             QGATE.SWAP
             (QGATE.U-THETA)
             (((CODE.NTHCDR
                ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) FLOAT.TAN)
                QGATE.POP
                (CODE.STACKDEPTH
                 ((FLOAT.= CODE.DO) QGATE.SRN (CODE.CONS INTEGER.>)
                  (QGATE.LIMITED-ORACLE QGATE.CNOT) (CODE.STACKDEPTH)))
                (CODE.DO*TIMES FLOAT.>))
               INTEGER.SWAP)
              (INTEGER.FROMFLOAT QGATE.LIMITED-ORACLE) (FLOAT.FROMBOOLEAN)
              (BOOLEAN.DUP FLOAT.STACKDEPTH) QGATE.TRANSPOSE)
             CODE.LIST
             (QGATE.TRANSPOSE QGATE.GATE)
             (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH ((QGATE.LIMITED-ORACLE) FLOAT.DUP))
Errors for best individual: #(1.954814945248693d0 0.3538549054913015d0
                              58.8538549054913d0)
Total errors for best individual: 61.1625247562313d0
Size of best individual (points): 61

Average total errors in population: 1.0804038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 54.7608
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 13
Best individual:
((QGATE.YANK (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)
             QGATE.SWAP
             (QGATE.U-THETA)
             (((CODE.NTHCDR
                ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) FLOAT.TAN)
                QGATE.POP
                (CODE.STACKDEPTH
                 ((FLOAT.= CODE.DO) QGATE.SRN (CODE.CONS INTEGER.>)
                  (QGATE.LIMITED-ORACLE QGATE.CNOT) (CODE.STACKDEPTH)))
                (CODE.DO*TIMES FLOAT.>))
               INTEGER.SWAP)
              (FLOAT.FROMBOOLEAN) (BOOLEAN.DUP FLOAT.STACKDEPTH)
              QGATE.TRANSPOSE)
             CODE.LIST
             (QGATE.TRANSPOSE QGATE.GATE)
             (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH ((QGATE.LIMITED-ORACLE) FLOAT.DUP))
Errors for best individual: #(1.954814945248693d0 0.3538549054913015d0
                              58.8538549054913d0)
Total errors for best individual: 61.1625247562313d0
Size of best individual (points): 58

Average total errors in population: 1.0668038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 55.1878
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 14
Best individual:
((QGATE.YANK (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)
             QGATE.SWAP
             (QGATE.U-THETA)
             (((CODE.NTHCDR
                ((QGATE.SWP 0.9956237077713013d0 QGATE.GATE) FLOAT.TAN)
                QGATE.POP
                (CODE.STACKDEPTH
                 ((FLOAT.= CODE.DO) QGATE.SRN (CODE.DUP INTEGER.>)
                  (QGATE.LIMITED-ORACLE QGATE.CNOT) (CODE.STACKDEPTH)))
                (CODE.DO*TIMES FLOAT.>))
               INTEGER.SWAP)
              (FLOAT.FROMBOOLEAN) (BOOLEAN.DUP FLOAT.STACKDEPTH)
              QGATE.TRANSPOSE)
             CODE.LIST
             (QGATE.TRANSPOSE QGATE.GATE)
             (NUMQUBITS BOOLEAN.OR))
 QGATE.STACKDEPTH ((QGATE.LIMITED-ORACLE) FLOAT.DUP))
Errors for best individual: #(1.954814945248693d0 0.3538549054913015d0
                              58.8538549054913d0)
Total errors for best individual: 61.1625247562313d0
Size of best individual (points): 58

Average total errors in population: 1.0776038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 51.4798
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 15
Best individual:
((-0.9231091737747192d0) (BOOLEAN.= INTEGER.YANK INTEGER.DUP QGATE.DUP)
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.STACKDEPTH QGATE.U2)
 ((CODE.SHOVE)
  (QGATE.U-THETA (INTEGER./)
                 QGATE.SHOVE
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (FLOAT.SWAP)
                 CODE.IF)))
Errors for best individual: #(0 9.76500286732469d0 10.519883760319876d0)
Total errors for best individual: 20.284886627644568d0
Size of best individual (points): 40

Average total errors in population: 1.0976037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 51.0416
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 16
Best individual:
((CODE.NOOP) BOOLEAN.OR (0.9249249696731567d0 (CODE.DO*TIMES CODE.DISCREPANCY))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.FROMBOOLEAN CODE.NULL)
 (QGATE.U-THETA
  ((BOOLEAN.=) ((NUMQUBITS FLOAT.STACKDEPTH) INTEGER./ CODE.DISCREPANCY))
  QGATE.STACKDEPTH
  ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER))
   (NUMQUBITS
    ((FLOAT.+
      (FLOAT.>
       (QGATE.SWAP INTEGER.FROMBOOLEAN
                   QGATE.STACKDEPTH
                   (BOOLEAN.SWAP FLOAT.FROMBOOLEAN (QGATE.U2))
                   QGATE.HADAMARD)))
     (FLOAT.FROMBOOLEAN) INTEGER.<))
   QGATE.LIMITED-ORACLE)
  (INTEGER.STACKDEPTH)
  CODE.IF))
Errors for best individual: #(2.708073418273571d0 0.45155470244589746d0
                              38.89424171289609d0)
Total errors for best individual: 42.05386983361556d0
Size of best individual (points): 64

Average total errors in population: 1.0808037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 53.0272
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 17
Best individual:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN (CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(2.5d0 2.7080734182735715d0 8.531055063705178d0)
Total errors for best individual: 13.73912848197875d0
Size of best individual (points): 80

Average total errors in population: 1.0962037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 53.249
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 18
Best individual:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN (CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(2.5d0 2.7080734182735715d0 8.531055063705178d0)
Total errors for best individual: 13.73912848197875d0
Size of best individual (points): 80

Average total errors in population: 1.0980037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 53.4454
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 19
Best individual:
(((INTEGER.YANKDUP NUMQUBITS)
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(2.5d0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 5.909647656003414d0
Size of best individual (points): 84

Average total errors in population: 1.1332036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 54.2968
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 20
Best individual:
(((INTEGER.YANKDUP NUMQUBITS)
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(2.5d0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 5.909647656003414d0
Size of best individual (points): 84

Average total errors in population: 1.1298036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 56.4576
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 21
Best individual:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE)
    ((QGATE.LIMITED-ORACLE CODE.NTHCDR
                           (INTEGER.= CODE.DISCREPANCY CODE.FROMFLOAT)
                           INTEGER.YANK)
     (INTEGER.>) (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) INTEGER.STACKDEPTH)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS
 ((((QGATE.STACKDEPTH
     (CODE.POP FLOAT.-
               CODE.LIST
               BOOLEAN.SWAP
               ((FLOAT.=) BOOLEAN.NOT)
               (CODE.STACKDEPTH))))
   (BOOLEAN.NOT) CODE.CDR)
  CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 95

Average total errors in population: 1.1712034e+7
Median total errors in population: 63.570026680763085d0
Average program size in population (points): 56.0438
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 22
Best individual:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE)
    ((QGATE.LIMITED-ORACLE CODE.NTHCDR
                           (INTEGER.= CODE.DISCREPANCY CODE.FROMFLOAT)
                           INTEGER.YANK)
     (INTEGER.>) (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) INTEGER.STACKDEPTH)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS
 ((((QGATE.STACKDEPTH
     (CODE.POP FLOAT.-
               CODE.LIST
               BOOLEAN.SWAP
               ((FLOAT.=) BOOLEAN.NOT)
               (CODE.STACKDEPTH))))
   (BOOLEAN.NOT) CODE.CDR)
  CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 95

Average total errors in population: 1.1380031e+7
Median total errors in population: 64.70807341827357d0
Average program size in population (points): 58.0316
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 23
Best individual:
((-0.9231091737747192d0) (BOOLEAN.= INTEGER.YANK INTEGER.DUP QGATE.DUP)
 (FLOAT.>
  (QGATE.SWAP INTEGER.FROMBOOLEAN
              QGATE.STACKDEPTH
              (BOOLEAN.SWAP FLOAT.FROMBOOLEAN (QGATE.U2))
              QGATE.HADAMARD))
 (QGATE.U-THETA (BOOLEAN.=)
                QGATE.STACKDEPTH
                (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER))
                  ((INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE QGATE.COMPOSE)
                   ((CODE.DO) QGATE.GATE) CODE.YANKDUP
                   (((QGATE.U-THETA
                      (FLOAT.STACKDEPTH QGATE.GATE
                                        (CODE.STACKDEPTH CODE.=
                                                         ((BOOLEAN.NOT
                                                           (INTEGER.-))
                                                          CODE.CDR)
                                                         (CODE.IF)
                                                         FLOAT.SHOVE)
                                        (BOOLEAN.FROMINTEGER)
                                        ((CODE.DO*) (BOOLEAN.YANKDUP))))
                     (BOOLEAN.=) FLOAT.STACKDEPTH
                     ((QGATE.GATE QGATE.CPHASE NIL)
                      (NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
                      QGATE.LIMITED-ORACLE)
                     (CODE.DO) CODE.IF)
                    (QGATE.SWP))))
                 INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE)
                (CODE.FROMFLOAT)
                CODE.IF))
Errors for best individual: #(2.635976538085345d0 0.31798826904267274d0
                              0.4769824035640089d0)
Total errors for best individual: 3.4309472106920267d0
Size of best individual (points): 94

Average total errors in population: 1.1398028e+7
Median total errors in population: 74.25d0
Average program size in population (points): 58.8632
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 24
Best individual:
((-0.9231091737747192d0) (BOOLEAN.= INTEGER.YANK INTEGER.DUP QGATE.DUP)
 (FLOAT.>
  (QGATE.SWAP INTEGER.FROMBOOLEAN
              QGATE.STACKDEPTH
              (BOOLEAN.SWAP FLOAT.FROMBOOLEAN (QGATE.U2))
              QGATE.HADAMARD))
 (QGATE.U-THETA (BOOLEAN.=)
                QGATE.STACKDEPTH
                (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER))
                  ((INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE QGATE.COMPOSE)
                   ((CODE.DO) QGATE.GATE) CODE.YANKDUP
                   (((QGATE.U-THETA
                      (FLOAT.STACKDEPTH QGATE.GATE
                                        (CODE.STACKDEPTH CODE.=
                                                         ((BOOLEAN.NOT (FALSE))
                                                          CODE.CDR)
                                                         (CODE.IF)
                                                         FLOAT.SHOVE)
                                        (BOOLEAN.FROMINTEGER)
                                        ((CODE.DO*) (BOOLEAN.YANKDUP))))
                     (BOOLEAN.=) FLOAT.STACKDEPTH
                     ((QGATE.GATE QGATE.CPHASE NIL)
                      (NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
                      QGATE.LIMITED-ORACLE)
                     (CODE.DO) CODE.IF)
                    (QGATE.SWP))))
                 INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE)
                (CODE.FROMFLOAT)
                CODE.IF))
Errors for best individual: #(2.635976538085345d0 0.31798826904267274d0
                              0.4769824035640089d0)
Total errors for best individual: 3.4309472106920267d0
Size of best individual (points): 94

Average total errors in population: 1.1272025e+7
Median total errors in population: 74.25d0
Average program size in population (points): 60.7892
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 25
Best individual:
((-0.9231091737747192d0) (BOOLEAN.= INTEGER.YANK INTEGER.DUP QGATE.DUP)
 (FLOAT.>
  (QGATE.SWAP INTEGER.FROMBOOLEAN
              QGATE.STACKDEPTH
              (BOOLEAN.SWAP FLOAT.FROMBOOLEAN (QGATE.U2))
              QGATE.HADAMARD))
 (QGATE.U-THETA (BOOLEAN.=)
                QGATE.STACKDEPTH
                (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER))
                  ((INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE QGATE.COMPOSE)
                   ((CODE.DO) QGATE.GATE) CODE.YANKDUP
                   (((QGATE.U-THETA
                      (FLOAT.STACKDEPTH QGATE.GATE
                                        (CODE.STACKDEPTH CODE.=
                                                         ((BOOLEAN.NOT (FALSE))
                                                          CODE.CDR)
                                                         (CODE.IF)
                                                         FLOAT.SHOVE)
                                        (BOOLEAN.FROMINTEGER)
                                        ((CODE.DO*) (BOOLEAN.YANKDUP))))
                     (BOOLEAN.=) FLOAT.STACKDEPTH
                     ((QGATE.GATE QGATE.CPHASE NIL)
                      (NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
                      QGATE.LIMITED-ORACLE)
                     (CODE.DO) CODE.IF)
                    (QGATE.SWP))))
                 INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE)
                (CODE.FROMFLOAT)
                CODE.IF))
Errors for best individual: #(2.635976538085345d0 0.31798826904267274d0
                              0.4769824035640089d0)
Total errors for best individual: 3.4309472106920267d0
Size of best individual (points): 94

Average total errors in population: 1.1214023e+7
Median total errors in population: 77.25d0
Average program size in population (points): 61.3702
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 26
Best individual:
((-0.9231091737747192d0) (BOOLEAN.= INTEGER.YANK INTEGER.DUP QGATE.DUP)
 (FLOAT.>
  (QGATE.SWAP INTEGER.FROMBOOLEAN
              QGATE.STACKDEPTH
              (BOOLEAN.SWAP FLOAT.FROMBOOLEAN (QGATE.U2))
              QGATE.HADAMARD))
 (QGATE.U-THETA (BOOLEAN.=)
                QGATE.STACKDEPTH
                (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER))
                  ((INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE QGATE.COMPOSE)
                   ((CODE.DO) QGATE.GATE) CODE.YANKDUP
                   (((QGATE.U-THETA
                      (FLOAT.STACKDEPTH QGATE.GATE
                                        (CODE.STACKDEPTH CODE.=
                                                         ((BOOLEAN.NOT
                                                           (BOOLEAN.=))
                                                          CODE.CDR)
                                                         (CODE.IF)
                                                         FLOAT.SHOVE)
                                        (BOOLEAN.FROMINTEGER)
                                        ((CODE.DO*) (BOOLEAN.YANKDUP))))
                     (BOOLEAN.=) FLOAT.STACKDEPTH
                     ((QGATE.GATE QGATE.CPHASE NIL)
                      (NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
                      QGATE.LIMITED-ORACLE)
                     (CODE.DO) CODE.DO*)
                    (QGATE.SWP))))
                 INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE)
                (CODE.FROMFLOAT)
                CODE.IF))
Errors for best individual: #(2.635976538085345d0 0.31798826904267274d0
                              0.4769824035640089d0)
Total errors for best individual: 3.4309472106920267d0
Size of best individual (points): 94

Average total errors in population: 1.1488021e+7
Median total errors in population: 79.25d0
Average program size in population (points): 61.7538
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 27
Best individual:
((QGATE.HADAMARD
  ((QGATE.LIMITED-ORACLE)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (FLOAT.SIN) FLOAT.%)
   (QGATE.YANK (QGATE.TRANSPOSE)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           ((((((CODE.DO*COUNT
                                 (FLOAT.* (QGATE.U-THETA CODE.CDR)
                                          (FLOAT.+ FLOAT.>)
                                          ((CODE.DO*) CODE.CDR)
                                          (INTEGER.STACKDEPTH))))
                               FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.6226351438549163d0
                              0.4669763578911873d0)
Total errors for best individual: 3.089611501746104d0
Size of best individual (points): 96

Average total errors in population: 1.0700019e+7
Median total errors in population: 69.43920062382699d0
Average program size in population (points): 64.8882
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 28
Best individual:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH QGATE.LIMITED-ORACLE)
     (INTEGER.>) (QGATE.CNOT NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (FLOAT.SIN) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           ((((((CODE.DO*COUNT
                                 (FLOAT.* (QGATE.U-THETA CODE.CDR)
                                          (FLOAT.* FLOAT.STACKDEPTH
                                                   CODE.FROMFLOAT)
                                          ((CODE.DO*) CODE.CDR)
                                          (INTEGER.STACKDEPTH))))
                               FLOAT.SIN (CODE.= (FLOAT.+) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS ((NIL (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.6226351438549163d0
                              0.4669763578911873d0)
Total errors for best individual: 3.089611501746104d0
Size of best individual (points): 97

Average total errors in population: 1.0244018e+7
Median total errors in population: 61.622635143854914d0
Average program size in population (points): 67.2342
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 29
Best individual:
((-0.9231091737747192d0) (BOOLEAN.= INTEGER.YANK INTEGER.DUP QGATE.DUP)
 (FLOAT.>
  (QGATE.SWAP INTEGER.FROMBOOLEAN
              QGATE.STACKDEPTH
              (FLOAT.SIN FLOAT.FROMBOOLEAN (QGATE.U2))
              QGATE.HADAMARD))
 (QGATE.U-THETA (BOOLEAN.=)
                QGATE.STACKDEPTH
                (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER))
                  ((INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE QGATE.COMPOSE)
                   ((CODE.DO) QGATE.GATE) CODE.YANKDUP
                   (((QGATE.U-THETA
                      (FLOAT.STACKDEPTH QGATE.GATE
                                        (CODE.STACKDEPTH CODE.=
                                                         ((BOOLEAN.NOT (FALSE))
                                                          CODE.CDR)
                                                         (CODE.IF)
                                                         FLOAT.SHOVE)
                                        ((CODE.DO*) (BOOLEAN.YANKDUP))))
                     (BOOLEAN.=) FLOAT.STACKDEPTH
                     ((QGATE.GATE QGATE.CPHASE NIL)
                      (NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
                      QGATE.LIMITED-ORACLE)
                     (CODE.DO) CODE.IF)
                    (QGATE.SWP))))
                 INTEGER.STACKDEPTH QGATE.LIMITED-ORACLE)
                (CODE.FROMFLOAT)
                CODE.IF))
Errors for best individual: #(0.4304273914121529d0 0.28478630429392393d0
                              0.42717945644088573d0)
Total errors for best individual: 1.1423931521469626d0
Size of best individual (points): 92

Average total errors in population: 1.0892017e+7
Median total errors in population: 69.47732435670642d0
Average program size in population (points): 65.777
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 30
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.1402016e+7
Median total errors in population: 79.25d0
Average program size in population (points): 65.7214
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 31
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.1412014e+7
Median total errors in population: 71.75d0
Average program size in population (points): 66.7894
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 32
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.1608013e+7
Median total errors in population: 71.75d0
Average program size in population (points): 66.1836
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 33
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.1208014e+7
Median total errors in population: 71.75d0
Average program size in population (points): 65.8502
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 34
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.1030016e+7
Median total errors in population: 71.75d0
Average program size in population (points): 65.1824
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 35
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 69

Average total errors in population: 1.1072014e+7
Median total errors in population: 65.0d0
Average program size in population (points): 66.9632
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 36
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO*
  (BOOLEAN.STACKDEPTH (INTEGER.DUP QGATE.GATE (QGATE.LIMITED-ORACLE))))
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 75

Average total errors in population: 1.144201e+7
Median total errors in population: 64.0d0
Average program size in population (points): 68.1576
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 37
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.2076009e+7
Median total errors in population: 77.25604101606457d0
Average program size in population (points): 67.0096
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 38
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 70

Average total errors in population: 1.232801e+7
Median total errors in population: 103.71278169249398d0
Average program size in population (points): 66.2914
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 39
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0.1461633395928612d0 0.44087596265687523d0
                              0.3758018502166701d0)
Total errors for best individual: 0.9628411524664066d0
Size of best individual (points): 70

Average total errors in population: 1.2498009e+7
Median total errors in population: 106.49941609799852d0
Average program size in population (points): 64.3894
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 40
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0.1461633395928612d0 0.44087596265687523d0
                              0.3758018502166701d0)
Total errors for best individual: 0.9628411524664066d0
Size of best individual (points): 71

Average total errors in population: 1.334601e+7
Median total errors in population: 1.0000000584926734d+7
Average program size in population (points): 60.8932
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 41
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0.1461633395928612d0 0.44087596265687523d0
                              0.3758018502166701d0)
Total errors for best individual: 0.9628411524664066d0
Size of best individual (points): 71

Average total errors in population: 1.3654009e+7
Median total errors in population: 1.0000002999999999d+7
Average program size in population (points): 59.152
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 42
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((CODE.YANK NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  ((((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL) BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 (((CODE.QUOTE CODE.SHOVE)
   (((QGATE.SWAP) CODE.DISCREPANCY) 0.609594464302063d0))
  (BOOLEAN.STACKDEPTH) QGATE.SHOVE
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0.1461633395928612d0 0.44087596265687523d0
                              0.3758018502166701d0)
Total errors for best individual: 0.9628411524664066d0
Size of best individual (points): 74

Average total errors in population: 1.374801e+7
Median total errors in population: 1.00000045d+7
Average program size in population (points): 56.6716
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 43
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.FROMBOOLEAN)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP
     (((QGATE.CNOT CODE.SHOVE) QGATE.HADAMARD) CODE.DISCREPANCY (NUMQUBITS))
     (BOOLEAN.OR))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO*
  (BOOLEAN.STACKDEPTH (INTEGER.DUP QGATE.GATE (QGATE.LIMITED-ORACLE))))
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND)
Errors for best individual: #(0.14443366266224644d0 0.353713750003519d0
                              0.43119762262032735d0)
Total errors for best individual: 0.9293450352860928d0
Size of best individual (points): 79

Average total errors in population: 1.396801e+7
Median total errors in population: 1.0000005999999999d+7
Average program size in population (points): 55.17
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 44
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.FROMBOOLEAN)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP
     (((QGATE.CNOT) QGATE.HADAMARD) CODE.DISCREPANCY (NUMQUBITS))
     (BOOLEAN.OR))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO*
  (BOOLEAN.STACKDEPTH (INTEGER.DUP QGATE.GATE (QGATE.LIMITED-ORACLE))))
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND)
Errors for best individual: #(0.14443366266224644d0 0.353713750003519d0
                              0.43119762262032735d0)
Total errors for best individual: 0.9293450352860928d0
Size of best individual (points): 78

Average total errors in population: 1.410801e+7
Median total errors in population: 1.0000005000000001d+7
Average program size in population (points): 53.8594
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 45
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.FROMBOOLEAN)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP
     (((QGATE.CNOT) QGATE.HADAMARD) CODE.DISCREPANCY (NUMQUBITS))
     (BOOLEAN.OR))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO*
  (BOOLEAN.STACKDEPTH (INTEGER.DUP QGATE.GATE (QGATE.LIMITED-ORACLE))))
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND)
Errors for best individual: #(0.14443366266224644d0 0.353713750003519d0
                              0.43119762262032735d0)
Total errors for best individual: 0.9293450352860928d0
Size of best individual (points): 78

Average total errors in population: 1.3218012e+7
Median total errors in population: 190.69246878900003d0
Average program size in population (points): 56.0726
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 46
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.FROMBOOLEAN)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP
     (((QGATE.CNOT) QGATE.HADAMARD) CODE.DISCREPANCY (NUMQUBITS))
     (BOOLEAN.OR))
    BOOLEAN.= QGATE.GATE)
   NIL)
  CODE.DO*
  (BOOLEAN.STACKDEPTH (INTEGER.DUP QGATE.GATE (QGATE.LIMITED-ORACLE))))
 ((QGATE.SHOVE QGATE.= 0.609594464302063d0) (BOOLEAN.STACKDEPTH) INTEGER.SWAP
  ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE QGATE.SWAP))))
 QGATE.LIMITED-ORACLE CODE.APPEND)
Errors for best individual: #(0.14443366266224644d0 0.353713750003519d0
                              0.43119762262032735d0)
Total errors for best individual: 0.9293450352860928d0
Size of best individual (points): 77

Average total errors in population: 1.3098012e+7
Median total errors in population: 113.49993479908596d0
Average program size in population (points): 56.5384
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 47
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0 0.44087596265687523d0 0.3758018502166701d0)
Total errors for best individual: 0.8166778128735454d0
Size of best individual (points): 71

Average total errors in population: 1.2200013e+7
Median total errors in population: 105.69189696516639d0
Average program size in population (points): 59.214
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 48
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    CODE.DO*TIMES QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0 0.44087596265687523d0 0.3758018502166701d0)
Total errors for best individual: 0.8166778128735454d0
Size of best individual (points): 71

Average total errors in population: 1.1436013e+7
Median total errors in population: 69.24493401767711d0
Average program size in population (points): 62.7974
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 49
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    CODE.DO*TIMES QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.SWAP)
Errors for best individual: #(0 0.44087596265687523d0 0.3758018502166701d0)
Total errors for best individual: 0.8166778128735454d0
Size of best individual (points): 70

Average total errors in population: 1.0018016e+7
Median total errors in population: 62.0d0
Average program size in population (points): 67.063
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 50
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL)
    QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE QGATE.=) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT./ CODE.SWAP)
Errors for best individual: #(0 0.44087596265687523d0 0.3758018502166701d0)
Total errors for best individual: 0.8166778128735454d0
Size of best individual (points): 69

Average total errors in population: 9806016.0
Median total errors in population: 61.96248414495466d0
Average program size in population (points): 67.7508
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 51
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35208431036298515d0 0.4297920505501768d0)
Total errors for best individual: 0.7818763609131619d0
Size of best individual (points): 96

Average total errors in population: 1.0126015e+7
Median total errors in population: 61.980085143325184d0
Average program size in population (points): 66.9474
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 52
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 96

Average total errors in population: 9668017.0
Median total errors in population: 61.997901576742194d0
Average program size in population (points): 67.5256
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 53
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 9460017.0
Median total errors in population: 61.886315362360996d0
Average program size in population (points): 68.3908
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 54
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 9680017.0
Median total errors in population: 62.0d0
Average program size in population (points): 66.4338
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 55
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 9380018.0
Median total errors in population: 61.990743859496334d0
Average program size in population (points): 66.6406
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 56
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 8968018.0
Median total errors in population: 61.942697520422946d0
Average program size in population (points): 67.7214
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 57
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 9148020.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.595
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 58
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP QGATE.GATE))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35037966426444656d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557691d0
Size of best individual (points): 95

Average total errors in population: 9070020.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.4534
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 59
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP QGATE.GATE))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35037966426444656d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557691d0
Size of best individual (points): 95

Average total errors in population: 9452022.0
Median total errors in population: 64.2734862581739d0
Average program size in population (points): 67.6138
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 60
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP QGATE.GATE))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))) BOOLEAN.=
    BOOLEAN.DUP)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35037966426444656d0 0.4307988546913224d0)
Total errors for best individual: 0.781178518955769d0
Size of best individual (points): 93

Average total errors in population: 9516022.0
Median total errors in population: 64.806906953757d0
Average program size in population (points): 66.9578
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 61
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP QGATE.GATE))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))) BOOLEAN.=
    BOOLEAN.DUP)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35037966426444656d0 0.4307988546913224d0)
Total errors for best individual: 0.781178518955769d0
Size of best individual (points): 93

Average total errors in population: 9782023.0
Median total errors in population: 69.14499824561088d0
Average program size in population (points): 66.069
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 62
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP QGATE.GATE))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))) BOOLEAN.=
    BOOLEAN.DUP)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35037966426444656d0 0.4307988546913224d0)
Total errors for best individual: 0.781178518955769d0
Size of best individual (points): 93

Average total errors in population: 9562022.0
Median total errors in population: 65.0d0
Average program size in population (points): 66.639
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 63
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SHOVE (FLOAT.TAN)) (NUMQUBITS BOOLEAN.YANK))
    (CODE.NOOP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS)) (CODE.IF))
    QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH QGATE.GATE
              (CODE.STACKDEPTH CODE.=
                               (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                               (CODE.IF)
                               FLOAT.SHOVE)
              (QGATE.QNOT)
              (INTEGER.SHOVE (CODE.DO*COUNT) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   CODE.DISCREPANCY CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34689222742754167d0 0.43378317086823315d0)
Total errors for best individual: 0.7806753982957748d0
Size of best individual (points): 99

Average total errors in population: 9806023.0
Median total errors in population: 69.09633173116144d0
Average program size in population (points): 65.489
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 64
Best individual:
(((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (INTEGER.YANK CODE.NTH
                                            FLOAT.STACKDEPTH
                                            (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   QGATE.=)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 98

Average total errors in population: 9576023.0
Median total errors in population: 65.0d0
Average program size in population (points): 66.5776
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 65
Best individual:
(((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK ((INTEGER.STACKDEPTH)) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (INTEGER.YANK QGATE.DUP
                                            FLOAT.STACKDEPTH
                                            (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.=)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   NIL)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 99

Average total errors in population: 9358023.0
Median total errors in population: 64.55283516022949d0
Average program size in population (points): 67.238
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 66
Best individual:
((((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH)) QGATE.CPHASE)
  ((((QGATE.U-THETA NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (CODE.NTH FLOAT.STACKDEPTH
                                        (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN FLOAT.TAN)) QGATE.LIMITED-ORACLE)
   NIL)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 99

Average total errors in population: 9328023.0
Median total errors in population: 63.286375008452154d0
Average program size in population (points): 67.2306
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 67
Best individual:
(((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
  ((((QGATE.U-THETA NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD QGATE.YANKDUP (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH QGATE.U2
                              (TRUE FLOAT.> -9 QGATE.YANKDUP QGATE.SWAP)
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (QGATE.TRANSPOSE) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT./ CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   INTEGER.FROMBOOLEAN)
  (BOOLEAN.=))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 96

Average total errors in population: 9536022.0
Median total errors in population: 64.0d0
Average program size in population (points): 66.8778
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 68
Best individual:
(((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (((BOOLEAN.YANKDUP) INTEGER.SWAP)
     ((BOOLEAN.FROMFLOAT) (CODE.=) INTEGER.FROMBOOLEAN FLOAT.SWAP) CODE.IF
     ((INTEGER.YANK))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   QGATE.=)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 89

Average total errors in population: 8640023.0
Median total errors in population: 62.0d0
Average program size in population (points): 69.2056
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 69
Best individual:
((((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH)) QGATE.CPHASE)
  ((((QGATE.U-THETA NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (CODE.NTH FLOAT.STACKDEPTH
                                        (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN FLOAT.TAN)) QGATE.LIMITED-ORACLE)
   NIL)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 99

Average total errors in population: 8594021.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.9656
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 70
Best individual:
(((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (INTEGER.POP QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (INTEGER.YANK FLOAT.STACKDEPTH
                                                (FLOAT.SWAP (CODE.FROMFLOAT)))
                                  (CODE.IF)
                                  QGATE.TRANSPOSE)
                 (QGATE.QNOT)
                 (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN)) QGATE.LIMITED-ORACLE) QGATE.=)
  (BOOLEAN.NOT))
 QGATE.U-THETA)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 96

Average total errors in population: 8716019.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.5964
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 71
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH BOOLEAN.OR)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 INTEGER.STACKDEPTH
 (((QGATE.U-THETA
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP
                                             ((FLOAT.STACKDEPTH)
                                              (QGATE.COMPOSE
                                               -0.21761369705200195d0))))
                                  FLOAT.SHOVE)
                 (QGATE.QNOT)
                 ((FLOAT.-))))
   (CODE.SHOVE) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL QGATE.MEASURE)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.25995742833740887d0 0.4295625126782303d0)
Total errors for best individual: 0.6895199410156392d0
Size of best individual (points): 97

Average total errors in population: 8750019.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.1162
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 72
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  INTEGER.FROMFLOAT)
                 (QGATE.QNOT)
                 ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.NOOP (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036276d0)
Total errors for best individual: 0.6563265609432342d0
Size of best individual (points): 94

Average total errors in population: 8744019.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.6894
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 73
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH BOOLEAN.OR
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  INTEGER.FROMFLOAT)
                 (QGATE.QNOT)
                 ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.NOOP (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036276d0)
Total errors for best individual: 0.6563265609432342d0
Size of best individual (points): 94

Average total errors in population: 8324020.5
Median total errors in population: 62.0d0
Average program size in population (points): 70.1968
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 74
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP ((CODE.NOOP) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((FLOAT.< (QGATE.HADAMARD CODE.DISCREPANCY (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= INTEGER.FROMFLOAT)
   (QGATE.GATE))
  CODE.DO*)
 INTEGER.STACKDEPTH
 (((QGATE.U-THETA
    (CODE.NTHCDR QGATE.GATE
                 (CODE.NULL CODE.=
                            (CODE.NTH CODE.STACKDEPTH
                                      (FLOAT.POP (FLOAT.STACKDEPTH)))
                            FLOAT.SHOVE)
                 (QGATE.QNOT)
                 ((FLOAT.-))))
   (BOOLEAN.=) CODE.APPEND
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 (FLOAT.STACKDEPTH INTEGER.POP))
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036276d0)
Total errors for best individual: 0.6563265609432342d0
Size of best individual (points): 94

Average total errors in population: 8808019.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.5428
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 75
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH (CODE.STACKDEPTH (INTEGER.YANK))
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  INTEGER.FROMFLOAT)
                 (QGATE.QNOT)
                 ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.NOOP (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036276d0)
Total errors for best individual: 0.6563265609432342d0
Size of best individual (points): 97

Average total errors in population: 9112019.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.3466
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 76
Best individual:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* FLOAT.=)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.QUOTE))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.DISCREPANCY (CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF))
 QGATE.CPHASE)
Errors for best individual: #(4.440892098500626d-16 0.25000000000000033d0
                              0.3750000000000002d0)
Total errors for best individual: 0.625000000000001d0
Size of best individual (points): 85

Average total errors in population: 8866020.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.0868
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 77
Best individual:
(((NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* FLOAT.=)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.QUOTE))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.DISCREPANCY (CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF))
 QGATE.CPHASE)
Errors for best individual: #(4.440892098500626d-16 0.25000000000000033d0
                              0.3750000000000002d0)
Total errors for best individual: 0.625000000000001d0
Size of best individual (points): 84

Average total errors in population: 9436018.0
Median total errors in population: 63.254398536524036d0
Average program size in population (points): 66.766
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 78
Best individual:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* FLOAT.=)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.QUOTE))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.DISCREPANCY (CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF))
 QGATE.CPHASE)
Errors for best individual: #(4.440892098500626d-16 0.25000000000000033d0
                              0.3750000000000002d0)
Total errors for best individual: 0.625000000000001d0
Size of best individual (points): 85

Average total errors in population: 9150020.0
Median total errors in population: 63.45968834066935d0
Average program size in population (points): 68.4068
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 79
Best individual:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* FLOAT.=)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK
                                        ((QGATE.U-THETA FLOAT.COS) CODE.NTH)
                                        CODE.STACKDEPTH
                                        (FLOAT.POP (FLOAT.STACKDEPTH)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.QUOTE))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.DISCREPANCY (CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF))
 QGATE.CPHASE)
Errors for best individual: #(4.440892098500626d-16 0.25000000000000033d0
                              0.3750000000000002d0)
Total errors for best individual: 0.625000000000001d0
Size of best individual (points): 89

Average total errors in population: 1.0036019e+7
Median total errors in population: 67.5d0
Average program size in population (points): 66.883
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 80
Best individual:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8)))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* FLOAT.=)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.QUOTE))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.DISCREPANCY (CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF))
 QGATE.CPHASE)
Errors for best individual: #(4.440892098500626d-16 0.25000000000000033d0
                              0.3750000000000002d0)
Total errors for best individual: 0.625000000000001d0
Size of best individual (points): 83

Average total errors in population: 9832019.0
Median total errors in population: 65.87703368037896d0
Average program size in population (points): 67.3698
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Conducting emigration.
Conducting immigration. Number of immigrants: 25
Producing next generation...
Evaluating fitness of population...

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 81
Best individual:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.=
                       (INTEGER.YANK CODE.NTH