diff --git a/cpp/nth-prime/nth_prime.cpp b/cpp/nth-prime/nth_prime.cpp
index 323f606..213a72a 100644
--- a/cpp/nth-prime/nth_prime.cpp
+++ b/cpp/nth-prime/nth_prime.cpp
@@ -37,17 +37,7 @@ number_t nth(size_t n, size_t sieve_size)
 
     sieve[0] = true;
 
-    number_t first_number = 1;
-
-    auto create_next = [&first_number](number_t p) -> number_t {
-
-        return (p*p - first_number)/2;
-    };
-
-    transform(primes.cbegin(), primes.cend(), next.begin(), create_next);
-
-    for (auto p : primes)
-        sieve[(p - first_number) / 2] = true;
+    number_t sieve_first = 1;
 
     auto process_prime = [sieve_size,&sieve](const number_t &p, number_t &next) {
 
@@ -61,22 +51,22 @@ number_t nth(size_t n, size_t sieve_size)
         next = i - sieve_size;
     };
 
+    auto create_next = [&sieve_first](number_t p) -> number_t {
+
+        return (p*p - sieve_first)/2;
+    };
+
+    transform(primes.cbegin(), primes.cend(), next.begin(), create_next);
+
+    for (auto p : primes)
+        sieve[(p - sieve_first) / 2] = true;
+
 
     while (true) {
 
         for (size_t pn = 0; pn < primes.size(); ++pn) {
 
-            const number_t &p = primes[pn];
-
-            number_t i = next[pn];
-
-            for (; i < sieve_size; i += p) {
-
-                sieve[i] = true;
-            }
-
-            next[pn] = i - sieve_size;
-//            process_prime(primes[pn], next[pn]);
+            process_prime(primes[pn], next[pn]);
         }
 
         for (size_t i = 0; i < sieve_size; ++i) {
@@ -84,33 +74,27 @@ number_t nth(size_t n, size_t sieve_size)
             if (sieve[i])
                 continue;
 
-            number_t p = first_number + 2*i;
+            number_t p = sieve_first + 2*i;
         
             primes.push_back(p);
 
             if (primes.size() == n - 1)
                 return p;
 
-            next[primes.size() - 1] = create_next(p);//(p*p - first_number)/2;
+            size_t pn = primes.size() - 1;
 
+            next[pn] = create_next(p);
             sieve[i] = true;
 
-            number_t j = next[primes.size() - 1];
-
-            for (; j < sieve_size; j += p) {
-
-                sieve[j] = true;
-            }
-
-            next[primes.size() - 1] = j - sieve_size;
+            process_prime(primes[pn], next[pn]);
         }
 
-        number_t next_first_number = first_number + 2*sieve_size;
+        number_t next_sieve_first = sieve_first + 2*sieve_size;
 
-        if (next_first_number < first_number)
+        if (next_sieve_first < sieve_first)
             throw runtime_error("failed to reach prime number");
 
-        first_number = next_first_number;
+        sieve_first = next_sieve_first;
         memset(&sieve[0], false, sieve.size()*sizeof(sieve[0]));
     }
 }