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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 0
Best individual:
(QGATE.LIMITED-ORACLE QGATE.STACKDEPTH
                      (FLOAT.POP (CODE.DO CODE.SWAP) CODE.FROMINTEGER))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 9

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 1
Best individual:
(QGATE.POP FLOAT.*
           (CODE.DO*COUNT BOOLEAN.YANKDUP
                          (10 INTEGER.> (CODE.DO*TIMES FLOAT.YANK))
                          QGATE.STACKDEPTH)
           (CODE.NOOP INTEGER.FROMBOOLEAN (FLOAT.+ CODE.=))
           (((CODE.YANK CODE.IF) CODE.YANKDUP) CODE.DO*)
           QGATE.LIMITED-ORACLE
           (QGATE.GATE QGATE.YANKDUP)
           CODE.DO)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 31

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 2
Best individual:
(FLOAT.STACKDEPTH (CODE.FROMBOOLEAN)
                  INTEGER.STACKDEPTH
                  QGATE.LIMITED-ORACLE
                  (QGATE.SHOVE)
                  (CODE.DO*COUNT
                   (TRUE BOOLEAN.FROMINTEGER INTEGER.FROMBOOLEAN)))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 14

Average total errors in population: 2.1754009e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 23.7126
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.STACKDEPTH (CODE.FROMBOOLEAN)
                  INTEGER.STACKDEPTH
                  QGATE.LIMITED-ORACLE
                  ((((BOOLEAN.STACKDEPTH QGATE.TRANSPOSE CODE.FROMBOOLEAN)
                     QGATE.DUP CODE.FROMFLOAT
                     (CODE.DO BOOLEAN.FROMINTEGER CODE.DO*COUNT))
                    INTEGER.FROMFLOAT CODE.DUP)
                   (QGATE.SHOVE))
                  (CODE.DO*COUNT
                   (TRUE BOOLEAN.FROMINTEGER INTEGER.FROMBOOLEAN)))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 29

Average total errors in population: 1.6294022e+7
Median total errors in population: 2.0e+7
Average program size in population (points): 28.1778
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.STACKDEPTH)
 (4 FLOAT.POP (FLOAT.STACKDEPTH QGATE.STACKDEPTH QGATE.SWAP))
 (CODE.DUP
  (CODE.DO*COUNT
   (INTEGER.STACKDEPTH CODE.FROMFLOAT
                       (CODE.SWAP CODE.DO*COUNT INTEGER.YANKDUP)))
  BOOLEAN.NOT
  (((QGATE.YANKDUP) (QGATE.LIMITED-ORACLE FLOAT.YANKDUP) QGATE.U2) FLOAT.DUP
   (FLOAT.% QGATE.CNOT))
  CODE.LIST))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 35

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 5
Best individual:
(FLOAT.STACKDEPTH (CODE.FROMBOOLEAN)
                  INTEGER.STACKDEPTH
                  QGATE.LIMITED-ORACLE
                  (QGATE.SHOVE)
                  (CODE.DO*COUNT
                   ((NUMQUBITS
                     (FLOAT.FROMBOOLEAN CODE.SHOVE
                                        (FLOAT.COS (CODE.IF FLOAT.DUP)
                                                   ((BOOLEAN.AND FLOAT.YANKDUP)
                                                    FLOAT.= CODE.DO*))
                                        CODE.=)
                     (CODE.FROMINTEGER))
                    (TRUE BOOLEAN.FROMINTEGER))))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 33

Average total errors in population: 1.2668034e+7
Median total errors in population: 65.0d0
Average program size in population (points): 31.2766
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) QGATE.SHOVE)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR (FLOAT.SIN QGATE.U-THETA))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(2.220446049250313d-16 2.6326038165371983d0 59.0d0)
Total errors for best individual: 61.6326038165372d0
Size of best individual (points): 58

Average total errors in population: 1.2654033e+7
Median total errors in population: 62.0d0
Average program size in population (points): 32.9482
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) QGATE.SHOVE)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR
                                       ((FLOAT.SIN QGATE.U-THETA)
                                        (((INTEGER.YANKDUP BOOLEAN.NOT)
                                          INTEGER.<)
                                         BOOLEAN.YANKDUP 9)))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(2.220446049250313d-16 2.6326038165371983d0 59.0d0)
Total errors for best individual: 61.6326038165372d0
Size of best individual (points): 67

Average total errors in population: 1.2340034e+7
Median total errors in population: 62.0d0
Average program size in population (points): 35.1468
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) QGATE.SHOVE)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR
                                       ((FLOAT.SIN QGATE.U-THETA)
                                        (((INTEGER.YANKDUP BOOLEAN.NOT)
                                          INTEGER.<)
                                         BOOLEAN.YANKDUP 9)))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(2.220446049250313d-16 2.6326038165371983d0 59.0d0)
Total errors for best individual: 61.6326038165372d0
Size of best individual (points): 66

Average total errors in population: 1.1768036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 37.7178
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) CODE.DO*)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR (CODE.SWAP QGATE.U-THETA))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(0 2.5759534941093714d0 59.0d0)
Total errors for best individual: 61.57595349410937d0
Size of best individual (points): 58

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 10
Best individual:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) CODE.DO*)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR (CODE.SWAP QGATE.U-THETA))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(0 2.5759534941093714d0 59.0d0)
Total errors for best individual: 61.57595349410937d0
Size of best individual (points): 58

Average total errors in population: 1.1318037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 41.677
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:
((((FLOAT.FROMBOOLEAN CODE.FROMBOOLEAN FLOAT./) (CODE.DO*) CODE.DO*)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR (CODE.SWAP QGATE.U-THETA))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(0 2.575953494109371d0 59.0d0)
Total errors for best individual: 61.57595349410937d0
Size of best individual (points): 58

Average total errors in population: 1.1290037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 43.3506
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) QGATE.SHOVE)
  ((FLOAT.SWAP
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (((FLOAT.SHOVE
                    ((CODE.IF CODE.DO*COUNT) BOOLEAN.STACKDEPTH (CODE.NTH)
                     (NUMQUBITS QGATE.SWP FLOAT.TAN) FLOAT.YANK)
                    CODE.STACKDEPTH
                    BOOLEAN.SWAP)
                   QGATE.LIMITED-ORACLE)
                  CODE.NTHCDR (FLOAT.SIN QGATE.U-THETA))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(0 2.528812754607922d0 59.0d0)
Total errors for best individual: 61.52881275460792d0
Size of best individual (points): 75

Average total errors in population: 1.0708038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 45.2392
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) QGATE.SHOVE)
  ((FLOAT.SWAP
    ((QGATE.STACKDEPTH
      ((FALSE -0.7091494798660278d0) BOOLEAN.POP
       (((FLOAT.SHOVE
          ((CODE.IF CODE.DO*COUNT) BOOLEAN.STACKDEPTH (CODE.NTH)
           (NUMQUBITS QGATE.SWP FLOAT.TAN) FLOAT.YANK)
          CODE.STACKDEPTH
          BOOLEAN.SWAP)
         QGATE.LIMITED-ORACLE)
        CODE.NTHCDR (FLOAT.SIN QGATE.U-THETA))
       CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(0 2.5288127546079227d0 59.0d0)
Total errors for best individual: 61.52881275460792d0
Size of best individual (points): 74

Average total errors in population: 1.1400037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 46.0918
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:
(((((CODE.=) FLOAT.STACKDEPTH) (CODE.DO*) QGATE.SHOVE)
  ((FLOAT.SWAP
    ((FLOAT.+
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR (FLOAT.SIN QGATE.U-THETA))
                 CODE.QUOTE)))
    -0.694973349571228d0)
   (FLOAT.YANK) CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 ((INTEGER.STACKDEPTH
   (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE))
  INTEGER.-)
 CODE.DISCREPANCY)
Errors for best individual: #(0 2.6326038165371983d0 38.86502004437697d0)
Total errors for best individual: 41.49762386091417d0
Size of best individual (points): 50

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 15
Best individual:
((-0.9231091737747192d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(1.1102230246251565d-16 0.4044661569950202d0
                              38.86748691917567d0)
Total errors for best individual: 39.27195307617069d0
Size of best individual (points): 51

Average total errors in population: 1.1120037e+7
Median total errors in population: 65.0d0
Average program size in population (points): 49.0866
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:
((-0.9231091737747192d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(1.1102230246251565d-16 0.4044661569950202d0
                              38.86748691917567d0)
Total errors for best individual: 39.27195307617069d0
Size of best individual (points): 51

Average total errors in population: 1.0948037e+7
Median total errors in population: 65.0d0
Average program size in population (points): 49.0284
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:
((-0.9231091737747192d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(1.1102230246251565d-16 0.4044661569950202d0
                              38.86748691917567d0)
Total errors for best individual: 39.27195307617069d0
Size of best individual (points): 51

Average total errors in population: 1.1302037e+7
Median total errors in population: 96.57595349410937d0
Average program size in population (points): 48.5228
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:
((-0.9231091737747192d0) BOOLEAN.OR
 ((CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(1.1102230246251565d-16 0.4044661569950202d0
                              38.86748691917567d0)
Total errors for best individual: 39.27195307617069d0
Size of best individual (points): 49

Average total errors in population: 1.1106037e+7
Median total errors in population: 66.57595349410937d0
Average program size in population (points): 50.0206
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:
((-0.9231091737747192d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(1.1102230246251565d-16 0.4044661569950202d0
                              38.86748691917567d0)
Total errors for best individual: 39.27195307617069d0
Size of best individual (points): 51

Average total errors in population: 1.1078036e+7
Median total errors in population: 65.3673961834628d0
Average program size in population (points): 53.8088
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:
((-0.9054964780807495d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(0 0.3830951507629462d0 38.85479846463855d0)
Total errors for best individual: 39.2378936154015d0
Size of best individual (points): 51

Average total errors in population: 1.1470035e+7
Median total errors in population: 69.0241640642583d0
Average program size in population (points): 54.8338
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:
((-0.9054964780807495d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(0 0.3830951507629462d0 38.85479846463855d0)
Total errors for best individual: 39.2378936154015d0
Size of best individual (points): 51

Average total errors in population: 1.1658034e+7
Median total errors in population: 97.0d0
Average program size in population (points): 55.0322
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:
((-0.9054964780807495d0) BOOLEAN.OR
 (((QGATE.TRANSPOSE) CODE.LIST QGATE.U2 FLOAT.SWAP)
  (QGATE.LIMITED-ORACLE CODE.LIST (QGATE.LIMITED-ORACLE) QGATE.LIMITED-ORACLE))
 ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  (INTEGER.FROMFLOAT))
 (INTEGER.YANKDUP CODE.NULL)
 ((CODE.DO*TIMES BOOLEAN.POP BOOLEAN.POP)
  (QGATE.U-THETA (BOOLEAN.=)
                 QGATE.STACKDEPTH
                 ((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
                  QGATE.LIMITED-ORACLE)
                 (INTEGER.STACKDEPTH)
                 CODE.IF)))
Errors for best individual: #(0 0.3830951507629462d0 38.85479846463855d0)
Total errors for best individual: 39.2378936154015d0
Size of best individual (points): 51

Average total errors in population: 1.1990032e+7
Median total errors in population: 98.57595349410937d0
Average program size in population (points): 53.017
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:
(((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) CODE.NTH QGATE.COMPOSE)
  ((CODE.DO
    ((QGATE.STACKDEPTH
      (FLOAT.TAN (FALSE -0.7091494798660278d0)
                 BOOLEAN.POP
                 (QGATE.LIMITED-ORACLE CODE.NTHCDR (FLOAT.SIN QGATE.U-THETA))
                 FLOAT./)))
    -0.694973349571228d0)
   (((INTEGER.< CODE.FROMBOOLEAN FLOAT./) (CODE.DO*) CODE.DO*)
    ((CODE.DO
      ((QGATE.STACKDEPTH
        (FLOAT.TAN (FALSE -0.7091494798660278d0)
                   BOOLEAN.POP
                   (QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
                   CODE.QUOTE)))
      -0.694973349571228d0)
     CODE.CONS)
    (INTEGER.FROMBOOLEAN) QGATE.GATE (QGATE.LIMITED-ORACLE))
   CODE.CONS)
  (INTEGER.FROMBOOLEAN INTEGER.SWAP) QGATE.GATE (QGATE.LIMITED-ORACLE))
 (((FLOAT.SIN BOOLEAN.FROMINTEGER FLOAT.COS QGATE.SRN)
   (INTEGER.STACKDEPTH
    (FLOAT.STACKDEPTH (CODE.ATOM FLOAT.SIN) QGATE.LIMITED-ORACLE)))
  INTEGER.-)
 INTEGER.STACKDEPTH
 ((-0.9054964780807495d0) CODE.STACKDEPTH ((CODE.STACKDEPTH) CODE.CAR)))
Errors for best individual: #(0 0.36435037852152297d0 38.84420693212505d0)
Total errors for best individual: 39.20855731064657d0
Size of best individual (points): 95

Average total errors in population: 1.170203e+7
Median total errors in population: 97.0d0
Average program size in population (points): 53.4964
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:
(((NUMQUBITS QGATE.U2)
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.FROMFLOAT)
    ((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.= (CODE.FROMBOOLEAN) CODE.DO* CODE.CAR)
                                (FLOAT.%
                                 (INTEGER.STACKDEPTH
                                  (CODE.SWAP QGATE.STACKDEPTH)))))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS
 ((CODE.YANKDUP (CODE.ATOM)) (QGATE.MEASURE) (FLOAT.FROMINTEGER)
  QGATE.TRANSPOSE))
Errors for best individual: #(2.5d0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 5.909647656003414d0
Size of best individual (points): 92

Average total errors in population: 1.1468029e+7
Median total errors in population: 65.0d0
Average program size in population (points): 54.129
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
  ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
   ((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)
                                (CODE.= (CODE.FROMBOOLEAN) CODE.DO* CODE.CAR))
                               INTEGER.< BOOLEAN.AND)
                              (((CODE.DO*TIMES) CODE.IF) QGATE.CPHASE
                               (QGATE.U2 INTEGER.=)
                               (((CODE.CAR) QGATE.SWAP) FLOAT.>)))
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 96

Average total errors in population: 1.0924029e+7
Median total errors in population: 62.0d0
Average program size in population (points): 56.9062
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
  ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
   ((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)
                                (CODE.= (CODE.FROMBOOLEAN) CODE.DO* CODE.NTH))
                               INTEGER.< BOOLEAN.AND)
                              (((CODE.DO*TIMES) CODE.IF) QGATE.CPHASE
                               (QGATE.U2 INTEGER.=)
                               (((CODE.CAR) QGATE.SWAP) FLOAT.>)))
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 96

Average total errors in population: 9940029.0
Median total errors in population: 61.60836250415046d0
Average program size in population (points): 62.6752
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 27
Best individual:
((QGATE.HADAMARD
  ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
   ((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)
                                (CODE.= (CODE.FROMBOOLEAN) CODE.DO* CODE.CAR))
                               INTEGER.<)
                              (((CODE.DO*TIMES) CODE.IF) QGATE.CPHASE
                               (QGATE.U2 INTEGER.=)
                               (((CODE.CAR) QGATE.SWAP) FLOAT.>)))
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 95

Average total errors in population: 9834028.0
Median total errors in population: 61.525964519999675d0
Average program size in population (points): 65.5712
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 28
Best individual:
((QGATE.HADAMARD
  ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP INTEGER.<) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           ((((((CODE.DO*COUNT)
                                (CODE.= (CODE.FROMBOOLEAN) CODE.DO* CODE.NTH))
                               INTEGER.< BOOLEAN.AND)
                              (((CODE.DO*TIMES) CODE.IF) QGATE.CPHASE
                               (QGATE.U2 INTEGER.=)
                               (((CODE.CAR) QGATE.SWAP) FLOAT.>)))
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 96

Average total errors in population: 1.0728026e+7
Median total errors in population: 61.88998798191433d0
Average program size in population (points): 64.6836
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
  ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
   ((TRUE) (FALSE INTEGER.=)
    ((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.FROMFLOAT) 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: #(4.440892098500626d-16 4.5d0 0.3750000000000002d0)
Total errors for best individual: 4.875d0
Size of best individual (points): 83

Average total errors in population: 1.0964023e+7
Median total errors in population: 74.25d0
Average program size in population (points): 64.4466
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:
(((INTEGER.YANKDUP NUMQUBITS)
  ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (INTEGER.+) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.FROMFLOAT)
                                       CODE.DO*
                                       CODE.DO*TIMES))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS
 ((((QGATE.STACKDEPTH CODE.DISCREPANCY)) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.980085143325183d0
                              0.4295625126782303d0)
Total errors for best individual: 3.409647656003414d0
Size of best individual (points): 87

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 31
Best individual:
((QGATE.HADAMARD
  ((QGATE.COMPOSE)
   ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
    ((TRUE) (FALSE CODE.CONS)
     ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
      (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
     QGATE.HADAMARD INTEGER.-)))
  ((QGATE.GATE (BOOLEAN.NOT) (FLOAT.% (QGATE.CPHASE FLOAT.* FLOAT.SIN)))
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((((QGATE.CPHASE) FLOAT.SWAP) (CODE.DO*COUNT))
                               FLOAT.SIN
                               (CODE.= (CODE.FROMBOOLEAN) 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 (((CODE.NULL) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.6226351438549163d0
                              0.4669763578911873d0)
Total errors for best individual: 3.089611501746104d0
Size of best individual (points): 96

Average total errors in population: 1.117802e+7
Median total errors in population: 98.5d0
Average program size in population (points): 63.2532
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)
   ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
    ((TRUE) (FALSE CODE.CONS)
     ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
      (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
     QGATE.HADAMARD INTEGER.-)))
  ((QGATE.GATE (BOOLEAN.NOT) (FLOAT.% (QGATE.CPHASE FLOAT.* FLOAT.SIN)))
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((((QGATE.CPHASE) FLOAT.SWAP) (CODE.DO*COUNT))
                               FLOAT.SIN
                               (CODE.= (CODE.FROMBOOLEAN) 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 (((CODE.NULL) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.6226351438549163d0
                              0.4669763578911873d0)
Total errors for best individual: 3.089611501746104d0
Size of best individual (points): 96

Average total errors in population: 1.093602e+7
Median total errors in population: 81.75d0
Average program size in population (points): 64.4684
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
  ((QGATE.COMPOSE)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH QGATE.LIMITED-ORACLE)
     (INTEGER.>) (QGATE.CNOT NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (FLOAT.SIN) (FLOAT.% (CODE.LIST)))
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           ((((((CODE.DO*COUNT
                                 (FLOAT.* (QGATE.U-THETA CODE.CDR)
                                          (FLOAT.* FLOAT.STACKDEPTH
                                                   CODE.FROMFLOAT)
                                          ((CODE.DO*) CODE.CDR)
                                          (INTEGER.STACKDEPTH))))
                               FLOAT.SIN (CODE.= (FLOAT.+) CODE.DO* CODE.CAR))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK
  CODE.DISCREPANCY)
 NUMQUBITS ((NIL (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.6226351438549163d0
                              0.4669763578911873d0)
Total errors for best individual: 3.089611501746104d0
Size of best individual (points): 100

Average total errors in population: 1.1170018e+7
Median total errors in population: 98.4900425716626d0
Average program size in population (points): 64.181
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
  ((QGATE.COMPOSE)
   ((QGATE.LIMITED-ORACLE (CODE.SWAP QGATE.U-THETA))
    ((TRUE) (FALSE CODE.CONS)
     ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
      (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
     QGATE.HADAMARD INTEGER.-)))
  ((QGATE.GATE (BOOLEAN.NOT) (FLOAT.% (QGATE.CPHASE FLOAT.* FLOAT.SIN)))
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((((QGATE.CPHASE)) (CODE.DO*COUNT)) FLOAT.SIN
                               (CODE.= (CODE.FROMBOOLEAN) 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 (((CODE.NULL) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(4.440892098500626d-16 2.6226351438549163d0
                              0.4669763578911873d0)
Total errors for best individual: 3.089611501746104d0
Size of best individual (points): 95

Average total errors in population: 1.0842018e+7
Median total errors in population: 79.25d0
Average program size in population (points): 65.347
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:
((CODE.FROMINTEGER)
 (((CODE.= (CODE.FROMBOOLEAN) CODE.DO* CODE.CAR)
   ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS CODE.NOOP)
               (FLOAT.= QGATE.COMPOSE)
               ((INTEGER.DUP) FLOAT.FROMINTEGER
                (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    ((CODE.YANK (INTEGER.STACKDEPTH))
     (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
   ((QGATE.GATE) FLOAT.SHOVE) CODE.DO* BOOLEAN.STACKDEPTH)
  ((((FLOAT.>)
     ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
     (QGATE.GATE) BOOLEAN.STACKDEPTH)
    CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
   INTEGER.DUP (INTEGER.FROMBOOLEAN (CODE.SHOVE) CODE.SHOVE BOOLEAN.DUP)
   BOOLEAN.NOT FLOAT.POP)
  CODE.FROMBOOLEAN FLOAT.* FLOAT.SIN))
Errors for best individual: #(0 2.5915518928348695d0 0.4731620027358139d0)
Total errors for best individual: 3.0647138955706836d0
Size of best individual (points): 75

Average total errors in population: 1.1188017e+7
Median total errors in population: 98.5d0
Average program size in population (points): 65.0954
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:
((((INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
   CODE.QUOTE QGATE.GATE)
  FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (INTEGER.SWAP (-0.6962908506393433d0 (BOOLEAN.YANKDUP))
                   (CODE.DUP)
                   (INTEGER.-
                    (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                      INTEGER.FROMBOOLEAN))
                    INTEGER.DUP
                    (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH FLOAT.FROMBOOLEAN)
      ((0.3849058151245117d0) QGATE.END) QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      QGATE.U-THETA
      ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   INTEGER.SHOVE)
  ((INTEGER.+) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(0.4113636202000026d0 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 1.3424664218360758d0
Size of best individual (points): 97

Average total errors in population: 1.0828017e+7
Median total errors in population: 79.23412230512128d0
Average program size in population (points): 66.2816
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:
((((INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
   CODE.QUOTE QGATE.GATE)
  FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (INTEGER.SWAP (-0.6962908506393433d0 (BOOLEAN.YANKDUP))
                   (CODE.DUP)
                   (INTEGER.-
                    (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                      INTEGER.FROMBOOLEAN))
                    INTEGER.DUP
                    (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH) ((0.3849058151245117d0) QGATE.END)
      QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      QGATE.U-THETA
      ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   INTEGER.SHOVE)
  ((INTEGER.+) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(0.4113636202000026d0 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 1.3424664218360758d0
Size of best individual (points): 96

Average total errors in population: 1.1138017e+7
Median total errors in population: 96.62263514385492d0
Average program size in population (points): 65.7074
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:
((((INTEGER.DUP (FLOAT.* (INTEGER.SWAP (FLOAT.>) (QGATE.GATE)))) CODE.QUOTE
   QGATE.GATE)
  FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (INTEGER.SWAP (-0.6962908506393433d0 (BOOLEAN.YANKDUP))
                   (CODE.DUP)
                   (INTEGER.-
                    (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                      INTEGER.FROMBOOLEAN))
                    INTEGER.DUP
                    (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH FLOAT.FROMBOOLEAN)
      ((0.3849058151245117d0) QGATE.END) QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      QGATE.U-THETA
      ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   INTEGER.SHOVE)
  ((INTEGER.+) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(0.4113636202000026d0 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 1.3424664218360758d0
Size of best individual (points): 97

Average total errors in population: 1.0850016e+7
Median total errors in population: 74.21514900081907d0
Average program size in population (points): 66.4122
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:
((((INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
   CODE.QUOTE QGATE.GATE)
  FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (QGATE.MEASURE (-0.6962908506393433d0 (BOOLEAN.YANKDUP))
                    (CODE.DUP)
                    (INTEGER.-
                     (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                       INTEGER.FROMBOOLEAN))
                     INTEGER.DUP
                     (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH FLOAT.FROMBOOLEAN)
      ((0.3849058151245117d0) QGATE.END) QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      QGATE.U-THETA
      ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   INTEGER.SHOVE)
  ((INTEGER.+) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(0.4113636202000026d0 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 1.3424664218360758d0
Size of best individual (points): 97

Average total errors in population: 1.1046015e+7
Median total errors in population: 74.21514900081907d0
Average program size in population (points): 66.3096
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:
((((INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.=)))) CODE.QUOTE
   QGATE.GATE)
  FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (INTEGER.SWAP (-0.6962908506393433d0 (BOOLEAN.YANKDUP))
                   (CODE.DUP)
                   (INTEGER.-
                    (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                      INTEGER.FROMBOOLEAN))
                    INTEGER.DUP
                    (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH FLOAT.FROMBOOLEAN)
      ((0.3849058151245117d0) QGATE.END) QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      QGATE.U-THETA
      ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   INTEGER.SHOVE)
  ((INTEGER.+) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(0.4113636202000026d0 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 1.3424664218360758d0
Size of best individual (points): 95

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 41
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((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*) NIL)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 98

Average total errors in population: 1.1634014e+7
Median total errors in population: 71.75d0
Average program size in population (points): 64.5604
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 CODE.LIST)
  (((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)
 ((((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.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.37134864754529273d0
                              0.44948438572690697d0)
Total errors for best individual: 0.9465485520457831d0
Size of best individual (points): 100

Average total errors in population: 1.1744013e+7
Median total errors in population: 64.39831531259992d0
Average program size in population (points): 67.1694
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:
(((CODE.YANKDUP INTEGER.YANK)
  (((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))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (BOOLEAN.OR (QGATE.LIMITED-ORACLE) QGATE.QNOT BOOLEAN.DUP)
  QGATE.END QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.12571551877358345d0 0.37134864754529273d0
                              0.44948438572690697d0)
Total errors for best individual: 0.9465485520457831d0
Size of best individual (points): 95

Average total errors in population: 1.243001e+7
Median total errors in population: 62.0d0
Average program size in population (points): 67.925
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:
((((INTEGER.DUP (FLOAT.* (INTEGER.STACKDEPTH (QGATE.STACKDEPTH) (QGATE.GATE))))
   CODE.QUOTE QGATE.GATE)
  FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (QGATE.MEASURE (-0.6962908506393433d0 (FLOAT.STACKDEPTH))
                    (CODE.DUP)
                    (INTEGER.-
                     (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                       INTEGER.FROMBOOLEAN))
                     INTEGER.DUP
                     (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH FLOAT.FROMBOOLEAN)
      ((0.3849058151245117d0) QGATE.END) QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      QGATE.U-THETA
      ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   BOOLEAN.DUP)
  ((INTEGER.STACKDEPTH) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(4.440892098500626d-16 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 0.9311028016360737d0
Size of best individual (points): 97

Average total errors in population: 1.263001e+7
Median total errors in population: 62.0d0
Average program size in population (points): 68.7156
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:
((((CODE.SHOVE CODE.QUOTE QGATE.GATE) CODE.QUOTE QGATE.GATE) FLOAT.STACKDEPTH)
 TRUE
 ((((CODE.SWAP
     (INTEGER.SWAP (INTEGER.DUP -0.6962908506393433d0 (FLOAT.STACKDEPTH))
                   (CODE.DUP)
                   (INTEGER.-
                    (((FLOAT.DUP QGATE.YANKDUP (QGATE.SWP))
                      INTEGER.FROMBOOLEAN))
                    INTEGER.DUP
                    (QGATE.U-THETA FLOAT.-))))
    (((CODE.IF 1) (QGATE.STACKDEPTH FLOAT.FROMBOOLEAN)
      ((0.3849058151245117d0) QGATE.END) QGATE.COMPOSE INTEGER.= CODE.CAR)
     (QGATE.GATE
      (CODE.ATOM
       ((INTEGER.YANK QGATE.YANKDUP
                      QGATE.SWAP
                      FLOAT.SWAP
                      QGATE.GATE
                      QGATE.POP
                      NUMQUBITS
                      QGATE.SHOVE)
        CODE.CDR))
      ((INTEGER.STACKDEPTH) QGATE.GATE BOOLEAN.NOT)
      (QGATE.U-THETA QGATE.END)
      ((NUMQUBITS QGATE.U2) QGATE.SRN FLOAT.SWAP
       (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))))
   INTEGER.SHOVE)
  ((INTEGER.+) FLOAT.-) QGATE.HADAMARD))
Errors for best individual: #(4.440892098500626d-16 0.4635382179240507d0
                              0.4675645837120226d0)
Total errors for best individual: 0.9311028016360737d0
Size of best individual (points): 95

Average total errors in population: 1.1790011e+7
Median total errors in population: 61.99685913570215d0
Average program size in population (points): 69.2446
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 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 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 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.0994014e+7
Median total errors in population: 62.0d0
Average program size in population (points): 66.9568
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 QGATE.SRN CODE.LIST)
  (((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 (CODE.NTHCDR FLOAT.SIN)))
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH)
    ((CODE.POP (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     (QGATE.TRANSPOSE (FLOAT.YANKDUP))))
   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): 100

Average total errors in population: 9676017.0
Median total errors in population: 61.94706947434369d0
Average program size in population (points): 68.0086
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 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.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 BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.12571551877358322d0 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.9224975860666301d0
Size of best individual (points): 96

Average total errors in population: 9826017.0
Median total errors in population: 61.890349095306235d0
Average program size in population (points): 67.9604
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 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.+))))
  NIL 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 BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
Errors for best individual: #(0.12571551877358322d0 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.9224975860666301d0
Size of best individual (points): 95

Average total errors in population: 9814016.0
Median total errors in population: 61.81591236545977d0
Average program size in population (points): 68.9708
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:
(((CODE.LIST QGATE.U-THETA CODE.YANKDUP 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 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: 1.0224016e+7
Median total errors in population: 62.0d0
Average program size in population (points): 68.082
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:
(((CODE.LIST QGATE.U-THETA CODE.YANKDUP 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 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: 9278017.0
Median total errors in population: 61.812679485603674d0
Average program size in population (points): 68.8886
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:
((((INTEGER.SWAP) -1)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((QGATE.LIMITED-ORACLE (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 (CODE.NTHCDR FLOAT.SIN)))
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH)
    ((CODE.CAR (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     ((FLOAT.YANKDUP))))
   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.37634822857960903d0
                              0.42043383871343765d0)
Total errors for best individual: 0.7967820672930468d0
Size of best individual (points): 98

Average total errors in population: 9160018.0
Median total errors in population: 61.85813519395487d0
Average program size in population (points): 68.7642
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:
((((INTEGER.SWAP) -1)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((QGATE.LIMITED-ORACLE (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 (CODE.NTHCDR FLOAT.SIN)))
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH)
    ((CODE.CAR (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     ((FLOAT.YANKDUP))))
   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.37634822857960903d0
                              0.42043383871343765d0)
Total errors for best individual: 0.7967820672930468d0
Size of best individual (points): 98

Average total errors in population: 9092018.0
Median total errors in population: 61.886315362360996d0
Average program size in population (points): 68.0814
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:
((((FLOAT.FROMBOOLEAN) -1)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((QGATE.LIMITED-ORACLE (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 (CODE.NTHCDR FLOAT.SIN)))
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH)
    ((CODE.CAR (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     ((FLOAT.YANKDUP))))
   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.37634822857960903d0
                              0.42043383871343765d0)
Total errors for best individual: 0.7967820672930468d0
Size of best individual (points): 98

Average total errors in population: 8876018.0
Median total errors in population: 61.85813519395487d0
Average program size in population (points): 68.8846
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:
((((FLOAT.FROMBOOLEAN) -1)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((QGATE.LIMITED-ORACLE (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 (CODE.NTHCDR FLOAT.SIN)))
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= CODE.NOOP) (BOOLEAN.STACKDEPTH)
    ((CODE.CAR (QGATE.STACKDEPTH CODE.NOOP (INTEGER.STACKDEPTH) INTEGER.DUP))
     ((FLOAT.YANKDUP))))
   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.37634822857960903d0
                              0.42043383871343765d0)
Total errors for best individual: 0.7967820672930468d0
Size of best individual (points): 98

Average total errors in population: 9184016.0
Median total errors in population: 61.73241967518128d0
Average program size in population (points): 67.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 56
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (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)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35208431036298515d0 0.4297920505501768d0)
Total errors for best individual: 0.7818763609131619d0
Size of best individual (points): 93

Average total errors in population: 9104018.0
Median total errors in population: 61.95332484050471d0
Average program size in population (points): 67.9822
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 INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (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)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35208431036298515d0 0.4297920505501768d0)
Total errors for best individual: 0.7818763609131619d0
Size of best individual (points): 93

Average total errors in population: 8884018.0
Median total errors in population: 61.73241967518128d0
Average program size in population (points): 68.1994
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)
  ((((QGATE.LIMITED-ORACLE NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (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)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (FLOAT.SWAP FLOAT.SIN CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL
   CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35208431036298515d0 0.4297920505501768d0)
Total errors for best individual: 0.7818763609131619d0
Size of best individual (points): 96

Average total errors in population: 8938018.0
Median total errors in population: 61.73241967518128d0
Average program size in population (points): 68.7454
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 INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (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)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.35208431036298515d0 0.4297920505501768d0)
Total errors for best individual: 0.7818763609131619d0
Size of best individual (points): 93

Average total errors in population: 9190018.0
Median total errors in population: 61.886315362360996d0
Average program size in population (points): 68.1108
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 INTEGER.*) (BOOLEAN.= 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)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 (FLOAT.STACKDEPTH CODE.DUP))
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 9006018.0
Median total errors in population: 61.84731584111302d0
Average program size in population (points): 68.6096
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 INTEGER.*) (BOOLEAN.= 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)))
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 (FLOAT.STACKDEPTH CODE.DUP))
Errors for best individual: #(0 0.3503796642644468d0 0.4307988546913225d0)
Total errors for best individual: 0.7811785189557693d0
Size of best individual (points): 95

Average total errors in population: 9246018.0
Median total errors in population: 61.99637823693325d0
Average program size in population (points): 67.134
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 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 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)))
                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34867621652563496d0 0.4322590173820735d0)
Total errors for best individual: 0.7809352339077085d0
Size of best individual (points): 92

Average total errors in population: 9506018.0
Median total errors in population: 61.999976872004375d0
Average program size in population (points): 66.0744
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:
((((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH)) QGATE.CPHASE)
  ((((QGATE.U-THETA NUMQUBITS INTEGER.*) (QGATE.SWAP FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (CODE.NTH FLOAT.STACKDEPTH
                                        (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.POP) FLOAT.SIN FLOAT.TAN)) QGATE.LIMITED-ORACLE) NIL)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(2.220446049250313d-16 0.25995742833740876d0
                              0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 99

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

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

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

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

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

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

Average total errors in population: 8930019.0
Median total errors in population: 61.9620164121563d0
Average program size in population (points): 67.319
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

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

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

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

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

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

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

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

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

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

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

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 70
Best individual:
(((QGATE.HADAMARD FLOAT.DUP (QGATE.STACKDEPTH))
  ((((NUMQUBITS INTEGER.*) (BOOLEAN.OR FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (INTEGER.YANK CODE.NTH
                                            FLOAT.STACKDEPTH
                                            (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% NIL (FLOAT.-))))
   (BOOLEAN.FROMFLOAT) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   NIL)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(3.3306690738754696d-16 0.2598915024628714d0
                              0.39643505848036276d0)
Total errors for best individual: 0.6563265609432345d0
Size of best individual (points): 97

Average total errors in population: 8638023.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.5488
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:
(((QGATE.HADAMARD FLOAT.DUP (QGATE.STACKDEPTH))
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (BOOLEAN.OR FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 ((((FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (INTEGER.YANK CODE.NTH
                                            FLOAT.STACKDEPTH
                                            (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% NIL (FLOAT.-))))
   (BOOLEAN.FROMFLOAT) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   NIL)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(3.3306690738754696d-16 0.2598915024628714d0
                              0.39643505848036276d0)
Total errors for best individual: 0.6563265609432345d0
Size of best individual (points): 97

Average total errors in population: 9186020.0
Median total errors in population: 62.0d0
Average program size in population (points): 66.965
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:
(((QGATE.HADAMARD FLOAT.DUP (QGATE.STACKDEPTH))
  ((((NUMQUBITS INTEGER.*) (BOOLEAN.OR FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (INTEGER.YANK CODE.NTH
                                            FLOAT.STACKDEPTH
                                            (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% NIL (FLOAT.-))))
   (BOOLEAN.FROMFLOAT) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   NIL)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(3.3306690738754696d-16 0.2598915024628714d0
                              0.39643505848036276d0)
Total errors for best individual: 0.6563265609432345d0
Size of best individual (points): 97

Average total errors in population: 8732021.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.826
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:
(((QGATE.HADAMARD FLOAT.DUP (QGATE.STACKDEPTH))
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (BOOLEAN.OR FLOAT.TAN)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (INTEGER.STACKDEPTH BOOLEAN.YANK FLOAT.SIN)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.=
                              (INTEGER.YANK CODE.NTH
                                            FLOAT.STACKDEPTH
                                            (FLOAT.SWAP (CODE.FROMFLOAT)))
                              (CODE.IF)
                              FLOAT.SHOVE)
             (QGATE.QNOT)
             (INTEGER.% NIL (FLOAT.-))))
   (BOOLEAN.FROMFLOAT) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN QGATE.GATE))
    QGATE.LIMITED-ORACLE)
   NIL)
  (BOOLEAN.NOT))
 FLOAT.STACKDEPTH)
Errors for best individual: #(3.3306690738754696d-16 0.2598915024628714d0
                              0.39643505848036276d0)
Total errors for best individual: 0.6563265609432345d0
Size of best individual (points): 98

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

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

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

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

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

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

Average total errors in population: 9624017.0
Median total errors in population: 63.96248414495466d0
Average program size in population (points): 67.3378
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 ((((CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  FLOAT.SHOVE)
                 (QGATE.QNOT)
                 ((FLOAT.-))))
   (BOOLEAN.=) BOOLEAN.OR ((FLOAT./ (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (BOOLEAN.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036276d0)
Total errors for best individual: 0.6563265609432342d0
Size of best individual (points): 94

Average total errors in population: 9882015.0
Median total errors in population: 63.286375008452154d0
Average program size in population (points): 67.3218
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:
(((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
   ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
      ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
     QGATE.LIMITED-ORACLE)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
   (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                      (INTEGER.FROMFLOAT))
     BOOLEAN.= QGATE.GATE))
   CODE.DO* BOOLEAN.POP)
  NUMQUBITS
  ((((CODE.NTHCDR QGATE.GATE
                  (CODE.STACKDEPTH CODE.=
                                   (CODE.NTH CODE.STACKDEPTH
                                             (FLOAT.POP (FLOAT.STACKDEPTH)))
                                   FLOAT.SHOVE)
                  (QGATE.U-THETA)))
    (BOOLEAN.=) FLOAT.STACKDEPTH
    ((CODE.NOOP (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
   (INTEGER.POP))
  FLOAT.STACKDEPTH)
 ((FLOAT.<) QGATE.MEASURE INTEGER.STACKDEPTH
  (QGATE.SHOVE QGATE.GATE FLOAT.SWAP) CODE.FROMFLOAT))
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036265d0)
Total errors for best individual: 0.656326560943234d0
Size of best individual (points): 100

Average total errors in population: 9866016.0
Median total errors in population: 63.45968834066935d0
Average program size in population (points): 67.438
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:
(((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
   ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
      ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
     QGATE.LIMITED-ORACLE)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
   (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                      (INTEGER.FROMFLOAT))
     BOOLEAN.= QGATE.GATE))
   CODE.DO* BOOLEAN.POP)
  NUMQUBITS
  ((((CODE.NTHCDR QGATE.GATE
                  (CODE.STACKDEPTH CODE.=
                                   (CODE.NTH CODE.STACKDEPTH
                                             (FLOAT.POP (FLOAT.STACKDEPTH)))
                                   FLOAT.SHOVE)
                  (QGATE.U-THETA)))
    (BOOLEAN.=) FLOAT.STACKDEPTH
    ((CODE.NOOP (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
   (INTEGER.POP))
  FLOAT.STACKDEPTH)
 ((FLOAT.<) QGATE.MEASURE INTEGER.STACKDEPTH
  (QGATE.SHOVE QGATE.GATE FLOAT.SWAP) CODE.FROMFLOAT))
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036265d0)
Total errors for best individual: 0.656326560943234d0
Size of best individual (points): 100

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

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

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

Average total errors in population: 9724018.0
Median total errors in population: 64.57909634638665d0
Average program size in population (points): 67.8
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:
(((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
   ((((CODE.IF ((FLOAT.-) NUMQUBITS) INTEGER.*)
      ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
     QGATE.LIMITED-ORACLE)
    ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
     (FLOAT.SIN QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
   (((INTEGER.YANKDUP ((FLOAT.SHOVE QGATE.HADAMARD) CODE.DISCREPANCY (8))
                      (INTEGER.FROMFLOAT))
     BOOLEAN.= QGATE.GATE))
   CODE.DO* BOOLEAN.POP)
  NUMQUBITS
  ((((CODE.NTHCDR QGATE.GATE
                  (CODE.STACKDEPTH CODE.=
                                   (CODE.NTH CODE.STACKDEPTH
                                             (FLOAT.POP (FLOAT.STACKDEPTH)))
                                   FLOAT.SHOVE)
                  (QGATE.U-THETA)))
    (BOOLEAN.=) FLOAT.STACKDEPTH
    ((CODE.NOOP (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
   (INTEGER.POP))
  FLOAT.STACKDEPTH)
 ((FLOAT.<) QGATE.MEASURE INTEGER.STACKDEPTH
  (QGATE.SHOVE QGATE.GATE FLOAT.SWAP) CODE.FROMFLOAT))
Errors for best individual: #(0 0.2598915024628714d0 0.39643505848036265d0)
Total errors for best individual: 0.656326560943234d0
Size of best individual (points): 100

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 81
Best individual:
(((FLOAT.TAN NUMQUBITS INTEGER.*)
  (((INTEGER.YANKDUP ((INTEGER.STACKDEPTH QGATE.HADAMARD) CODE.DISCREPANCY (8))
                     (INTEGER.FROMFLOAT))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((CODE.NTHCDR ((INTEGER.STACKDEPTH QGATE.HADAMARD) (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)))
                                       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): 84

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