diff --git a/satore/README.md b/satore/README.md
index f22af7b..bf32cbb 100644
--- a/satore/README.md
+++ b/satore/README.md
@@ -49,3 +49,24 @@ The .p file is assumed to be a standalone file with only comments and
 parentheses. All axioms must be included. (This will likely be improved soon.)
 
 Note that `racket -l- satore` can be invoked from anywhere.
+
+## Results on TPTP 7.2.0 (corrected)
+
+Corrected results on TPTP 7.2.0, on a 2-2.5GHz CPU, with a limit of 5 minutes
+and 32GB per problem, either with the default settings, or with
+`--no-discover-online` to disable atom rewriting.
+
+```
+┌────────────────────────────┬───────┬───────┬───────┬───────┬───────┬────────┐
+│Strategy                    │   UEQ │   CNE │   CEQ │   FNE │   FEQ │    All │
+│                 Class size→│  1092 │  2212 │  4436 │  1784 │  5860 │  15384 │
+├────────────────────────────┼───────┼───────┼───────┼───────┼───────┼────────┤
+│Satore               (all)  │   177 │  1140 │   956 │   822 │  1324 │   4419 │
+│                    (proof) │   177 │  1078 │   952 │   766 │  1324 │   4297 │
+│                     (sat)  │     0 │    62 │     4 │    56 │     0 │    122 │
+├────────────────────────────┼───────┼───────┼───────┼───────┼───────┼────────┤
+│Satore w/o atom rw   (all)  │   128 │   967 │   674 │   711 │   843 │   3323 │
+│                    (proof) │   128 │   913 │   670 │   658 │   843 │   3212 │
+│                     (sat)  │     0 │    54 │     4 │    53 │     0 │    111 │
+└────────────────────────────┴───────┴───────┴───────┴───────┴───────┴────────┘
+```
diff --git a/satore/saturation.rkt b/satore/saturation.rkt
index 3a30de3..5491ea4 100644
--- a/satore/saturation.rkt
+++ b/satore/saturation.rkt
@@ -212,8 +212,12 @@
 ;; Cs : (listof Clause?)
 ;; cost-type: symbol?
 ;; parent : Clause?
+;; cost-depth-factor : number?
 ;; -> void?
-(define (Clauses-calculate-cost! Cs cost-type parent)
+(define (Clauses-calculate-cost! Cs
+                                 cost-type
+                                 parent
+                                 #:! cost-depth-factor)
   (case cost-type
     ;; Very simple cost function that uses the weight of the Clause. May not be fair.
     [(weight)
@@ -229,7 +233,7 @@
        (set-Clause-cost! C
          (if (empty? (Clause-clause C))
              -inf.0 ; empty clause should always be top of the list
-             (+ (* (Clause-depth C) (*cost-depth-factor*))
+             (+ (* (Clause-depth C) cost-depth-factor)
                 (Clause-size C)))))])
 
   ;; Add noise to the cost so as to potentially solve more later.
@@ -333,10 +337,12 @@
       (set-Clause-candidate?! C #true)
       (enqueue! priority C)))
 
+  (define cost-depth-factor (*cost-depth-factor*)) ; immutable value
+
   (define (add-candidates! parent Cs)
     ;; Calculate costs and add to candidate heap.
     (unless (empty? Cs)
-      (Clauses-calculate-cost! Cs cost-type parent)
+      (Clauses-calculate-cost! Cs cost-type parent #:cost-depth-factor cost-depth-factor)
 
       (for ([C (in-list Cs)])
         (set-Clause-candidate?! C #true))