diff --git a/src/is_prime.rs b/src/is_prime.rs
index d28e564..5605445 100644
--- a/src/is_prime.rs
+++ b/src/is_prime.rs
@@ -7,8 +7,8 @@ pub mod prime_utils {
     }
 
     #[must_use]
-    pub fn is_prime(number: &BigUint, g_primes: &[BigUint]) -> bool {
-        if BigUint::from(1u8) == *number {
+    pub fn is_prime(number: &BigUint) -> bool {
+        if BigUint::one() == *number {
             return false;
         }
         if BigUint::from(4u8) > *number {
@@ -27,12 +27,6 @@ pub mod prime_utils {
 
             let sqrtnum = number.sqrt() + &one; //fake ceil function
 
-            for prime in g_primes.iter().filter(|p| p < &&sqrtnum) {
-                if number % prime == ZERO {
-                    return false;
-                }
-            }
-
             loop {
                 i += &one;
                 if number % &i == ZERO {
diff --git a/src/main.rs b/src/main.rs
index c8598b8..6967713 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -56,7 +56,6 @@ const N: i64 = 1_000_000;
 const NF: f64 = N as f64;
 const NU: usize = N as usize;
 const THREADS: usize = 30;
-const SPLITTER: u64 = N as u64 / THREADS as u64;
 
 fn worker(
     workloads: usize,
@@ -68,53 +67,24 @@ fn worker(
     #[cfg(target_os = "windows")]
     try_set_thread_priority();
 
-    static INC: once_cell::sync::Lazy<BigUint> = Lazy::new(BigUint::one);
-    static ONE_THOUSAND: once_cell::sync::Lazy<BigUint> =
-        Lazy::new(|| BigUint::from(SPLITTER * 10));
-    static ONE_HUNDRED: once_cell::sync::Lazy<BigUint> = Lazy::new(|| BigUint::from(SPLITTER));
-    static TEN: once_cell::sync::Lazy<BigUint> = Lazy::new(|| BigUint::from(10u8));
-
     let work_uint = BigUint::from(workloads);
     let mut number = BigUint::from(i) * &work_uint;
 
     let max = BigUint::from(i + 1) * work_uint;
     let mut primecache = Vec::with_capacity(NU);
-    let mut primecache_outside_len = 0;
-    let mut global_primes = arcclone.read().unwrap();
     loop {
-        number += &*INC;
+        number += &BigUint::one();
 
-        if prime_utils::is_prime(&number, &global_primes) {
+        if prime_utils::is_prime(&number) {
             primecache.push(number.clone());
             progress.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         }
-
-        if (&number * &*ONE_THOUSAND) / &max / &*TEN == &number / &max * &*ONE_HUNDRED {
-            drop(global_primes);
-
-            let mut new_primecache = arcclone.write().unwrap();
-
-            new_primecache.extend_from_slice(&primecache[primecache_outside_len..]);
-            new_primecache.sort_unstable();
-
-            primecache.clone_from(&new_primecache);
-            primecache_outside_len = new_primecache.len();
-
-            drop(new_primecache);
-
-            global_primes = arcclone.read().unwrap();
-        }
         if number == max {
             break;
         }
     }
 
-    drop(global_primes);
-
-    let mut new_primecache = arcclone.write().unwrap();
-
-    new_primecache.extend_from_slice(&primecache[primecache_outside_len..]);
-    new_primecache.sort_unstable();
+    arcclone.write().unwrap().append(&mut primecache);
 
     threads_done.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
 }
@@ -180,7 +150,7 @@ fn main() {
         let mut number = BigUint::from(THREADS) * BigUint::from(workloads);
         loop {
             number += &*INC;
-            if prime_utils::is_prime(&number, &primes) {
+            if prime_utils::is_prime(&number) {
                 primes.push(number.clone());
             }
             if primes.len() == NU {