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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 0
Best individual:
(FLOAT.POP
 ((QGATE.LIMITED-ORACLE (FLOAT.STACKDEPTH)
                        ((FLOAT.SIN) BOOLEAN.NOT QGATE.LIMITED-ORACLE
                         (INTEGER.%) FLOAT.-)
                        CODE.DO)
  CODE.FROMFLOAT
  (CODE.NOOP FLOAT.+
             (QGATE.POP CODE.NTH)
             (FLOAT.%)
             QGATE.SWP
             ((CODE.DO INTEGER.FROMBOOLEAN) QGATE.QNOT (CODE.ATOM FLOAT./)
              CODE.DUP))))
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: 2.925e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 23.2534
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:
(((CODE.FROMFLOAT) BOOLEAN.SHOVE NUMQUBITS) ((CODE.DO* INTEGER.%) FLOAT.SIN)
 ((FLOAT.YANK CODE.APPEND TRUE 4) QGATE.POP
  (((QGATE.TRANSPOSE (CODE.STACKDEPTH ((FLOAT.YANK) FLOAT.POP QGATE.SWAP)))
    CODE.DO*COUNT ((CODE.SHOVE) QGATE.SHOVE) CODE.DO*TIMES BOOLEAN.STACKDEPTH
    QGATE.LIMITED-ORACLE)
   INTEGER.-))
 QGATE.HADAMARD)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 39

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 2
Best individual:
((QGATE.GATE
  ((CODE.STACKDEPTH CODE.DO*COUNT CODE.STACKDEPTH)
   (INTEGER.FROMFLOAT (FLOAT.<)) NUMQUBITS FLOAT.SIN QGATE.LIMITED-ORACLE)
  (FLOAT.FROMINTEGER)
  (QGATE.GATE (INTEGER.FROMBOOLEAN CODE.CDR) QGATE.CPHASE CODE.DISCREPANCY)
  NUMQUBITS
  QGATE.CNOT)
 ((FLOAT.SIN) BOOLEAN.YANKDUP))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 30

Average total errors in population: 2.2650008e+7
Median total errors in population: 3.0e+7
Average program size in population (points): 22.7832
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:
(INTEGER.= INTEGER.SHOVE
           (CODE.DO* BOOLEAN.FROMFLOAT
                     INTEGER.STACKDEPTH
                     QGATE.LIMITED-ORACLE
                     INTEGER.FROMFLOAT)
           ((QGATE.POP) CODE.DO*
            (BOOLEAN.FROMINTEGER (CODE.SHOVE)
                                 (CODE.IF)
                                 CODE.=
                                 QGATE.CPHASE
                                 NUMQUBITS
                                 (BOOLEAN.FROMFLOAT
                                  (CODE.= INTEGER.FROMBOOLEAN
                                          INTEGER.STACKDEPTH
                                          CODE.NOOP)
                                  (INTEGER.SHOVE)
                                  CODE.YANK)))
           (BOOLEAN.SWAP FLOAT./)
           NUMQUBITS)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 36

Average total errors in population: 1.693802e+7
Median total errors in population: 2.0e+7
Average program size in population (points): 28.3602
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:
((FLOAT.DUP ((CODE.QUOTE) CODE.FROMFLOAT)
            (CODE.DO*)
            (QGATE.STACKDEPTH (QGATE.TRANSPOSE) INTEGER.FROMFLOAT QGATE.YANK))
 INTEGER.DUP
 (CODE.NULL BOOLEAN.NOT
            (((CODE.CONS
               ((CODE.FROMBOOLEAN (FLOAT.FROMBOOLEAN))
                ((INTEGER.STACKDEPTH FLOAT.%) CODE.FROMBOOLEAN) INTEGER.-
                (FLOAT.+ (QGATE.U-THETA))
                (QGATE.STACKDEPTH QGATE.STACKDEPTH))))
             QGATE.U-THETA))
 FLOAT.TAN QGATE.U-THETA (CODE.IF QGATE.LIMITED-ORACLE (TRUE INTEGER.-))
 CODE.CDR)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 51

Average total errors in population: 1.3436031e+7
Median total errors in population: 1.0000002999999999d+7
Average program size in population (points): 30.8036
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.POP
 ((QGATE.LIMITED-ORACLE (FLOAT.STACKDEPTH)
                        ((FLOAT.SIN) BOOLEAN.NOT QGATE.LIMITED-ORACLE
                         (INTEGER.%) FLOAT.-)
                        CODE.DO)
  CODE.FROMFLOAT
  (CODE.NOOP FLOAT.+
             (QGATE.POP)
             (FLOAT.%)
             QGATE.SWP
             ((CODE.DO ((QGATE.COMPOSE BOOLEAN.FROMFLOAT) INTEGER.FROMBOOLEAN))
              QGATE.QNOT (CODE.ATOM FLOAT./) CODE.DUP))))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 38

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 6
Best individual:
(FLOAT.< (FLOAT.POP CODE.FROMBOOLEAN FLOAT.SHOVE)
         (NUMQUBITS)
         ((CODE.STACKDEPTH CODE.CDR)
          ((BOOLEAN.YANKDUP (BOOLEAN.FROMFLOAT FLOAT.* BOOLEAN.AND)
                            QGATE.LIMITED-ORACLE)
           BOOLEAN.SWAP FLOAT.DUP)
          FLOAT.>)
         (FLOAT.% CODE.DO*COUNT
                  (FLOAT.YANKDUP CODE.DO*TIMES CODE.YANK (BOOLEAN.=))
                  CODE.QUOTE))
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.2332035e+7
Median total errors in population: 62.0d0
Average program size in population (points): 33.8798
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:
((BOOLEAN.FROMFLOAT NUMQUBITS) (QGATE.LIMITED-ORACLE)
 (BOOLEAN.FROMFLOAT NUMQUBITS)
 (CODE.STACKDEPTH ((BOOLEAN.YANK INTEGER.SHOVE) QGATE.SWAP) CODE.DO*COUNT)
 (CODE.NULL
  (CODE.DO*COUNT BOOLEAN.SWAP
                 (-10 QGATE.U-THETA
                  (((INTEGER.STACKDEPTH) CODE.QUOTE) FLOAT.COS)
                  (QGATE.LIMITED-ORACLE))
                 FLOAT.<)
  QGATE.STACKDEPTH
  QGATE.LIMITED-ORACLE)
 FLOAT.> (INTEGER.SWAP INTEGER.> (FLOAT.SWAP) INTEGER.SWAP (QGATE.SRN))
 (INTEGER.SHOVE CODE.ATOM
                CODE.APPEND
                ((FLOAT.COS) FLOAT.> QGATE.=)
                QGATE.YANKDUP
                INTEGER.FROMFLOAT
                FLOAT.-
                (CODE.SWAP)))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 59

Average total errors in population: 1.1698036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 36.0908
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:
(((NUMQUBITS)) (FLOAT.STACKDEPTH)
 (INTEGER.DUP INTEGER.DUP (BOOLEAN.STACKDEPTH) (QGATE.LIMITED-ORACLE -4))
 QGATE.MEASURE)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 15

Average total errors in population: 1.1840036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 37.5872
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:
(INTEGER.= INTEGER.SHOVE
           (CODE.DO* BOOLEAN.FROMFLOAT
                     INTEGER.STACKDEPTH
                     QGATE.LIMITED-ORACLE
                     INTEGER.FROMFLOAT)
           (((((INTEGER.DUP) INTEGER.+ INTEGER.SWAP) BOOLEAN.NOT) CODE.YANKDUP)
            CODE.DO*
            (INTEGER.+ (NUMQUBITS NUMQUBITS)
                       QGATE.U-THETA
                       (((CODE.STACKDEPTH) CODE.FROMBOOLEAN) (QGATE.GATE)
                        (FLOAT.=
                         ((QGATE.U-THETA) (INTEGER.SWAP) QGATE.STACKDEPTH
                          CODE.SWAP)
                         QGATE.LIMITED-ORACLE)
                        INTEGER.% CODE.DO)
                       (INTEGER.%)))
           (BOOLEAN.FROMINTEGER FLOAT./)
           NUMQUBITS)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 51

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 10
Best individual:
((QGATE.POP QGATE.SWAP) (BOOLEAN.SHOVE CODE.DO*) INTEGER.STACKDEPTH
 (QGATE.LIMITED-ORACLE NUMQUBITS
                       ((QGATE.TRANSPOSE QGATE.STACKDEPTH)
                        QGATE.LIMITED-ORACLE))
 (INTEGER.> ((FLOAT.SHOVE))
            CODE.SHOVE
            (TRUE
             (FLOAT.SIN
              (INTEGER.SWAP
               ((0.8693606853485107d0) BOOLEAN.NOT
                ((INTEGER.=) QGATE.END INTEGER.DUP)))
              BOOLEAN.NOT
              INTEGER.POP))))
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 39

Average total errors in population: 1.1646036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 40.3708
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.DUP BOOLEAN.=
            (CODE.DO*)
            (QGATE.STACKDEPTH NIL INTEGER.FROMFLOAT QGATE.YANK))
 INTEGER.DUP
 ((((CODE.QUOTE INTEGER.DUP) (CODE.IF QGATE.=) FLOAT.COS (QGATE.POP))
   CODE.NULL)
  BOOLEAN.NOT
  (((CODE.CONS
     ((CODE.FROMBOOLEAN (FLOAT.FROMBOOLEAN))
      ((INTEGER.STACKDEPTH INTEGER.YANKDUP) CODE.FROMBOOLEAN) INTEGER.-
      (FLOAT.+ (QGATE.U-THETA)) (QGATE.STACKDEPTH QGATE.STACKDEPTH))))
   QGATE.U-THETA))
 FLOAT.TAN QGATE.U-THETA
 ((CODE.IF QGATE.LIMITED-ORACLE (TRUE INTEGER.-))
  (QGATE.YANKDUP BOOLEAN.FROMINTEGER
                 (((INTEGER.SWAP CODE.CONS) FLOAT.SWAP) QGATE.TRANSPOSE)
                 (INTEGER.> QGATE.SHOVE)
                 FLOAT.<
                 (CODE.FROMFLOAT)))
 CODE.CDR)
Errors for best individual: #(0 3.0d0 59.0d0)
Total errors for best individual: 62.0d0
Size of best individual (points): 75

Average total errors in population: 1.1636036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 42.1542
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.NOOP
  ((CODE.YANKDUP INTEGER.STACKDEPTH
                 (BOOLEAN.DUP
                  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP)
                   BOOLEAN.FROMINTEGER
                   (FLOAT./ FLOAT.SWAP
                            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH)
                             NUMQUBITS
                             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2
                              INTEGER.=))))
                  CODE.STACKDEPTH))
   CODE.DO*TIMES FLOAT.+))
 BOOLEAN.YANK
 ((BOOLEAN.DUP QGATE.DUP CODE.LIST QGATE.CNOT) (FLOAT.SIN CODE.APPEND -3)
  (CODE.DO*COUNT
   ((QGATE.COMPOSE) QGATE.GATE (CODE.DISCREPANCY QGATE.SWAP) QGATE.GATE))
  CODE.DO
  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP) QGATE.U2
   (FLOAT./ FLOAT.SWAP
            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH) NUMQUBITS
             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2 FLOAT.YANKDUP)))))
 QGATE.LIMITED-ORACLE)
Errors for best individual: #(2.220446049250313d-16 2.572750016904307d0 59.0d0)
Total errors for best individual: 61.57275001690431d0
Size of best individual (points): 81

Average total errors in population: 1.0956038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 45.425
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.NOOP
  ((CODE.YANKDUP INTEGER.STACKDEPTH
                 (BOOLEAN.DUP
                  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP)
                   BOOLEAN.FROMINTEGER
                   (FLOAT./ FLOAT.SWAP
                            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH)
                             NUMQUBITS
                             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2
                              INTEGER.=))))
                  CODE.STACKDEPTH))
   CODE.DO*TIMES FLOAT.+))
 BOOLEAN.YANK
 ((BOOLEAN.DUP QGATE.DUP CODE.LIST QGATE.CNOT) (FLOAT.SIN CODE.APPEND -3)
  (CODE.DO*COUNT
   ((QGATE.COMPOSE) QGATE.GATE (CODE.DISCREPANCY QGATE.SWAP) QGATE.GATE))
  CODE.DO
  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP) QGATE.U2
   (FLOAT./ FLOAT.SWAP
            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH) NUMQUBITS
             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2 FLOAT.YANKDUP)))))
 QGATE.LIMITED-ORACLE)
Errors for best individual: #(2.220446049250313d-16 2.572750016904307d0 59.0d0)
Total errors for best individual: 61.57275001690431d0
Size of best individual (points): 81

Average total errors in population: 1.1392037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 46.366
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.NOOP
  ((CODE.YANKDUP INTEGER.STACKDEPTH
                 (BOOLEAN.DUP
                  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP)
                   BOOLEAN.FROMINTEGER
                   (FLOAT./ FLOAT.SWAP
                            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH)
                             NUMQUBITS
                             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2
                              INTEGER.=))))
                  CODE.STACKDEPTH))
   CODE.DO*TIMES FLOAT.+))
 BOOLEAN.YANK
 ((BOOLEAN.DUP QGATE.DUP CODE.LIST QGATE.CNOT) (FLOAT.SIN CODE.APPEND -3)
  (CODE.DO*COUNT
   ((QGATE.COMPOSE) QGATE.GATE (CODE.DISCREPANCY QGATE.SWAP) QGATE.GATE))
  CODE.DO
  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP) QGATE.U2
   (FLOAT./ FLOAT.SWAP
            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH) NUMQUBITS
             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2 FLOAT.YANKDUP)))))
 QGATE.LIMITED-ORACLE)
Errors for best individual: #(2.220446049250313d-16 2.572750016904307d0 59.0d0)
Total errors for best individual: 61.57275001690431d0
Size of best individual (points): 81

Average total errors in population: 1.1568037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 47.6958
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:
((CODE.NOOP
  ((CODE.YANKDUP INTEGER.STACKDEPTH
                 (BOOLEAN.DUP
                  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP)
                   BOOLEAN.FROMINTEGER
                   (FLOAT./ FLOAT.SWAP
                            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH)
                             NUMQUBITS
                             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2
                              INTEGER.=))))
                  CODE.STACKDEPTH))
   CODE.DO*TIMES FLOAT.+))
 BOOLEAN.YANK
 ((BOOLEAN.DUP QGATE.DUP CODE.LIST QGATE.CNOT) (FLOAT.SIN CODE.APPEND -3)
  (CODE.DO*COUNT
   ((QGATE.COMPOSE) QGATE.GATE (CODE.DISCREPANCY QGATE.SWAP) QGATE.GATE))
  CODE.DO
  ((QGATE.END) (INTEGER.STACKDEPTH QGATE.POP) QGATE.U2
   (FLOAT./ FLOAT.SWAP
            ((CODE.= FLOAT.FROMINTEGER) (FLOAT.STACKDEPTH) NUMQUBITS
             (-8 QGATE.U-THETA INTEGER.FROMBOOLEAN 2 FLOAT.YANKDUP)))))
 QGATE.LIMITED-ORACLE)
Errors for best individual: #(2.220446049250313d-16 2.572750016904307d0 59.0d0)
Total errors for best individual: 61.57275001690431d0
Size of best individual (points): 81

Average total errors in population: 1.1332037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 50.1814
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.1949220895767212d0 CODE.DUP)
   (((((((FLOAT.FROMBOOLEAN) BOOLEAN.SHOVE) FLOAT.COS) INTEGER.+)) FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))
   INTEGER.SHOVE)
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(2.690708733652215d0 4.519105061434482d0
                              48.86084665323471d0)
Total errors for best individual: 56.070660448321405d0
Size of best individual (points): 57

Average total errors in population: 1.1618037e+7
Median total errors in population: 62.0d0
Average program size in population (points): 51.7592
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.1949220895767212d0 CODE.DUP)
   (((((((FLOAT.FROMBOOLEAN) BOOLEAN.SHOVE) FLOAT.COS) INTEGER.+)) FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))
   INTEGER.SHOVE)
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(2.690708733652215d0 4.519105061434482d0
                              48.86084665323471d0)
Total errors for best individual: 56.070660448321405d0
Size of best individual (points): 57

Average total errors in population: 1.1112038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 55.762
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.1949220895767212d0 CODE.DUP)
   (((((((FLOAT.FROMBOOLEAN) BOOLEAN.SHOVE) FLOAT.COS) INTEGER.+)) FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR)))
   INTEGER.SHOVE)
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(2.690708733652215d0 4.519105061434482d0
                              48.86084665323471d0)
Total errors for best individual: 56.070660448321405d0
Size of best individual (points): 57

Average total errors in population: 1.0712039e+7
Median total errors in population: 62.0d0
Average program size in population (points): 59.0682
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.1949220895767212d0 CODE.DUP)
   (((((((FLOAT.FROMBOOLEAN) BOOLEAN.SHOVE) FLOAT.COS) INTEGER.+)) FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (BOOLEAN.SWAP (CODE.ATOM CODE.CDR)
                 ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE QGATE.GATE)
                 QGATE.U-THETA
                 ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
                  (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE)
                             CODE.NTHCDR)))
   INTEGER.SHOVE)
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(2.690708733652215d0 4.519105061434482d0
                              48.86084665323471d0)
Total errors for best individual: 56.070660448321405d0
Size of best individual (points): 57

Average total errors in population: 1.0830038e+7
Median total errors in population: 62.0d0
Average program size in population (points): 59.7356
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.1949220895767212d0 CODE.DUP)
   (((((((FLOAT.FROMBOOLEAN) BOOLEAN.SHOVE) FLOAT.COS) INTEGER.+)) FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN CODE.CDR
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR))))
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD)
 CODE.CAR)
Errors for best individual: #(2.690708733652215d0 4.519105061434482d0
                              48.86084665323471d0)
Total errors for best individual: 56.070660448321405d0
Size of best individual (points): 55

Average total errors in population: 1.1894036e+7
Median total errors in population: 62.0d0
Average program size in population (points): 59.6762
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:
(((INTEGER.+) FLOAT./)
 (10 QGATE.COMPOSE (QGATE.GATE (CODE.FROMFLOAT)) (FLOAT.STACKDEPTH))
 ((((BOOLEAN.POP FLOAT.>)
    ((BOOLEAN.POP 0.33808445930480957d0)
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP CODE.LIST))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((QGATE.= QGATE.END) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((-0.9231091737747192d0) BOOLEAN.OR (INTEGER.YANK INTEGER.DUP QGATE.DUP)
     ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) QGATE.COMPOSE) (FLOAT.+))
     (INTEGER.YANKDUP CODE.NULL)
     (QGATE.U-THETA
      ((FALSE) ((NUMQUBITS FLOAT.STACKDEPTH) INTEGER./ CODE.DISCREPANCY))
      QGATE.STACKDEPTH
      ((QGATE.GATE FLOAT.COS (FLOAT.FROMINTEGER)) NUMQUBITS
       QGATE.LIMITED-ORACLE)
      NIL)))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
  (CODE.IF (INTEGER.YANKDUP) QGATE.QNOT BOOLEAN.DUP) BOOLEAN.NOT
  QGATE.LIMITED-ORACLE)
 INTEGER.YANKDUP (FLOAT.POP) BOOLEAN.SHOVE)
Errors for best individual: #(0 0.3869042792905433d0 38.85743476294527d0)
Total errors for best individual: 39.24433904223581d0
Size of best individual (points): 97

Average total errors in population: 1.2106036e+7
Median total errors in population: 63.98130293315678d0
Average program size in population (points): 60.817
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.1949220895767212d0 CODE.DUP)
   ((((((INTEGER.DUP (CODE.FROMINTEGER) FLOAT.FROMBOOLEAN) FLOAT.COS)
       INTEGER.+))
     FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR))))
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(1.6907087336522149d0 4.4845077135914d0
                              8.535330224160703d0)
Total errors for best individual: 14.710546671404318d0
Size of best individual (points): 56

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 23
Best individual:
((((-0.1949220895767212d0 CODE.DUP)
   ((((((INTEGER.DUP (CODE.FROMINTEGER) FLOAT.FROMBOOLEAN) FLOAT.COS)
       INTEGER.+))
     FLOAT.-)
    QGATE.CPHASE))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR))))
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(1.6907087336522149d0 4.4845077135914d0
                              8.535330224160703d0)
Total errors for best individual: 14.710546671404318d0
Size of best individual (points): 55

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 24
Best individual:
((((-0.1949220895767212d0 CODE.DUP)
   ((((((INTEGER.DUP (CODE.FROMINTEGER) FLOAT.FROMBOOLEAN) FLOAT.COS)
       INTEGER.+))
     FLOAT.-)))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE) CODE.NTHCDR))))
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(1.6907087336522149d0 4.4845077135914d0
                              8.535330224160703d0)
Total errors for best individual: 14.710546671404318d0
Size of best individual (points): 54

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 25
Best individual:
((((-0.1949220895767212d0 CODE.DUP)
   ((((((INTEGER.DUP (CODE.FROMINTEGER) FLOAT.FROMBOOLEAN) FLOAT.COS)
       INTEGER.+))
     FLOAT.-)))
  FLOAT.STACKDEPTH)
 TRUE
 ((CODE.FROMBOOLEAN
   (QGATE.GATE (CODE.ATOM CODE.CDR)
               ((INTEGER.STACKDEPTH BOOLEAN.AND) QGATE.GATE)
               QGATE.U-THETA
               ((NUMQUBITS QGATE.U2) QGATE.SRN
                (CODE.SWAP (CODE.DO*COUNT QGATE.LIMITED-ORACLE)
                           QGATE.STACKDEPTH))))
  (NIL (FLOAT.- FLOAT.+)) QGATE.HADAMARD FLOAT.SIN)
 CODE.CAR)
Errors for best individual: #(1.6907087336522149d0 4.4845077135914d0
                              8.535330224160703d0)
Total errors for best individual: 14.710546671404318d0
Size of best individual (points): 54

Average total errors in population: 9676033.0
Median total errors in population: 59.45855584012663d0
Average program size in population (points): 66.0812
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.QNOT CODE.NOOP)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS CODE.NOOP)
              (FLOAT.= QGATE.COMPOSE)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (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) CODE.DO* BOOLEAN.STACKDEPTH)
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) CODE.SHOVE BOOLEAN.DUP)
  BOOLEAN.NOT FLOAT.POP)
 CODE.FROMBOOLEAN FLOAT.* FLOAT.SIN)
Errors for best individual: #(2.622635143854916d0 2.857647701308246d0
                              0.4731620027358141d0)
Total errors for best individual: 5.953444847898975d0
Size of best individual (points): 71

Average total errors in population: 9268030.0
Median total errors in population: 41.04187214610567d0
Average program size in population (points): 67.815
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:
((CODE.STACKDEPTH)
 (10 QGATE.COMPOSE (CODE.CDR (CODE.FROMFLOAT)) (FLOAT.STACKDEPTH))
 ((((BOOLEAN.POP FLOAT.>)
    ((BOOLEAN.POP 0.33808445930480957d0)
     (FLOAT.> QGATE.U-THETA CODE.YANKDUP QGATE.SRN))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((CODE.LIST QGATE.END) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
    ((-0.9231091737747192d0) BOOLEAN.OR (INTEGER.YANK INTEGER.DUP QGATE.DUP)
     ((NUMQUBITS (BOOLEAN.DUP CODE.DO*TIMES) QGATE.COMPOSE) (FLOAT.+))
     (INTEGER.YANKDUP CODE.NULL)
     (QGATE.U-THETA
      ((CODE.NULL) ((NUMQUBITS FLOAT.STACKDEPTH) INTEGER./ CODE.DISCREPANCY))
      QGATE.STACKDEPTH
      ((QGATE.GATE FLOAT.COS (FLOAT.FROMINTEGER)) NUMQUBITS
       QGATE.LIMITED-ORACLE)
      NIL)))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP)
  (CODE.IF (INTEGER.YANKDUP) ((QGATE.U-THETA) QGATE.QNOT) BOOLEAN.DUP)
  BOOLEAN.NOT QGATE.LIMITED-ORACLE)
 INTEGER.YANKDUP (INTEGER.DUP) BOOLEAN.SHOVE)
Errors for best individual: #(2.5d0 2.635976538085345d0 0.4769824035640089d0)
Total errors for best individual: 5.612958941649353d0
Size of best individual (points): 98

Average total errors in population: 9114029.0
Median total errors in population: 39.24433904223581d0
Average program size in population (points): 68.6748
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO*))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS (((CODE.FROMBOOLEAN) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 89

Average total errors in population: 9830028.0
Median total errors in population: 59.55847213624276d0
Average program size in population (points): 66.8664
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           ((((((CODE.DO*COUNT) (QGATE.END)) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO*))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) QGATE.SHOVE)))
Errors for best individual: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 91

Average total errors in population: 1.0358026e+7
Median total errors in population: 61.69505308605287d0
Average program size in population (points): 65.18
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:
(((FALSE CODE.CONS)
  (NIL
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           (((((CODE.DO*COUNT) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO*))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (CODE.DUP))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) CODE.CDR) CODE.DUP))
Errors for best individual: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 88

Average total errors in population: 1.0102024e+7
Median total errors in population: 62.0d0
Average program size in population (points): 64.8764
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:
(((FALSE CODE.CONS)
  ((QGATE.COMPOSE)
   (((QGATE.GATE QGATE.CPHASE (FLOAT.FROMINTEGER)) NUMQUBITS
     QGATE.LIMITED-ORACLE)
    (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER (QGATE.POP) BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD INTEGER.-))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (QGATE.YANK (CODE.APPEND)
               (BOOLEAN.STACKDEPTH)
               ((NUMQUBITS QGATE.U-THETA
                           ((((((CODE.DO*COUNT) (QGATE.END)) FLOAT.SIN
                               (CODE.= (BOOLEAN.DUP) CODE.DO*))
                              INTEGER.< BOOLEAN.AND)
                             NUMQUBITS)))
                (INTEGER.DUP
                 (FLOAT.* (INTEGER.STACKDEPTH (FLOAT.>) (QGATE.GATE))))
                QGATE.POP))
   QGATE.LIMITED-ORACLE)
  FLOAT.YANK CODE.DISCREPANCY)
 NUMQUBITS (((QGATE.STACKDEPTH) (BOOLEAN.NOT) QGATE.SHOVE)))
Errors for best individual: #(0 2.980085143325183d0 0.4295625126782303d0)
Total errors for best individual: 3.4096476560034135d0
Size of best individual (points): 91

Average total errors in population: 1.0304022e+7
Median total errors in population: 64.38004429039553d0
Average program size in population (points): 63.7036
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:
(((CODE.= 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.*)
    (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) CODE.DO* BOOLEAN.STACKDEPTH)
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP BOOLEAN.NOT CODE.CDR)
 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): 66

Average total errors in population: 1.0244022e+7
Median total errors in population: 65.0d0
Average program size in population (points): 64.3634
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:
((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) CODE.DO* BOOLEAN.STACKDEPTH)
    CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
   INTEGER.DUP (CODE.IF 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): 74

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 34
Best individual:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (CODE.DO*COUNT) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN
                    (INTEGER.+ NIL CODE.DO* BOOLEAN.FROMINTEGER))
                   INTEGER.< (BOOLEAN.AND (FLOAT.< FLOAT.<)))
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 81

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 35
Best individual:
((QGATE.HADAMARD
  ((CODE.DISCREPANCY (CODE.DO*COUNT) -1)
   ((TRUE) (FALSE CODE.CONS)
    ((FLOAT.FROMINTEGER BOOLEAN.STACKDEPTH FLOAT./) (INTEGER.>)
     (INTEGER.YANKDUP NUMQUBITS) BOOLEAN.STACKDEPTH)
    QGATE.HADAMARD QGATE.LIMITED-ORACLE))
  ((QGATE.GATE (CODE.QUOTE) FLOAT.%)
   (-0.7562001943588257d0 (CODE.APPEND) (BOOLEAN.STACKDEPTH)
    ((NUMQUBITS QGATE.U-THETA
                (((((CODE.DO*COUNT) FLOAT.SIN
                    (INTEGER.+ NIL CODE.DO* BOOLEAN.FROMINTEGER))
                   INTEGER.< (BOOLEAN.AND (FLOAT.< FLOAT.<)))
                  NUMQUBITS)))
     (INTEGER.DUP
      ((FLOAT.* (INTEGER.STACKDEPTH NIL (QGATE.GATE))) (FLOAT.COS QGATE.U2)))
     QGATE.POP))
   QGATE.LIMITED-ORACLE)
  -7
  CODE.DISCREPANCY)
 NUMQUBITS)
Errors for best individual: #(4.440892098500626d-16 2.529181377272293d0
                              0.39688603295421954d0)
Total errors for best individual: 2.926067410226513d0
Size of best individual (points): 81

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

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

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

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

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

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

Average total errors in population: 1.1140018e+7
Median total errors in population: 74.75d0
Average program size in population (points): 59.2408
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:
(QGATE.U-THETA
 ((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
   (((INTEGER.SWAP NUMQUBITS ((INTEGER.=) 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))
     CODE.FROMINTEGER QGATE.GATE)
    (QGATE.GATE))
   CODE.DO* BOOLEAN.STACKDEPTH)
  ((QGATE.SHOVE QGATE.=) (BOOLEAN.STACKDEPTH) QGATE.SHOVE
   ((FLOAT.FROMBOOLEAN) ((QGATE.YANKDUP (CODE.CONS QGATE.COMPOSE)))))
  CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND CODE.SWAP))
Errors for best individual: #(0.14443366266224666d0 0.44049307150365713d0
                              0.3807259812196515d0)
Total errors for best individual: 0.9656527153855553d0
Size of best individual (points): 76

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 43
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (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.1568018e+7
Median total errors in population: 110.0d0
Average program size in population (points): 60.2342
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

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

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

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

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

Average total errors in population: 1.2046015e+7
Median total errors in population: 113.49957386042037d0
Average program size in population (points): 61.6262
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:
((((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.2084014e+7
Median total errors in population: 107.5d0
Average program size in population (points): 62.3186
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 47
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((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.U-THETA CODE.YANKDUP INTEGER.+)))
  ((((INTEGER.FROMFLOAT CODE.LIST)
     (INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT)) NIL))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 ((QGATE.SHOVE (CODE.QUOTE) 0.609594464302063d0) (BOOLEAN.STACKDEPTH)
  QGATE.SHOVE ((QGATE.YANKDUP (CODE.CONS QGATE.SWAP))))
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.SWAP)
Errors for best individual: #(0 0.44087596265687523d0 0.3758018502166701d0)
Total errors for best individual: 0.8166778128735454d0
Size of best individual (points): 73

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 48
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((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.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (CODE.STACKDEPTH))
                     (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*) (NUMQUBITS))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((QGATE.HADAMARD) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0.14443366266224644d0 0.353713750003519d0
                              0.43119762262032735d0)
Total errors for best individual: 0.9293450352860928d0
Size of best individual (points): 98

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 49
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (NUMQUBITS))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 (((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.14616333959286143d0 0.35208431036298515d0
                              0.4297920505501768d0)
Total errors for best individual: 0.9280397005060234d0
Size of best individual (points): 96

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 50
Best individual:
(((FLOAT.SIN FLOAT.FROMBOOLEAN (QGATE.U2))
  (((INTEGER.SWAP NUMQUBITS CODE.DISCREPANCY) (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) FLOAT./))
     (QGATE.TRANSPOSE (CODE.NULL BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) FLOAT.FROMINTEGER BOOLEAN.DUP) -7
  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: 1.2600012e+7
Median total errors in population: 105.69529102903859d0
Average program size in population (points): 62.6354
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 51
Best individual:
(((FLOAT.SIN FLOAT.FROMBOOLEAN (QGATE.U2))
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.=)
    ((INTEGER.DUP) FLOAT.FROMINTEGER
     (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   (((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)
 (((NIL
    ((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 FLOAT./ (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.2402013e+7
Median total errors in population: 72.19830535604038d0
Average program size in population (points): 64.489
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 52
Best individual:
(((FLOAT.SIN FLOAT.FROMBOOLEAN)
  (((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.> 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): 93

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 53
Best individual:
(((FLOAT.SIN FLOAT.FROMBOOLEAN (QGATE.U2))
  (((INTEGER.SWAP NUMQUBITS CODE.DISCREPANCY) (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) FLOAT./))
     (QGATE.TRANSPOSE (CODE.NULL BOOLEAN.DUP))))
   CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND)
  INTEGER.DUP (CODE.IF (QGATE.LIMITED-ORACLE) FLOAT.FROMINTEGER BOOLEAN.DUP) -7
  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: 9456017.0
Median total errors in population: 61.96248414495466d0
Average program size in population (points): 68.4408
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 54
Best individual:
((((-0.1949220895767212d0 CODE.SHOVE) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.=)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    5 QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (QGATE.DUP (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0.14443366266224644d0 0.3618678543385595d0
                              0.39790901547246715d0)
Total errors for best individual: 0.9042105324732731d0
Size of best individual (points): 98

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 55
Best individual:
((((-0.1949220895767212d0 CODE.SHOVE) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.=)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    5 QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (QGATE.DUP (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0.14443366266224644d0 0.3618678543385595d0
                              0.39790901547246715d0)
Total errors for best individual: 0.9042105324732731d0
Size of best individual (points): 97

Average total errors in population: 9514016.0
Median total errors in population: 61.9620164121563d0
Average program size in population (points): 67.6904
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.SHOVE) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS INTEGER.*)
              (FLOAT.=)
              ((INTEGER.DUP) FLOAT.FROMINTEGER
               (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.QNOT))
                     (INTEGER.FROMFLOAT))
    5 QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((QGATE.SHOVE
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (QGATE.TRANSPOSE)))
                                       (FLOAT.YANKDUP)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      (QGATE.DUP (CODE.DO*) (FLOAT.-))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS ((BOOLEAN.FROMFLOAT) FLOAT.SIN CODE.DO*TIMES))
    QGATE.LIMITED-ORACLE)
   NIL CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0.14443366266224644d0 0.3618678543385595d0
                              0.39790901547246715d0)
Total errors for best individual: 0.9042105324732731d0
Size of best individual (points): 98

Average total errors in population: 9364017.0
Median total errors in population: 61.893963484406044d0
Average program size in population (points): 67.2782
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:
(((CODE.NTHCDR FLOAT.SIN)
  (((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)
 ((((FLOAT.>) ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((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)
  QGATE.DUP (CODE.IF (FLOAT.-) 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): 94

Average total errors in population: 9446016.0
Median total errors in population: 61.85813519395487d0
Average program size in population (points): 67.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 58
Best individual:
(((FLOAT.SIN FLOAT.FROMBOOLEAN)
  (((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)
 ((((FLOAT.>)
    ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA FLOAT.YANK 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 NIL QGATE.QNOT BOOLEAN.DUP) BOOLEAN.NOT
  QGATE.LIMITED-ORACLE)
 CODE.FROMBOOLEAN QGATE.LIMITED-ORACLE CODE.APPEND FLOAT.=)
Errors for best individual: #(1.1102230246251565d-16 0.3763482285796089d0
                              0.420433838713438d0)
Total errors for best individual: 0.796782067293047d0
Size of best individual (points): 97

Average total errors in population: 9060016.0
Median total errors in population: 61.62096296748091d0
Average program size in population (points): 68.5172
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:
(((FLOAT.SIN FLOAT.FROMBOOLEAN)
  (((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)
 ((((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: #(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: 9102017.0
Median total errors in population: 61.76480752982544d0
Average program size in population (points): 68.0146
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:
(((CODE.NTHCDR FLOAT.SIN)
  (((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)
 ((((FLOAT.>) ((0.33808445930480957d0) (FLOAT.> QGATE.U-THETA CODE.YANKDUP))
    (QGATE.GATE) CODE.DO* BOOLEAN.STACKDEPTH)
   ((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)
  QGATE.DUP (CODE.IF (FLOAT.-) 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): 94

Average total errors in population: 8858018.0
Median total errors in population: 61.6209629674809d0
Average program size in population (points): 68.7634
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:
(((FLOAT.SIN QGATE.SWP)
  (((INTEGER.SWAP NUMQUBITS INTEGER.*) NIL
    ((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)
 ((((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.SWAP 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): 97

Average total errors in population: 8718018.0
Median total errors in population: 61.588452892795054d0
Average program size in population (points): 68.7884
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)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS CODE.NOOP)
              (FLOAT.= QGATE.COMPOSE)
              (((INTEGER.DUP (FLOAT.* QGATE.LIMITED-ORACLE))) 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 (BOOLEAN.STACKDEPTH))
                     (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.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       BOOLEAN.SHOVE)
                      (QGATE.QNOT)
                      (INTEGER.% (CODE.DO*) NIL)))
   FLOAT.STACKDEPTH
   ((NUMQUBITS ((QGATE.SWAP) INTEGER.< CODE.DO*TIMES)) QGATE.LIMITED-ORACLE)
   FLOAT.+ CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.353713750003519d0 0.43119762262032735d0)
Total errors for best individual: 0.7849113726238464d0
Size of best individual (points): 99

Average total errors in population: 8984018.0
Median total errors in population: 61.73241967518128d0
Average program size in population (points): 68.1914
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 63
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((BOOLEAN.= (INTEGER.SWAP NUMQUBITS CODE.NOOP)
              (FLOAT.= QGATE.COMPOSE)
              (((INTEGER.DUP (FLOAT.* QGATE.LIMITED-ORACLE))) 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 (BOOLEAN.STACKDEPTH))
                     (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.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       BOOLEAN.SHOVE)
                      (QGATE.QNOT)
                      (INTEGER.% (CODE.DO*) NIL)))
   FLOAT.STACKDEPTH
   ((((QGATE.SWAP) INTEGER.< CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) FLOAT.+
   CODE.IF)
  (QGATE.SWP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.353713750003519d0 0.43119762262032735d0)
Total errors for best individual: 0.7849113726238464d0
Size of best individual (points): 98

Average total errors in population: 8898017.0
Median total errors in population: 61.57269660686039d0
Average program size in population (points): 68.883
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

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

Average total errors in population: 9258017.0
Median total errors in population: 61.893963484406044d0
Average program size in population (points): 67.8266
Number of ERC variables: 0
Number of RAND-generated variables: 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

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

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

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

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

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 67
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     (((INTEGER.DUP) (FLOAT.TAN)) 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 (NIL FLOAT.SIN CODE.ATOM)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34867569853796543d0 0.43225946067628596d0)
Total errors for best individual: 0.7809351592142514d0
Size of best individual (points): 99

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 68
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     (((INTEGER.DUP) (FLOAT.TAN)) 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 (NIL FLOAT.SIN CODE.ATOM)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34867569853796543d0 0.43225946067628596d0)
Total errors for best individual: 0.7809351592142514d0
Size of best individual (points): 99

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 69
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     (((INTEGER.DUP) (FLOAT.TAN)) 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 (CODE.STACKDEPTH FLOAT.SIN CODE.ATOM)) QGATE.LIMITED-ORACLE) NIL
   CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34867569853796543d0 0.43225946067628596d0)
Total errors for best individual: 0.7809351592142514d0
Size of best individual (points): 99

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 70
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.SIN FLOAT.TAN)
     (((INTEGER.DUP) (FLOAT.TAN)) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 NUMQUBITS
 (((QGATE.U-THETA
    (FLOAT.STACKDEPTH QGATE.GATE
                      (CODE.STACKDEPTH CODE.=
                                       (INTEGER.YANK CODE.NTH
                                                     CODE.STACKDEPTH
                                                     (FLOAT.POP
                                                      (FLOAT.STACKDEPTH)))
                                       (CODE.IF)
                                       FLOAT.SHOVE)
                      (QGATE.QNOT)
                      ((CODE.FROMFLOAT))))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL FLOAT.SIN CODE.ATOM)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34867569853796543d0 0.43225946067628596d0)
Total errors for best individual: 0.7809351592142514d0
Size of best individual (points): 99

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 71
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.TAN)
     (((INTEGER.DUP) (FLOAT.TAN)) 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.=) QGATE.TRANSPOSE
   ((NUMQUBITS (CODE.STACKDEPTH FLOAT.SIN CODE.ATOM)) QGATE.LIMITED-ORACLE) NIL
   CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34689222742754167d0 0.43378317086823315d0)
Total errors for best individual: 0.7806753982957748d0
Size of best individual (points): 98

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

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; -*- Report at generation 72
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP NUMQUBITS INTEGER.*) (FLOAT.TAN)
     (((INTEGER.DUP) (FLOAT.TAN)) 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.=) QGATE.TRANSPOSE
   ((NUMQUBITS (CODE.STACKDEPTH FLOAT.SIN CODE.ATOM)) QGATE.LIMITED-ORACLE) NIL
   CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.34689222742754167d0 0.43378317086823315d0)
Total errors for best individual: 0.7806753982957748d0
Size of best individual (points): 98

Average total errors in population: 9044020.0
Median total errors in population: 62.0d0
Average program size in population (points): 68.222
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 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 CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.= (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): 91

Average total errors in population: 8790019.0
Median total errors in population: 61.961525653687545d0
Average program size in population (points): 68.8314
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:
((((QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH)) QGATE.CPHASE)
  ((((BOOLEAN.AND NUMQUBITS INTEGER.*) (FLOAT.SWAP)
     ((INTEGER.DUP) FLOAT.FROMINTEGER
      (-0.9021610021591187d0 INTEGER.FROMFLOAT)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (QGATE.STACKDEPTH))
                     (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.STACKDEPTH)
 NUMQUBITS
 (((FLOAT.*
    (FLOAT.= QGATE.GATE
             (CODE.STACKDEPTH CODE.= (INTEGER.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): 91

Average total errors in population: 8884017.0
Median total errors in population: 61.96103361042615d0
Average program size in population (points): 67.9712
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)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.*)
    (QGATE.DUP QGATE.U-THETA CODE.YANKDUP INTEGER.+)))
  (((INTEGER.YANKDUP (QGATE.HADAMARD CODE.DISCREPANCY (8)) (INTEGER.FROMFLOAT))
    BOOLEAN.= QGATE.GATE)
   (QGATE.GATE))
  CODE.DO* BOOLEAN.POP)
 INTEGER.STACKDEPTH
 (((QGATE.U-THETA
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  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.259957428337409d0 0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 93

Average total errors in population: 8514018.0
Median total errors in population: 61.96103361042615d0
Average program size in population (points): 68.969
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)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL CODE.IF)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #(0 0.259957428337409d0 0.4295625126782303d0)
Total errors for best individual: 0.6895199410156393d0
Size of best individual (points): 99

Average total errors in population: 8582018.0
Median total errors in population: 61.96051701038171d0
Average program size in population (points): 68.7314
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)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (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): 99

Average total errors in population: 9042018.0
Median total errors in population: 61.980085143325184d0
Average program size in population (points): 67.6152
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)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (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): 99

Average total errors in population: 9262019.0
Median total errors in population: 62.0d0
Average program size in population (points): 66.5138
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)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (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): 99

Average total errors in population: 8928020.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.335
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)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (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): 99

Average total errors in population: 9122020.0
Median total errors in population: 62.0d0
Average program size in population (points): 66.1756
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:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (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): 99

Average total errors in population: 9262021.0
Median total errors in population: 62.0d0
Average program size in population (points): 66.2344
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 82
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((QGATE.END (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): 99

Average total errors in population: 9402019.0
Median total errors in population: 62.0d0
Average program size in population (points): 66.7208
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 83
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH)
                                  (FLOAT.SHOVE
                                   (FLOAT.% CODE.NULL (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH ((NUMQUBITS) 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): 92

Average total errors in population: 9196018.0
Median total errors in population: 62.0d0
Average program size in population (points): 67.2882
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 84
Best individual:
((((-0.1949220895767212d0 CODE.DUP) QGATE.CPHASE)
  ((((INTEGER.SWAP ((FLOAT.-) NUMQUBITS) INTEGER.*)
     ((INTEGER.DUP) FLOAT.FROMINTEGER (FLOAT.> INTEGER.STACKDEPTH QGATE.END)))
    QGATE.LIMITED-ORACLE)
   ((CODE.YANK (INTEGER.STACKDEPTH) FLOAT.SIN)
    (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
    (CODE.NTHCDR QGATE.GATE
                 (CODE.STACKDEPTH CODE.=
                                  (CODE.NTH CODE.STACKDEPTH
                                            (FLOAT.POP (FLOAT.STACKDEPTH)))
                                  (FLOAT.SHOVE
                                   (FLOAT.% QGATE.LIMITED-ORACLE
                                            (CODE.DO* FLOAT.<))))
                 (QGATE.QNOT)
                 (INTEGER.FROMFLOAT)))
   (BOOLEAN.=) FLOAT.STACKDEPTH
   ((NUMQUBITS (NIL CODE.DO*TIMES)) QGATE.LIMITED-ORACLE) NIL QGATE.MEASURE)
  (INTEGER.POP))
 FLOAT.STACKDEPTH)
Errors for best individual: #