diff --git a/apps/egraphGP/Main.hs b/apps/egraphGP/Main.hs
--- a/apps/egraphGP/Main.hs
+++ b/apps/egraphGP/Main.hs
@@ -179,7 +179,7 @@
          do runEqSat myCost rewriteBasic2 1
             cleanDB
             pure ()
-       let radius' = if b then (min 20 $ radius+1) else (max 1 $ radius-1)
+       let radius' = if b then (max 1 $ min (200 `div` maxSize) (radius+1)) else (max 1 $ radius-1)
            nEvs'    = nEvs + if upd then 1 else 0
        pure (radius', nEvs')
   eclasses <- gets (IntMap.toList . _eClass)
@@ -235,15 +235,17 @@
 
     getParetoEcsUpTo n = concat <$> (forM [1..maxSize] $ \i -> getBestEcsOfSize  i n)
 
-    getBestEcsOfSize i n = do
-      ecs <- getTopECLassWithSize i n
-      Prelude.mapM canonical (Prelude.take n ecs)
+    getBestEcsOfSize i n = getTopECLassWithSize i n
+      --do
+      --ecs <- getTopECLassWithSize i n
+      --Prelude.mapM canonical ecs -- (Prelude.take n ecs)
 
-    getBestEcs p n = do
-      ecs  <- getTopECLassThat n p
+    getBestEcs p n = getTopECLassThat n p
+     --do
+      --ecs  <- getTopECLassThat n p
       --fits <- Prelude.mapM getFitness ecs
       --let sorted = sort $ Prelude.zip (Prelude.map (fmap negate) fits) ecs
-      Prelude.mapM canonical (Prelude.take n ecs)
+      --Prelude.mapM canonical (Prelude.take n ecs)
 
     randomChildFrom ec maxL = do
       p <- rnd toss -- whether to go deeper or return this level
diff --git a/src/Algorithm/EqSat/Queries.hs b/src/Algorithm/EqSat/Queries.hs
--- a/src/Algorithm/EqSat/Queries.hs
+++ b/src/Algorithm/EqSat/Queries.hs
@@ -76,17 +76,12 @@
                                               else go m bests t
 getTopECLassWithSize :: Monad m => Int -> Int -> EGraphST m [EClassId]
 getTopECLassWithSize sz n = do
-  gets ((IntMap.!? sz) . _sizeFitDB . _eDB)
-    >>= go n []
+  go n [] <$> gets ((IntMap.!? sz) . _sizeFitDB . _eDB)
+    >>= mapM canonical
   where
-    go :: Monad m => Int -> [EClassId] -> Maybe (RangeTree Double) -> EGraphST m [EClassId]
-    go _ bests Nothing   = pure []
-    go 0 bests (Just rt) = pure bests
+    -- go :: Monad m => Int -> [EClassId] -> Maybe (RangeTree Double) -> EGraphST m [EClassId]
+    go _ bests Nothing   = []
+    go 0 bests (Just rt) = bests
     go m bests (Just rt) = case rt of
-                             Empty   -> pure bests
-                             t :|> y -> do let x = snd y
-                                           ecId <- canonical x
-                                           ec <- gets ((IntMap.! ecId) . _eClass)
-                                           if (isInfinite . fromJust . _fitness . _info $ ec)
-                                             then pure bests
-                                             else go (m-1) (x:bests) (Just t)
+                             Empty   -> bests
+                             t :|> (f, x) -> if isInfinite f then bests else go (m-1) (x:bests) (Just t)
diff --git a/srtree.cabal b/srtree.cabal
--- a/srtree.cabal
+++ b/srtree.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           srtree
-version:        2.0.0.1
+version:        2.0.0.2
 synopsis:       A general library to work with Symbolic Regression expression trees.
 description:    A Symbolic Regression Tree data structure to work with mathematical expressions with support to first order derivative and simplification;
 category:       Math, Data, Data Structures
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -72,7 +72,7 @@
 -- we must relabel the parameters of the expression to sequence values
 --gradVals :: [(Double, [Double])]
 gradVals = map (M.toList . snd . forwardModeUnique xs' thetaSingle err . relabelParams) exprs
-gradVals' = map (M.toList . snd . reverseModeUnique xs' thetaSingle err . relabelParams) exprs
+--gradVals' = map (M.toList . snd . reverseModeUnique xs' thetaSingle err . relabelParams) exprs
 
 -- values of the evaluated expressions
 --exprVals :: [Double]
@@ -88,7 +88,7 @@
 tests = TestList $
      zipWith (testDiff "forward mode" "autodiff x forward mode") autoDiffMult forwardVals
   <> zipWith (testDiff "forward mode" "autodiff x forward mode unique") autoDiffSingle gradVals
-  <> zipWith (testDiff "reverse mode" "autodiff x reverse mode unique") autoDiffSingle gradVals'
+  -- <> zipWith (testDiff "reverse mode" "autodiff x reverse mode unique") autoDiffSingle gradVals'
 
 main :: IO ()
 main = do