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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 0
Best individual:
((QGATE.GATE) (CODE.IF) 0 INTEGER.SWAP
 (CODE.DISCREPANCY FLOAT.TAN
                   (FLOAT.% (INTEGER.DUP CODE.DO*))
                   (QGATE.YANKDUP (CODE.YANK) QGATE.LIMITED-ORACLE)
                   (QGATE.LIMITED-ORACLE))
 (FLOAT.% CODE.FROMINTEGER QGATE.U2))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 26

Average total errors in population: 2.9234e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 23.2448
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:
(FLOAT.TAN QGATE.LIMITED-ORACLE
           INTEGER.<
           CODE.DO*COUNT
           ((QGATE.TRANSPOSE) FLOAT.+)
           ((CODE.CONS (4 CODE.STACKDEPTH FLOAT.YANK FLOAT.SIN)
                       (CODE.YANK)
                       (FLOAT.FROMBOOLEAN
                        ((CODE.DO) (CODE.NULL CODE.FROMFLOAT) QGATE.SHOVE
                         (CODE.DO*) (CODE.ATOM (BOOLEAN.FROMFLOAT)) CODE.CONS))
                       (FLOAT./))
            CODE.DO*TIMES))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 38

Average total errors in population: 2.7170002e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 19.6634
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((CODE.CAR FLOAT.% CODE.STACKDEPTH) (FLOAT.POP QGATE.SWAP)
     FLOAT.FROMINTEGER)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA (NUMQUBITS))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (FLOAT.SWAP) CODE.CDR) CODE.DUP))
Errors for best individual: #(0 2.708073418273571d0 59.0d0)
Total errors for best individual: 61.70807341827357d0
Size of best individual (points): 64

Average total errors in population: 2.2236007e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 23.0102
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.- QGATE.LIMITED-ORACLE
          ((INTEGER.STACKDEPTH)
           (BOOLEAN.OR (QGATE.TRANSPOSE BOOLEAN.NOT) CODE.YANKDUP FLOAT.SIN)
           INTEGER./ (BOOLEAN.STACKDEPTH)))
 (((CODE.DO 0.11710190773010254d0) ((QGATE.YANK) FLOAT.COS) CODE.CDR)
  QGATE.HADAMARD BOOLEAN.FROMINTEGER (CODE.SWAP CODE.=))
 (QGATE.LIMITED-ORACLE (INTEGER.FROMFLOAT CODE.APPEND)
                       ((INTEGER.% QGATE.END) (CODE.CDR) FLOAT.=)
                       INTEGER.%)
 QGATE.DUP)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 46

Average total errors in population: 1.6358022e+7
Median total errors in population: 2.0e+7
Average program size in population (points): 27.7248
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN CODE.IF
                               (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) (FLOAT.SWAP) CODE.CDR) CODE.DUP))
Errors for best individual: #(0 2.878401247653964d0 59.0d0)
Total errors for best individual: 61.87840124765396d0
Size of best individual (points): 75

Average total errors in population: 1.3082033e+7
Median total errors in population: 108.5d0
Average program size in population (points): 29.7596
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN CODE.IF
                               (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)
Errors for best individual: #(0 2.878401247653964d0 59.0d0)
Total errors for best individual: 61.87840124765396d0
Size of best individual (points): 67

Average total errors in population: 1.2258035e+7
Median total errors in population: 62.0d0
Average program size in population (points): 31.572
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN CODE.IF
                               (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)
Errors for best individual: #(0 2.878401247653964d0 59.0d0)
Total errors for best individual: 61.87840124765396d0
Size of best individual (points): 67

Average total errors in population: 1.2090036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 32.373
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:
((((INTEGER.YANK) QGATE.LIMITED-ORACLE)
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    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: #(0 2.826821810431806d0 59.0d0)
Total errors for best individual: 61.82682181043181d0
Size of best individual (points): 77

Average total errors in population: 1.1656037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 34.2802
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.HADAMARD
  ((1 (CODE.FROMFLOAT FLOAT.DUP QGATE.=))
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    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
                 ((CODE.POP CODE.NTHCDR (QGATE.U2 FLOAT.SIN CODE.CDR))
                  (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: #(0 2.708073418273571d0 59.0d0)
Total errors for best individual: 61.70807341827357d0
Size of best individual (points): 86

Average total errors in population: 1.1318037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 36.4766
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.HADAMARD
  (-0.2940850257873535d0 (CODE.QUOTE CODE.CONS) INTEGER.+
   ((CODE.APPEND QGATE.SWP (CODE.NTH)) QGATE.COMPOSE FLOAT.< FLOAT.-)
   (CODE.LIST CODE.NULL) (QGATE.END))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL 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: #(0 2.5291813772722924d0 59.0d0)
Total errors for best individual: 61.529181377272295d0
Size of best individual (points): 77

Average total errors in population: 1.1664037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 37.2448
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:
((QGATE.HADAMARD
  (NIL
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((CODE.CAR
                              ((FLOAT.COS INTEGER.STACKDEPTH) (CODE.DO)
                               FLOAT.YANKDUP QGATE.GATE))
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (FLOAT.SWAP) CODE.CDR) CODE.DUP))
Errors for best individual: #(2.5d0 10.5d0 0.4295625126782303d0)
Total errors for best individual: 13.429562512678231d0
Size of best individual (points): 70

Average total errors in population: 1.1434038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 40.7982
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
  (NIL
   ((TRUE) (FALSE CODE.CONS) ((FLOAT.POP QGATE.SWAP) FLOAT.FROMINTEGER)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((CODE.CAR
                              ((FLOAT.COS INTEGER.STACKDEPTH) (CODE.DO)
                               FLOAT.YANKDUP QGATE.GATE))
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (FLOAT.SWAP) CODE.CDR) CODE.DUP))
Errors for best individual: #(2.5d0 10.5d0 0.4295625126782303d0)
Total errors for best individual: 13.429562512678231d0
Size of best individual (points): 70

Average total errors in population: 1.1398038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 44.9732
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.HADAMARD
  ((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.826821810431806d0 8.620116357823855d0)
Total errors for best individual: 13.946938168255661d0
Size of best individual (points): 82

Average total errors in population: 1.1760038e+7
Median total errors in population: 63.51208203212915d0
Average program size in population (points): 49.6128
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.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.%) 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.826821810431806d0 8.620116357823855d0)
Total errors for best individual: 13.946938168255661d0
Size of best individual (points): 81

Average total errors in population: 1.1580039e+7
Median total errors in population: 65.0d0
Average program size in population (points): 54.8438
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.HADAMARD
  ((QGATE.COMPOSE)
   ((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.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.*
                  ((BOOLEAN.SWAP (CODE.DO*COUNT 4)
                                 QGATE.YANK
                                 (CODE.DO*TIMES (QGATE.END)
                                                (INTEGER.* NUMQUBITS)
                                                FLOAT.SIN))
                   (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 4.5d0 0.3750000000000002d0)
Total errors for best individual: 7.375d0
Size of best individual (points): 95

Average total errors in population: 1.1558037e+7
Median total errors in population: 64.13970774909946d0
Average program size in population (points): 56.0778
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((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.= (BOOLEAN.DUP) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.*
                  ((BOOLEAN.SWAP (CODE.DO*COUNT 4)
                                 QGATE.YANK
                                 (CODE.DO*TIMES (QGATE.END)
                                                (INTEGER.* NUMQUBITS)
                                                FLOAT.SIN))
                   (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 4.5d0 0.3750000000000002d0)
Total errors for best individual: 7.375d0
Size of best individual (points): 95

Average total errors in population: 1.1246037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 57.4764
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:
((QGATE.HADAMARD
  ((FLOAT.< (FLOAT.+ BOOLEAN.FROMFLOAT) NUMQUBITS)
   ((QGATE.COMPOSE)
    ((TRUE) (FALSE CODE.CONS)
     ((FLOAT.FROMINTEGER (INTEGER.>) 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): 89

Average total errors in population: 1.1714034e+7
Median total errors in population: 62.0d0
Average program size in population (points): 57.9648
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (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*))
                              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: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 89

Average total errors in population: 1.1690033e+7
Median total errors in population: 69.43920062382699d0
Average program size in population (points): 58.6936
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (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*))
                              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: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 89

Average total errors in population: 1.178403e+7
Median total errors in population: 79.25d0
Average program size in population (points): 58.5732
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (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*))
                              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: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 89

Average total errors in population: 1.1306029e+7
Median total errors in population: 101.0d0
Average program size in population (points): 60.567
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (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*))
                              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: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 89

Average total errors in population: 1.1352024e+7
Median total errors in population: 79.25d0
Average program size in population (points): 61.2366
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (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*))
                              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) QGATE.SHOVE) CODE.DUP))
Errors for best individual: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 89

Average total errors in population: 1.0996022e+7
Median total errors in population: 77.24647775838558d0
Average program size in population (points): 62.3744
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
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 77

Average total errors in population: 1.1356022e+7
Median total errors in population: 81.75d0
Average program size in population (points): 62.2562
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 77

Average total errors in population: 1.0902022e+7
Median total errors in population: 74.25d0
Average program size in population (points): 63.2476
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 77

Average total errors in population: 1.0872023e+7
Median total errors in population: 77.25d0
Average program size in population (points): 62.8352
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 77

Average total errors in population: 1.0982022e+7
Median total errors in population: 79.25d0
Average program size in population (points): 61.9736
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.>) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN
                    (INTEGER.+ NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 77

Average total errors in population: 1.0634024e+7
Median total errors in population: 81.75d0
Average program size in population (points): 63.0752
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
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 77

Average total errors in population: 1.0904023e+7
Median total errors in population: 98.5d0
Average program size in population (points): 62.9118
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
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      (((INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 76

Average total errors in population: 1.1400022e+7
Median total errors in population: 104.5d0
Average program size in population (points): 61.9248
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                ((((NIL FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR)) INTEGER.<
                   BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(3.3306690738754696d-16 2.5291813772722924d0
                              0.3968860329542194d0)
Total errors for best individual: 2.926067410226512d0
Size of best individual (points): 76

Average total errors in population: 1.1440022e+7
Median total errors in population: 104.5d0
Average program size in population (points): 61.7664
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.SWAP) FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(3.3306690738754696d-16 2.5291813772722924d0
                              0.3968860329542194d0)
Total errors for best individual: 2.926067410226512d0
Size of best individual (points): 77

Average total errors in population: 1.127002e+7
Median total errors in population: 96.98008514332518d0
Average program size in population (points): 62.7986
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (CODE.NOOP)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.NULL NIL CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.FROMBOOLEAN
      ((FLOAT.* (FLOAT.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(1.1102230246251565d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.9260674102265125d0
Size of best individual (points): 76

Average total errors in population: 1.1320021e+7
Median total errors in population: 100.0d0
Average program size in population (points): 62.503
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>) (INTEGER.YANKDUP NUMQUBITS)
     BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) NIL
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN) INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE)))) QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS
 (((BOOLEAN.AND)
   ((INTEGER.SWAP BOOLEAN.=
                  CODE.=
                  (((QGATE.END) (CODE.APPEND)
                    (CODE.FROMINTEGER BOOLEAN.POP CODE.YANKDUP) BOOLEAN.DUP)
                   FLOAT.-)
                  ((FLOAT.POP) CODE.IF))
    INTEGER.SWAP))))
Errors for best individual: #(1.1102230246251565d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.9260674102265125d0
Size of best individual (points): 89

Average total errors in population: 1.0960021e+7
Median total errors in population: 81.74936079063055d0
Average program size in population (points): 62.3196
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:
(((QGATE.HADAMARD
   (((INTEGER.SWAP) -1)
    ((TRUE) (FALSE CODE.CONS)
     ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
      (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
     QGATE.HADAMARD QGATE.LIMITED-ORACLE))
   ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
    (-0.7562001943588257d0 (CODE.APPEND) (CODE.CAR)
     ((NUMQUBITS QGATE.U-THETA
                 ((((FLOAT.SIN (CODE.= NIL CODE.DO* CODE.CAR)) INTEGER.<
                    BOOLEAN.AND)
                   NUMQUBITS)))
      (INTEGER.DUP
       ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
      QGATE.POP))
    QGATE.LIMITED-ORACLE)
   -7
   CODE.DISCREPANCY)
  NUMQUBITS)
 ((CODE.DISCREPANCY (FLOAT.SIN)
                    (CODE.IF CODE.ATOM CODE.=)
                    (BOOLEAN.YANKDUP QGATE.COMPOSE)
                    (FLOAT.+))
  ((CODE.NOOP) CODE.NOOP (INTEGER.+) CODE.QUOTE)))
Errors for best individual: #(4.440892098500626d-16 2.5291813772722924d0
                              0.3968860329542194d0)
Total errors for best individual: 2.926067410226512d0
Size of best individual (points): 96

Average total errors in population: 1.1352021e+7
Median total errors in population: 100.0d0
Average program size in population (points): 61.5054
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:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (INTEGER.SWAP) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (CODE.NOOP)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.NULL NIL CODE.CAR))
                   INTEGER.< BOOLEAN.AND)
                  NUMQUBITS)))
     (((FLOAT.* (FLOAT.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  QGATE.GATE
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(1.1102230246251565d-16 2.5291813772722924d0
                              0.3968860329542194d0)
Total errors for best individual: 2.926067410226512d0
Size of best individual (points): 75

Average total errors in population: 1.109602e+7
Median total errors in population: 74.75d0
Average program size in population (points): 62.2142
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE QGATE.HADAMARD)
    ((((BOOLEAN.STACKDEPTH CODE.IF QGATE.QNOT) BOOLEAN.STACKDEPTH) FLOAT./)
     (INTEGER.>) (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (-0.7587937116622925d0) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO*)) INTEGER.<
                   BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE)))) QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS
 (((BOOLEAN.AND)
   ((INTEGER.SWAP BOOLEAN.=
                  CODE.=
                  (((QGATE.END) NIL (CODE.FROMINTEGER BOOLEAN.POP CODE.YANKDUP)
                    BOOLEAN.DUP)
                   FLOAT.-)
                  ((FLOAT.POP) CODE.IF))
    INTEGER.SWAP))))
Errors for best individual: #(4.440892098500626d-16 2.5265918998140027d0
                              0.3949439248605019d0)
Total errors for best individual: 2.921535824674505d0
Size of best individual (points): 98

Average total errors in population: 1.0792019e+7
Median total errors in population: 71.75d0
Average program size in population (points): 63.5496
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:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE QGATE.HADAMARD)
    ((((BOOLEAN.STACKDEPTH CODE.IF QGATE.QNOT) BOOLEAN.STACKDEPTH) FLOAT./)
     (INTEGER.>) (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (-0.7587937116622925d0) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN (CODE.= NIL CODE.DO*)) INTEGER.<
                   BOOLEAN.AND)
                  NUMQUBITS)))
     (INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE)))) QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS
 (((BOOLEAN.AND)
   ((INTEGER.SWAP BOOLEAN.=
                  CODE.=
                  (((QGATE.END) NIL (CODE.FROMINTEGER BOOLEAN.POP CODE.YANKDUP)
                    BOOLEAN.DUP)
                   FLOAT.-)
                  ((FLOAT.POP) CODE.IF))
    INTEGER.SWAP))))
Errors for best individual: #(4.440892098500626d-16 2.5265918998140027d0
                              0.3949439248605019d0)
Total errors for best individual: 2.921535824674505d0
Size of best individual (points): 98

Average total errors in population: 1.1024019e+7
Median total errors in population: 71.76459068863615d0
Average program size in population (points): 62.9412
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)
              ((CODE.SWAP (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.=) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
  (CODE.IF CODE.SWAP FLOAT./))
 CODE.FROMBOOLEAN 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.0940019e+7
Median total errors in population: 71.76459068863615d0
Average program size in population (points): 63.5306
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))
  ((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)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (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.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 98

Average total errors in population: 1.1250019e+7
Median total errors in population: 74.75d0
Average program size in population (points): 62.2186
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)
  ((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)
 NUMQUBITS
 (((QGATE.TRANSPOSE
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (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.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 98

Average total errors in population: 1.0674018e+7
Median total errors in population: 69.27913163591292d0
Average program size in population (points): 64.7586
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)
  ((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)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.GATE))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 99

Average total errors in population: 1.0184017e+7
Median total errors in population: 65.0d0
Average program size in population (points): 67.146
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:
(((FLOAT.> QGATE.U-THETA CODE.YANKDUP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (INTEGER.SWAP -0.3377957344055176d0 CODE.LIST) FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.12571551877358345d0 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.9224975860666303d0
Size of best individual (points): 98

Average total errors in population: 1.0374016e+7
Median total errors in population: 61.96248414495466d0
Average program size in population (points): 66.6778
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:
(((FLOAT.> QGATE.U-THETA CODE.YANKDUP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (INTEGER.SWAP -0.3377957344055176d0 CODE.LIST) FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.12571551877358345d0 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.9224975860666303d0
Size of best individual (points): 96

Average total errors in population: 9546015.0
Median total errors in population: 53.75785640782405d0
Average program size in population (points): 69.1362
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.SHOVE) 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))
    5 QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (QGATE.DUP (CODE.DO*) (FLOAT.-))))
   (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.14443366266224644d0 0.3618678543385595d0
                              0.39790901547246715d0)
Total errors for best individual: 0.9042105324732731d0
Size of best individual (points): 99

Average total errors in population: 9312015.0
Median total errors in population: 61.526591899814d0
Average program size in population (points): 68.811
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:
(((FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 ((((FLOAT.>)
    ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.DO)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) CODE.IF BOOLEAN.DUP) BOOLEAN.NOT
  QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT.+ CODE.SWAP)
Errors for best individual: #(0 0.37134864754529273d0 0.44948438572690697d0)
Total errors for best individual: 0.8208330332721997d0
Size of best individual (points): 100

Average total errors in population: 9102016.0
Median total errors in population: 61.690022145197766d0
Average program size in population (points): 69.3468
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:
(((FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 ((((FLOAT.>)
    ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.DO)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) CODE.IF BOOLEAN.DUP) BOOLEAN.NOT
  QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT.+ CODE.SWAP)
Errors for best individual: #(0 0.37134864754529273d0 0.44948438572690697d0)
Total errors for best individual: 0.8208330332721997d0
Size of best individual (points): 100

Average total errors in population: 9320016.0
Median total errors in population: 61.85813519395487d0
Average program size in population (points): 68.994
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:
(((FLOAT.> QGATE.U-THETA BOOLEAN.SWAP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 9318017.0
Median total errors in population: 61.85813519395487d0
Average program size in population (points): 69.1674
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:
(((FLOAT.> QGATE.U-THETA BOOLEAN.SWAP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 9406016.0
Median total errors in population: 61.812679485603674d0
Average program size in population (points): 68.2928
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:
(((FLOAT.> QGATE.U-THETA BOOLEAN.SWAP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 9222017.0
Median total errors in population: 61.886315362360996d0
Average program size in population (points): 67.7014
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:
(((FLOAT.> QGATE.U-THETA BOOLEAN.SWAP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 8956017.0
Median total errors in population: 61.588452892795054d0
Average program size in population (points): 67.9792
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:
(((FLOAT.> QGATE.U-THETA BOOLEAN.SWAP FLOAT.SIN)
  (((INTEGER.YANK NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 9018016.0
Median total errors in population: 43.83830188116359d0
Average program size in population (points): 67.6484
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:
(((FLOAT.> QGATE.U-THETA BOOLEAN.SWAP FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 9162017.0
Median total errors in population: 59.4254405627405d0
Average program size in population (points): 68.2226
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:
(((FLOAT.> QGATE.U-THETA FLOAT.+ FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 ((((FLOAT.>)
    ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.DO)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) CODE.IF BOOLEAN.DUP) BOOLEAN.NOT
  QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE FLOAT.+ CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 100

Average total errors in population: 8978017.0
Median total errors in population: 61.690022145197766d0
Average program size in population (points): 69.1226
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:
(((FLOAT.> QGATE.U-THETA FLOAT.+ FLOAT.SIN)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((FLOAT.FROMBOOLEAN (QGATE.LIMITED-ORACLE -0.3377957344055176d0 CODE.LIST)
                       FLOAT./)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.U-THETA QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((QGATE.GATE) QGATE.U2) QGATE.SRN)
 (((((0.33808445930480957d0)
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP QGATE.COMPOSE))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) QGATE.QNOT FLOAT.>) BOOLEAN.NOT
  QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 98

Average total errors in population: 8826016.0
Median total errors in population: 45.444330588857945d0
Average program size in population (points): 69.4042
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((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): 99

Average total errors in population: 9276017.0
Median total errors in population: 61.76504238245042d0
Average program size in population (points): 67.5908
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((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): 99

Average total errors in population: 9032017.0
Median total errors in population: 61.62096304642253d0
Average program size in population (points): 67.8892
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 INTEGER.<)
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 99

Average total errors in population: 9392017.0
Median total errors in population: 61.7839243783545d0
Average program size in population (points): 67.1352
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH
                       (INTEGER.YANK CODE.NTH
                                     CODE.STACKDEPTH
                                     (FLOAT.POP (FLOAT.STACKDEPTH)))
                       (CODE.IF)
                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((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): 98

Average total errors in population: 8642018.0
Median total errors in population: 61.73241967518128d0
Average program size in population (points): 69.3504
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   NIL FLOAT.STACKDEPTH
   ((CODE.CONS ((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): 98

Average total errors in population: 8974018.0
Median total errors in population: 61.828260186943794d0
Average program size in population (points): 68.7028
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((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): 98

Average total errors in population: 9362018.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.7836
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (QGATE.GATE 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((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): 99

Average total errors in population: 8912021.0
Median total errors in population: 62.0d0
Average program size in population (points): 69.4424
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)
  ((((INTEGER.SWAP NUMQUBITS FLOAT.TAN) (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 QGATE.U-THETA)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (8)) NIL) BOOLEAN.=
    QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (INTEGER.% (CODE.DO*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34867621652563496d0 0.4322590173820735d0)
Total errors for best individual: 0.7809352339077085d0
Size of best individual (points): 96

Average total errors in population: 8892020.0
Median total errors in population: 61.96248414495466d0
Average program size in population (points): 69.5474
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)
  ((((INTEGER.SWAP NUMQUBITS BOOLEAN.POP) (FLOAT.TAN 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 (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((CODE.CONS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   INTEGER.SWAP 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): 98

Average total errors in population: 8886021.0
Median total errors in population: 61.961525653687545d0
Average program size in population (points): 69.5694
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)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
     (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))
 (BOOLEAN.STACKDEPTH))
Errors for best individual: #(0 0.4040515174168027d0 0.3756011467442306d0)
Total errors for best individual: 0.7796526641610333d0
Size of best individual (points): 96

Average total errors in population: 9074020.0
Median total errors in population: 61.963169181296045d0
Average program size in population (points): 69.0092
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (INTEGER.+)
     (INTEGER.SHOVE (CODE.DO*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 (BOOLEAN.STACKDEPTH FLOAT.STACKDEPTH))
Errors for best individual: #(0 0.4040515174168027d0 0.3756011467442306d0)
Total errors for best individual: 0.7796526641610333d0
Size of best individual (points): 97

Average total errors in population: 9240021.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.3382
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (INTEGER.+)
     (INTEGER.SHOVE (CODE.DO*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  NIL)
 (BOOLEAN.STACKDEPTH FLOAT.STACKDEPTH))
Errors for best individual: #(0 0.4040515174168027d0 0.3756011467442306d0)
Total errors for best individual: 0.7796526641610333d0
Size of best individual (points): 96

Average total errors in population: 9366021.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.239
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.POP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
 ((((CODE.=)
    (CODE.NTH
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.DO*) NIL)))
   (1) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 (BOOLEAN.STACKDEPTH))
Errors for best individual: #(0 0.25995742833740876d0 0.4295625126782303d0)
Total errors for best individual: 0.6895199410156391d0
Size of best individual (points): 95

Average total errors in population: 8954022.0
Median total errors in population: 62.0d0
Average program size in population (points): 69.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 67
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.POP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
 ((((CODE.=)
    (CODE.NTH
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.DO*) NIL)))
   (1) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 (BOOLEAN.STACKDEPTH))
Errors for best individual: #(0 0.25995742833740876d0 0.4295625126782303d0)
Total errors for best individual: 0.6895199410156391d0
Size of best individual (points): 95

Average total errors in population: 9076022.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.6686
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.POP FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS)) NIL)
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((CODE.=)
    (CODE.NTH
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK QGATE.SWAP 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))
 QGATE.SHOVE)
Errors for best individual: #(0 0.25995742833740876d0 0.4295625126782303d0)
Total errors for best individual: 0.6895199410156391d0
Size of best individual (points): 93

Average total errors in population: 9420020.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.7678
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS (BOOLEAN.YANK QGATE.GATE)) (FLOAT.SIN FLOAT.COS)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
     (CODE.STACKDEPTH CODE.CONS
                      (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)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2692875721772756d0 0.3763411823847813d0)
Total errors for best individual: 0.6456287545620569d0
Size of best individual (points): 96

Average total errors in population: 9408022.0
Median total errors in population: 64.0d0
Average program size in population (points): 67.8558
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((NUMQUBITS (BOOLEAN.YANK QGATE.GATE)) (FLOAT.SIN FLOAT.COS)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
     (CODE.STACKDEPTH CODE.CONS
                      (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                      (BOOLEAN.SWAP)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.DO*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2692875721772756d0 0.3763411823847813d0)
Total errors for best individual: 0.6456287545620569d0
Size of best individual (points): 96

Average total errors in population: 9656022.0
Median total errors in population: 65.78637500845215d0
Average program size in population (points): 66.5986
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)
  (((NUMQUBITS (BOOLEAN.YANK QGATE.GATE)) (FLOAT.SIN FLOAT.COS)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (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
     (CODE.STACKDEPTH CODE.CONS
                      (INTEGER.YANK CODE.NTH CODE.STACKDEPTH)
                      (BOOLEAN.SWAP)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.DO*))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2692875721772756d0 0.3763411823847813d0)
Total errors for best individual: 0.6456287545620569d0
Size of best individual (points): 95

Average total errors in population: 9154020.0
Median total errors in population: 62.117261764118496d0
Average program size in population (points): 67.8852
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 FLOAT.SIN)) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.COS)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK QGATE.SWAP CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.NOOP) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((NUMQUBITS) FLOAT.SIN CODE.DO*TIMES)) QGATE.LIMITED-ORACLE)
   BOOLEAN.FROMINTEGER QGATE.LIMITED-ORACLE)
  (QGATE.SWP))
 QGATE.SHOVE)
Errors for best individual: #(0 0.2692875721772755d0 0.3763411823847813d0)
Total errors for best individual: 0.6456287545620568d0
Size of best individual (points): 94

Average total errors in population: 9394020.0
Median total errors in population: 63.45968834066935d0
Average program size in population (points): 67.062
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 FLOAT.SIN)) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.COS)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK QGATE.SWAP CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.NOOP) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((NUMQUBITS) FLOAT.SIN CODE.DO*TIMES)) QGATE.LIMITED-ORACLE)
   BOOLEAN.FROMINTEGER QGATE.LIMITED-ORACLE)
  (QGATE.SWP))
 QGATE.SHOVE)
Errors for best individual: #(0 0.2692875721772755d0 0.3763411823847813d0)
Total errors for best individual: 0.6456287545620568d0
Size of best individual (points): 94

Average total errors in population: 9252020.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.2208
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 FLOAT.SIN)) QGATE.CPHASE)
  (((NUMQUBITS BOOLEAN.YANK) (FLOAT.COS)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (QGATE.LIMITED-ORACLE
    ((FALSE (INTEGER.STACKDEPTH) FLOAT.*)
     (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+))))
  ((((QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS)) (INTEGER.FROMFLOAT))
    QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((QGATE.U-THETA CODE.=)
    (CODE.NTH
     (CODE.STACKDEPTH CODE.=
                      (INTEGER.YANK QGATE.SWAP CODE.STACKDEPTH)
                      (CODE.IF)
                      FLOAT.SHOVE)
     (QGATE.QNOT)
     (INTEGER.SHOVE (CODE.NOOP) NIL)))
   NIL FLOAT.STACKDEPTH
   ((NUMQUBITS ((NUMQUBITS) FLOAT.SIN CODE.DO*TIMES)) QGATE.LIMITED-ORACLE)
   BOOLEAN.FROMINTEGER QGATE.LIMITED-ORACLE)
  (QGATE.SWP))
 QGATE.SHOVE)
Errors for best individual: #(0 0.2692875721772755d0 0.3763411823847813d0)
Total errors for best individual: 0.6456287545620568d0
Size of best individual (points): 93

Average total errors in population: 9510020.0
Median total errors in population: 64.5d0
Average program size in population (points): 67.4118
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:
(((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.SHOVE)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.=
                       (CODE.NTH CODE.NTH
                                 CODE.STACKDEPTH
                                 (FLOAT.POP (FLOAT.STACKDEPTH)))
                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((BOOLEAN.FROMFLOAT))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF))
 FLOAT.STACKDEPTH)
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: 9698018.0
Median total errors in population: 64.5d0
Average program size in population (points): 67.0158
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)))
   (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 (BOOLEAN.SHOVE (BOOLEAN.YANKDUP FLOAT.> FLOAT.STACKDEPTH))))
Errors for best individual: #(4.440892098500626d-16 0.25000000000000033d0
                              0.3750000000000002d0)
Total errors for best individual: 0.625000000000001d0
Size of best individual (points): 91

Average total errors in population: 9354019.0
Median total errors in population: 63.5d0
Average program size in population (points): 67.716
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:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP
     ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8)))
    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.STACKDEPTH CODE.=
                                       ((INTEGER.YANK CODE.NTH
                                                      CODE.STACKDEPTH
                                                      (FLOAT.POP
                                                       (FLOAT.STACKDEPTH)))
                                        ((CODE.POP QGATE.POP)
                                         FLOAT.FROMINTEGER))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((BOOLEAN.FROMFLOAT))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (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: 9656020.0
Median total errors in population: 64.0d0
Average program size in population (points): 67.0282
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))
                 NIL)
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((CODE.FROMFLOAT FLOAT.TAN
                   QGATE.TRANSPOSE
                   FLOAT.SWAP
                   (BOOLEAN.DUP CODE.DUP)
                   FLOAT.FROMBOOLEAN)
   ((((FLOAT.STACKDEPTH QGATE.GATE
                        (CODE.=
                         (INTEGER.YANK CODE.NTH
                                       CODE.STACKDEPTH
                                       (FLOAT.POP NIL))
                         FLOAT.SHOVE)
                        (QGATE.QNOT)
                        ((BOOLEAN.FROMFLOAT))))
     (QGATE.SWAP))
    (BOOLEAN.=) FLOAT.STACKDEPTH
    ((NUMQUBITS (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): 95

Average total errors in population: 9462020.0
Median total errors in population: 64.21314401892029d0
Average program size in population (points): 67.4174
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 (NUMQUBITS))
     (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
 (((CODE.FROMFLOAT (FLOAT.TAN (CODE.QUOTE CODE.CAR))
                   QGATE.TRANSPOSE
                   FLOAT.SWAP
                   (BOOLEAN.DUP CODE.DUP)
                   FLOAT.FROMBOOLEAN)
   ((((FLOAT.STACKDEPTH QGATE.GATE
                        (CODE.=
                         (INTEGER.YANK CODE.NTH
                                       CODE.STACKDEPTH
                                       (FLOAT.POP NIL))
                         FLOAT.SHOVE)
                        (QGATE.QNOT)
                        ((BOOLEAN.FROMFLOAT))))
     (QGATE.SWAP))
    (BOOLEAN.=) FLOAT.STACKDEPTH
    ((NUMQUBITS (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): 100

Average total errors in population: 9388022.0
Median total errors in population: 65.11319681888396d0
Average program size in population (points): 67.1234
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.SIN)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY)
                 (INTEGER.FROMFLOAT))
    BOOLEAN.=)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((CODE.FROMFLOAT FLOAT.TAN
                   QGATE.TRANSPOSE
                   FLOAT.SWAP
                   (BOOLEAN.DUP CODE.DUP)
                   FLOAT.FROMBOOLEAN)
   ((((FLOAT.STACKDEPTH QGATE.GATE
                        (CODE.=
                         (INTEGER.YANK CODE.NTH
                                       CODE.STACKDEPTH
                                       (FLOAT.POP NIL))
                         FLOAT.SHOVE)
                        (QGATE.QNOT)
                        ((BOOLEAN.FROMFLOAT))))
     (QGATE.SWAP))
    (BOOLEAN.=) FLOAT.STACKDEPTH
    ((NUMQUBITS (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): 94

Average total errors in population: 9296021.0
Median total errors in population: 64.42192697936625d0
Average program size in population (points): 65.8342
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...

;;;;;;;;;;;;;;;;;;;;;;;;;