diff --git a/include/opencl.h b/include/opencl.h
index 9d9a726ba..38dc88e08 100644
--- a/include/opencl.h
+++ b/include/opencl.h
@@ -43,6 +43,32 @@ typedef enum vendor_id
 
 } vendor_id_t;
 
+typedef enum status_rc
+{
+   STATUS_INIT            = 0,
+   STATUS_AUTOTUNE        = 1,
+   STATUS_RUNNING         = 2,
+   STATUS_PAUSED          = 3,
+   STATUS_EXHAUSTED       = 4,
+   STATUS_CRACKED         = 5,
+   STATUS_ABORTED         = 6,
+   STATUS_QUIT            = 7,
+   STATUS_BYPASS          = 8,
+
+} status_rc_t;
+
+static const char ST_0000[] = "Initializing";
+static const char ST_0001[] = "Autotuning";
+static const char ST_0002[] = "Running";
+static const char ST_0003[] = "Paused";
+static const char ST_0004[] = "Exhausted";
+static const char ST_0005[] = "Cracked";
+static const char ST_0006[] = "Aborted";
+static const char ST_0007[] = "Quit";
+static const char ST_0008[] = "Bypass";
+
+char *strstatus (const uint devices_status);
+
 void load_kernel (const char *kernel_file, int num_devices, size_t *kernel_lengths, const u8 **kernel_sources);
 void writeProgramBin (char *dst, u8 *binary, size_t binary_size);
 
diff --git a/include/restore.h b/include/restore.h
index 9491e880a..fe8f553fa 100644
--- a/include/restore.h
+++ b/include/restore.h
@@ -41,8 +41,6 @@ void write_restore (opencl_ctx_t *opencl_ctx, const char *new_restore_file, rest
 
 void cycle_restore (opencl_ctx_t *opencl_ctx);
 
-void check_checkpoint (opencl_ctx_t *opencl_ctx);
-
 void stop_at_checkpoint (opencl_ctx_t *opencl_ctx);
 
 #endif // _RESTORE_H
diff --git a/include/status.h b/include/status.h
index 9f6c60ab8..f58079fca 100644
--- a/include/status.h
+++ b/include/status.h
@@ -13,22 +13,6 @@
 #define STATUS_TIMER      10
 #define MACHINE_READABLE  0
 
-typedef enum status_rc
-{
-   STATUS_STARTING           = 0,
-   STATUS_INIT               = 1,
-   STATUS_RUNNING            = 2,
-   STATUS_PAUSED             = 3,
-   STATUS_EXHAUSTED          = 4,
-   STATUS_CRACKED            = 5,
-   STATUS_ABORTED            = 6,
-   STATUS_QUIT               = 7,
-   STATUS_BYPASS             = 8,
-   STATUS_STOP_AT_CHECKPOINT = 9,
-   STATUS_AUTOTUNE           = 10
-
-} status_rc_t;
-
 double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries);
 
 void status_display_machine_readable (opencl_ctx_t *opencl_ctx, const hashes_t *hashes);
diff --git a/include/thread.h b/include/thread.h
index 82f1eb9f7..5831bd8b1 100644
--- a/include/thread.h
+++ b/include/thread.h
@@ -62,12 +62,12 @@ void hc_signal (void (callback) (int));
 
 #endif
 
+void mycracked (opencl_ctx_t *opencl_ctx);
 void myabort (opencl_ctx_t *opencl_ctx);
 void myquit (opencl_ctx_t *opencl_ctx);
+void bypass (opencl_ctx_t *opencl_ctx);
 
 void SuspendThreads (opencl_ctx_t *opencl_ctx);
 void ResumeThreads (opencl_ctx_t *opencl_ctx);
 
-void bypass (opencl_ctx_t *opencl_ctx);
-
 #endif // _THREAD_H
diff --git a/include/types.h b/include/types.h
index d420103a9..8e3c16fc4 100644
--- a/include/types.h
+++ b/include/types.h
@@ -493,6 +493,12 @@ typedef struct
 
   hc_device_param_t  *devices_param;
 
+  bool                run_main_level1;
+  bool                run_main_level2;
+  bool                run_main_level3;
+  bool                run_thread_level1;
+  bool                run_thread_level2;
+
   u32                 devices_status;
 
   u32                 opencl_platforms_filter;
@@ -940,8 +946,6 @@ typedef struct
 
   restore_data_t *rd;
 
-  u64     checkpoint_cur_words;     // used for the "stop at next checkpoint" feature
-
   /**
    * status, timer
    */
diff --git a/src/dispatch.c b/src/dispatch.c
index 82319cae0..ecc0089fe 100644
--- a/src/dispatch.c
+++ b/src/dispatch.c
@@ -128,7 +128,7 @@ void *thread_calc_stdin (void *p)
 
   const uint attack_kern = data.attack_kern;
 
-  while ((opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
+  while (opencl_ctx->run_thread_level1 == true)
   {
     hc_thread_mutex_lock (mux_dispatcher);
 
@@ -198,18 +198,12 @@ void *thread_calc_stdin (void *p)
 
       words_cur++;
 
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+      while (opencl_ctx->run_thread_level1 == false) break;
     }
 
     hc_thread_mutex_unlock (mux_dispatcher);
 
-    if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-    if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-    if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-    if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+    while (opencl_ctx->run_thread_level1 == false) break;
 
     // flush
 
@@ -261,7 +255,7 @@ void *thread_calc (void *p)
 
   if (attack_mode == ATTACK_MODE_BF)
   {
-    while ((opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
+    while (opencl_ctx->run_thread_level1 == true)
     {
       const uint work = get_work (device_param, -1u);
 
@@ -288,12 +282,7 @@ void *thread_calc (void *p)
         */
       }
 
-      if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+      if (opencl_ctx->run_thread_level1 == false) break;
 
       if (data.benchmark == 1) break;
 
@@ -373,7 +362,7 @@ void *thread_calc (void *p)
 
     u64 words_cur = 0;
 
-    while ((opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
+    while (opencl_ctx->run_thread_level1 == true)
     {
       u64 words_off = 0;
       u64 words_fin = 0;
@@ -463,28 +452,13 @@ void *thread_calc (void *p)
 
           pw_add (device_param, (u8 *) line_buf, line_len);
 
-          if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-          if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-          if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-          if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-          if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+          if (opencl_ctx->run_thread_level1 == false) break;
         }
 
-        if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-        if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-        if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-        if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-        if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+        if (opencl_ctx->run_thread_level1 == false) break;
       }
 
-      if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+      if (opencl_ctx->run_thread_level1 == false) break;
 
       //
       // flush
@@ -513,12 +487,7 @@ void *thread_calc (void *p)
         */
       }
 
-      if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+      if (opencl_ctx->run_thread_level1 == false) break;
 
       if (words_fin == 0) break;
 
diff --git a/src/hash_management.c b/src/hash_management.c
index 871a3e27f..96c4331e3 100644
--- a/src/hash_management.c
+++ b/src/hash_management.c
@@ -568,7 +568,7 @@ int check_cracked (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, ha
         }
       }
 
-      if (hashes->salts_done == hashes->salts_cnt) opencl_ctx->devices_status = STATUS_CRACKED;
+      if (hashes->salts_done == hashes->salts_cnt) mycracked (opencl_ctx);
 
       check_hash (opencl_ctx, device_param, &cracked[i]);
     }
@@ -1422,7 +1422,7 @@ int hashes_init_stage2 (hashes_t *hashes, const hashconfig_t *hashconfig, opencl
       salts_done++;
     }
 
-    if (salts_done == salts_cnt) opencl_ctx->devices_status = STATUS_CRACKED;
+    if (salts_done == salts_cnt) mycracked (opencl_ctx);
   }
 
   myfree (hashes->digests_buf);
diff --git a/src/hashcat.c b/src/hashcat.c
index b54386c7e..3458d5bda 100644
--- a/src/hashcat.c
+++ b/src/hashcat.c
@@ -847,13 +847,13 @@ int main (int argc, char **argv)
 
   if (opencl_info)
   {
-    quiet = 1;
-    gpu_temp_disable = 1;
-    potfile_disable = 1;
-    restore_disable = 1;
-    markov_disable = 1;
-    logfile_disable = 1;
-    stdout_flag = 1;
+    quiet             = 1;
+    gpu_temp_disable  = 1;
+    potfile_disable   = 1;
+    restore_disable   = 1;
+    markov_disable    = 1;
+    logfile_disable   = 1;
+    //stdout_flag       = 1;
   }
 
   /**
@@ -1304,6 +1304,13 @@ int main (int argc, char **argv)
     opencl_vector_width   = 1;
   }
 
+  if (opencl_info == true)
+  {
+    opencl_platforms    = NULL;
+    opencl_devices      = NULL;
+    opencl_device_types = mystrdup ("1,2,3");
+  }
+
   if (remove_timer_chgd == 1)
   {
     if (remove == 0)
@@ -1584,7 +1591,6 @@ int main (int argc, char **argv)
   data.veracrypt_pim           = veracrypt_pim;
   data.scrypt_tmto             = scrypt_tmto;
 
-
   /**
    * cpu affinity
    */
@@ -1716,16 +1722,12 @@ int main (int argc, char **argv)
 
   data.opencl_ctx = opencl_ctx;
 
-  if (opencl_info)
-  {
-    opencl_platforms = NULL;
-    opencl_devices = NULL;
-    opencl_device_types = strdup("1,2,3");
-  }
+  const int rc_opencl_init = opencl_ctx_init (opencl_ctx, opencl_platforms, opencl_devices, opencl_device_types, opencl_vector_width, opencl_vector_width_chgd, nvidia_spin_damp, nvidia_spin_damp_chgd, workload_profile, kernel_accel, kernel_accel_chgd, kernel_loops, kernel_loops_chgd, keyspace, stdout_flag);
 
-  if (opencl_ctx_init (opencl_ctx, opencl_platforms, opencl_devices, opencl_device_types, opencl_vector_width, opencl_vector_width_chgd, nvidia_spin_damp, nvidia_spin_damp_chgd, workload_profile, kernel_accel, kernel_accel_chgd, kernel_loops, kernel_loops_chgd, keyspace, stdout_flag) != 0)
+  if (rc_opencl_init == -1)
   {
-    log_error ("ERROR: opencl_ctx_init() failed.");
+    log_error ("ERROR: opencl_ctx_init() failed");
+
     return -1;
   }
 
@@ -1829,6 +1831,14 @@ int main (int argc, char **argv)
 
   for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
   {
+    opencl_ctx->devices_status = STATUS_INIT;
+
+    //opencl_ctx->run_main_level1   = true;
+    opencl_ctx->run_main_level2   = true;
+    opencl_ctx->run_main_level3   = true;
+    opencl_ctx->run_thread_level1 = true;
+    opencl_ctx->run_thread_level2 = true;
+
     /*
      * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
      * the following algos are skipped entirely
@@ -1982,7 +1992,6 @@ int main (int argc, char **argv)
 
     hashconfig_general_defaults (hashconfig, hashes, optional_param1);
 
-
     if (hashes->salts_cnt == 1)
       hashconfig->opti_type |= OPTI_TYPE_SINGLE_SALT;
 
@@ -3866,11 +3875,6 @@ int main (int argc, char **argv)
      * status and monitor threads
      */
 
-    if ((opencl_ctx->devices_status != STATUS_BYPASS) && (opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
-    {
-      opencl_ctx->devices_status = STATUS_STARTING;
-    }
-
     uint inner_threads_cnt = 0;
 
     hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
@@ -3891,9 +3895,9 @@ int main (int argc, char **argv)
       {
         if (data.outfile_check_directory != NULL)
         {
-          if ((hashconfig->hash_mode != 5200) &&
-              !((hashconfig->hash_mode >=  6200) && (hashconfig->hash_mode <=  6299)) &&
-              !((hashconfig->hash_mode >= 13700) && (hashconfig->hash_mode <= 13799)) &&
+          if ((hashconfig->hash_mode !=  5200) &&
+            !((hashconfig->hash_mode >=  6200) && (hashconfig->hash_mode <=  6299)) &&
+            !((hashconfig->hash_mode >= 13700) && (hashconfig->hash_mode <= 13799)) &&
               (hashconfig->hash_mode != 9000))
           {
             hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
@@ -3940,9 +3944,11 @@ int main (int argc, char **argv)
 
     for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
     {
-      if (opencl_ctx->devices_status == STATUS_CRACKED) continue;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) continue;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    continue;
+      //opencl_ctx->run_main_level1   = true;
+      //opencl_ctx->run_main_level2   = true;
+      opencl_ctx->run_main_level3   = true;
+      opencl_ctx->run_thread_level1 = true;
+      opencl_ctx->run_thread_level2 = true;
 
       if (maskpos > rd->maskpos)
       {
@@ -4244,9 +4250,13 @@ int main (int argc, char **argv)
 
       for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
       {
-        if (opencl_ctx->devices_status == STATUS_CRACKED) continue;
-        if (opencl_ctx->devices_status == STATUS_ABORTED) continue;
-        if (opencl_ctx->devices_status == STATUS_QUIT)    continue;
+        if (opencl_ctx->run_main_level3 == false) break;
+
+        //opencl_ctx->run_main_level1   = true;
+        //opencl_ctx->run_main_level2   = true;
+        //opencl_ctx->run_main_level3   = true;
+        opencl_ctx->run_thread_level1 = true;
+        opencl_ctx->run_thread_level2 = true;
 
         rd->dictpos = dictpos;
 
@@ -4256,11 +4266,6 @@ int main (int argc, char **argv)
 
         logfile_sub_msg ("START");
 
-        if ((opencl_ctx->devices_status != STATUS_BYPASS) && (opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
-        {
-          opencl_ctx->devices_status = STATUS_INIT;
-        }
-
         memset (data.words_progress_done,     0, hashes->salts_cnt * sizeof (u64));
         memset (data.words_progress_rejected, 0, hashes->salts_cnt * sizeof (u64));
         memset (data.words_progress_restored, 0, hashes->salts_cnt * sizeof (u64));
@@ -4819,10 +4824,7 @@ int main (int argc, char **argv)
 
         hc_thread_t *c_threads = (hc_thread_t *) mycalloc (opencl_ctx->devices_cnt, sizeof (hc_thread_t));
 
-        if ((opencl_ctx->devices_status != STATUS_BYPASS) && (opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
-        {
-          opencl_ctx->devices_status = STATUS_AUTOTUNE;
-        }
+        opencl_ctx->devices_status = STATUS_AUTOTUNE;
 
         for (uint device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
         {
@@ -4876,10 +4878,7 @@ int main (int argc, char **argv)
          * create cracker threads
          */
 
-        if ((opencl_ctx->devices_status != STATUS_BYPASS) && (opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
-        {
-          opencl_ctx->devices_status = STATUS_RUNNING;
-        }
+        opencl_ctx->devices_status = STATUS_RUNNING;
 
         if (initial_restore_done == 0)
         {
@@ -4929,7 +4928,10 @@ int main (int argc, char **argv)
 
         local_free (c_threads);
 
-        if ((opencl_ctx->devices_status != STATUS_BYPASS) && (opencl_ctx->devices_status != STATUS_CRACKED) && (opencl_ctx->devices_status != STATUS_ABORTED) && (opencl_ctx->devices_status != STATUS_QUIT))
+        if ((opencl_ctx->devices_status != STATUS_CRACKED)
+         && (opencl_ctx->devices_status != STATUS_ABORTED)
+         && (opencl_ctx->devices_status != STATUS_QUIT)
+         && (opencl_ctx->devices_status != STATUS_BYPASS))
         {
           opencl_ctx->devices_status = STATUS_EXHAUSTED;
         }
@@ -5015,33 +5017,12 @@ int main (int argc, char **argv)
 
         global_free (subid);
 
-        // from this point we handle bypass as running
-
-        if (opencl_ctx->devices_status == STATUS_BYPASS)
-        {
-          opencl_ctx->devices_status = STATUS_RUNNING;
-        }
-
-        // and overwrite benchmark aborts as well
-
-        if (data.benchmark == 1)
-        {
-          if (opencl_ctx->devices_status == STATUS_ABORTED)
-          {
-            opencl_ctx->devices_status = STATUS_RUNNING;
-          }
-        }
-
         // finalize task
 
-        if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-        if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-        if (opencl_ctx->devices_status == STATUS_QUIT)    break;
+        if (opencl_ctx->run_main_level3 == false) break;
       }
 
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
+      if (opencl_ctx->run_main_level2 == false) break;
     }
 
     // problems could occur if already at startup everything was cracked (because of .pot file reading etc), we must set some variables here to avoid NULL pointers
@@ -5288,6 +5269,8 @@ int main (int argc, char **argv)
     }
     #endif // HAVE_HWMON
 
+    if (opencl_ctx->run_main_level1 == false) break;
+
     // free memory
 
     opencl_session_destroy (opencl_ctx);
@@ -5329,8 +5312,6 @@ int main (int argc, char **argv)
     local_free (nvml_power_limit);
     #endif
 
-    opencl_ctx_devices_destroy (opencl_ctx);
-
     global_free (kernel_rules_buf);
 
     global_free (root_css_buf);
@@ -5341,8 +5322,6 @@ int main (int argc, char **argv)
     global_free (words_progress_done);
     global_free (words_progress_rejected);
     global_free (words_progress_restored);
-
-    if (opencl_ctx->devices_status == STATUS_QUIT) break;
   }
 
   // wait for outer threads
@@ -5443,11 +5422,10 @@ int main (int argc, char **argv)
 
   u32 rc_final = -1;
 
-  if (opencl_ctx->devices_status == STATUS_ABORTED)            rc_final = 2;
-  if (opencl_ctx->devices_status == STATUS_QUIT)               rc_final = 2;
-  if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) rc_final = 2;
-  if (opencl_ctx->devices_status == STATUS_EXHAUSTED)          rc_final = 1;
-  if (opencl_ctx->devices_status == STATUS_CRACKED)            rc_final = 0;
+  if (opencl_ctx->devices_status == STATUS_ABORTED)   rc_final = 2;
+  if (opencl_ctx->devices_status == STATUS_QUIT)      rc_final = 2;
+  if (opencl_ctx->devices_status == STATUS_EXHAUSTED) rc_final = 1;
+  if (opencl_ctx->devices_status == STATUS_CRACKED)   rc_final = 0;
 
   opencl_ctx_destroy (opencl_ctx);
 
diff --git a/src/monitor.c b/src/monitor.c
index 42d530aed..39fe5d1d5 100644
--- a/src/monitor.c
+++ b/src/monitor.c
@@ -117,7 +117,7 @@ void *thread_monitor (void *p)
   {
     hc_sleep (sleep_time);
 
-    if (opencl_ctx->devices_status != STATUS_RUNNING) continue;
+    if (opencl_ctx->devices_status == STATUS_INIT) continue;
 
     #if defined (HAVE_HWMON)
 
@@ -205,7 +205,7 @@ void *thread_monitor (void *p)
         {
           log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
 
-          if (opencl_ctx->devices_status != STATUS_QUIT) myabort (opencl_ctx);
+          myabort (opencl_ctx);
 
           break;
         }
@@ -321,7 +321,7 @@ void *thread_monitor (void *p)
           if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
         }
 
-        if (opencl_ctx->devices_status != STATUS_QUIT) myabort (opencl_ctx);
+        myabort (opencl_ctx);
       }
     }
 
diff --git a/src/opencl.c b/src/opencl.c
index 016aeae85..dff67a115 100644
--- a/src/opencl.c
+++ b/src/opencl.c
@@ -17,6 +17,7 @@
 #include "cpu_md5.h"
 #include "interface.h"
 #include "tuningdb.h"
+#include "thread.h"
 #include "opencl.h"
 #include "hwmon.h"
 #include "restore.h"
@@ -45,6 +46,24 @@ extern hc_thread_mutex_t mux_hwmon;
 
 extern const int comptime;
 
+char *strstatus (const uint devices_status)
+{
+  switch (devices_status)
+  {
+    case  STATUS_INIT:      return ((char *) ST_0000);
+    case  STATUS_AUTOTUNE:  return ((char *) ST_0001);
+    case  STATUS_RUNNING:   return ((char *) ST_0002);
+    case  STATUS_PAUSED:    return ((char *) ST_0003);
+    case  STATUS_EXHAUSTED: return ((char *) ST_0004);
+    case  STATUS_CRACKED:   return ((char *) ST_0005);
+    case  STATUS_ABORTED:   return ((char *) ST_0006);
+    case  STATUS_QUIT:      return ((char *) ST_0007);
+    case  STATUS_BYPASS:    return ((char *) ST_0008);
+  }
+
+  return ((char *) "Uninitialized! Bug!");
+}
+
 static uint setup_opencl_platforms_filter (const char *opencl_platforms)
 {
   uint opencl_platforms_filter = 0;
@@ -318,10 +337,7 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, ha
 
       run_kernel (KERN_RUN_2, opencl_ctx, device_param, pws_cnt, true, slow_iteration, hashconfig);
 
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
+      while (opencl_ctx->run_thread_level2 == false) break;
 
       /**
        * speed
@@ -343,7 +359,7 @@ int choose_kernel (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, ha
 
       if (data.benchmark == 1)
       {
-        if (speed_ms > 4096) opencl_ctx->devices_status = STATUS_ABORTED;
+        if (speed_ms > 4096) myabort (opencl_ctx);
       }
     }
 
@@ -979,31 +995,12 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
                    + device_param->kernel_params_mp_l_buf32[5];
   }
 
-  // iteration type
-
-  uint innerloop_step = 0;
-  uint innerloop_cnt  = 0;
-
-  if      (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)   innerloop_step = device_param->kernel_loops;
-  else                                                             innerloop_step = 1;
-
-  if      (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt  = data.kernel_rules_cnt;
-  else if (data.attack_kern == ATTACK_KERN_COMBI)    innerloop_cnt  = data.combs_cnt;
-  else if (data.attack_kern == ATTACK_KERN_BF)       innerloop_cnt  = data.bfs_cnt;
-
   // loop start: most outer loop = salt iteration, then innerloops (if multi)
 
   for (uint salt_pos = 0; salt_pos < hashes->salts_cnt; salt_pos++)
   {
     while (opencl_ctx->devices_status == STATUS_PAUSED) hc_sleep (1);
 
-    if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-    if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-    if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-    if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-    if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
-
     salt_t *salt_buf = &hashes->salts_buf[salt_pos];
 
     device_param->kernel_params_buf32[27] = salt_pos;
@@ -1017,19 +1014,24 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
       rewind (combs_fp);
     }
 
+    // iteration type
+
+    uint innerloop_step = 0;
+    uint innerloop_cnt  = 0;
+
+    if   (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
+    else                                                        innerloop_step = 1;
+
+    if      (data.attack_kern == ATTACK_KERN_STRAIGHT)  innerloop_cnt  = data.kernel_rules_cnt;
+    else if (data.attack_kern == ATTACK_KERN_COMBI)     innerloop_cnt  = data.combs_cnt;
+    else if (data.attack_kern == ATTACK_KERN_BF)        innerloop_cnt  = data.bfs_cnt;
+
     // innerloops
 
     for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
     {
       while (opencl_ctx->devices_status == STATUS_PAUSED) hc_sleep (1);
 
-      if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
-
       uint fast_iteration = 0;
 
       uint innerloop_left = innerloop_cnt - innerloop_pos;
@@ -1236,13 +1238,6 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
 
       if (rc == -1) return -1;
 
-      if (opencl_ctx->devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (opencl_ctx);
-
-      if (opencl_ctx->devices_status == STATUS_CRACKED) break;
-      if (opencl_ctx->devices_status == STATUS_ABORTED) break;
-      if (opencl_ctx->devices_status == STATUS_QUIT)    break;
-      if (opencl_ctx->devices_status == STATUS_BYPASS)  break;
-
       /**
        * result
        */
@@ -1296,7 +1291,11 @@ int run_cracker (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param, hash
        */
 
       if (data.benchmark == 1) break;
+
+      if (opencl_ctx->run_thread_level2 == false) break;
     }
+
+    if (opencl_ctx->run_thread_level2 == false) break;
   }
 
   device_param->speed_pos = speed_pos;
@@ -1315,6 +1314,12 @@ int opencl_ctx_init (opencl_ctx_t *opencl_ctx, const char *opencl_platforms, con
     return 0;
   }
 
+  opencl_ctx->devices_status            = STATUS_INIT;
+  opencl_ctx->run_main_level1           = true;
+  opencl_ctx->run_main_level2           = true;
+  opencl_ctx->run_main_level3           = true;
+  opencl_ctx->run_thread_level1         = true;
+  opencl_ctx->run_thread_level2         = true;
   opencl_ctx->opencl_vector_width_chgd  = opencl_vector_width_chgd;
   opencl_ctx->opencl_vector_width       = opencl_vector_width;
   opencl_ctx->nvidia_spin_damp_chgd     = nvidia_spin_damp_chgd;
@@ -1519,8 +1524,9 @@ int opencl_ctx_devices_init (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashc
 
   u32 devices_active = 0;
 
-  if (opencl_info) {
-    fprintf(stdout, "OpenCL Info:\n");
+  if (opencl_info)
+  {
+    fprintf (stdout, "OpenCL Info:\n");
   }
 
   for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
diff --git a/src/outfile_check.c b/src/outfile_check.c
index 29ea1af86..51aa5c074 100644
--- a/src/outfile_check.c
+++ b/src/outfile_check.c
@@ -29,6 +29,7 @@
 #include "status.h"
 #include "convert.h"
 #include "shared.h"
+#include "thread.h"
 #include "outfile_check.h"
 
 extern hc_global_data_t data;
@@ -280,7 +281,7 @@ void *thread_outfile_remove (void *p)
 
                             hashes->salts_done++;
 
-                            if (hashes->salts_done == hashes->salts_cnt) opencl_ctx->devices_status = STATUS_CRACKED;
+                            if (hashes->salts_done == hashes->salts_cnt) mycracked (opencl_ctx);
                           }
                         }
                       }
diff --git a/src/restore.c b/src/restore.c
index 9a5a41b83..b2a7a85f4 100644
--- a/src/restore.c
+++ b/src/restore.c
@@ -303,25 +303,8 @@ void cycle_restore (opencl_ctx_t *opencl_ctx)
   }
 }
 
-void check_checkpoint (opencl_ctx_t *opencl_ctx)
-{
-  // if (data.restore_disable == 1) break;  (this is already implied by previous checks)
-
-  u64 words_cur = get_lowest_words_done (opencl_ctx);
-
-  if (words_cur != data.checkpoint_cur_words)
-  {
-    myabort (opencl_ctx);
-  }
-}
-
 void stop_at_checkpoint (opencl_ctx_t *opencl_ctx)
 {
-  if (opencl_ctx->devices_status != STATUS_STOP_AT_CHECKPOINT)
-  {
-    if (opencl_ctx->devices_status != STATUS_RUNNING) return;
-  }
-
   // this feature only makes sense if --restore-disable was not specified
 
   if (data.restore_disable == 1)
@@ -331,25 +314,25 @@ void stop_at_checkpoint (opencl_ctx_t *opencl_ctx)
     return;
   }
 
-  // check if monitoring of Restore Point updates should be enabled or disabled
+  if (opencl_ctx->devices_status != STATUS_RUNNING) return;
 
-  if (opencl_ctx->devices_status != STATUS_STOP_AT_CHECKPOINT)
+  if ((opencl_ctx->run_thread_level1 == true) && (opencl_ctx->run_thread_level2 == true))
   {
-    opencl_ctx->devices_status = STATUS_STOP_AT_CHECKPOINT;
-
-    // save the current restore point value
-
-    data.checkpoint_cur_words = get_lowest_words_done (opencl_ctx);
+    opencl_ctx->run_main_level1   = false;
+    opencl_ctx->run_main_level2   = false;
+    opencl_ctx->run_main_level3   = false;
+    opencl_ctx->run_thread_level1 = false;
+    opencl_ctx->run_thread_level2 = true;
 
     log_info ("Checkpoint enabled: Will quit at next Restore Point update");
   }
   else
   {
-    opencl_ctx->devices_status = STATUS_RUNNING;
-
-    // reset the global value for checkpoint checks
-
-    data.checkpoint_cur_words = 0;
+    opencl_ctx->run_main_level1   = true;
+    opencl_ctx->run_main_level2   = true;
+    opencl_ctx->run_main_level3   = true;
+    opencl_ctx->run_thread_level1 = true;
+    opencl_ctx->run_thread_level2 = true;
 
     log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
   }
diff --git a/src/status.c b/src/status.c
index dc3bf7d61..c0d90f1bd 100644
--- a/src/status.c
+++ b/src/status.c
@@ -30,18 +30,6 @@
 #include "data.h"
 #include "status.h"
 
-static const char ST_0000[] = "Initializing";
-static const char ST_0001[] = "Starting";
-static const char ST_0002[] = "Running";
-static const char ST_0003[] = "Paused";
-static const char ST_0004[] = "Exhausted";
-static const char ST_0005[] = "Cracked";
-static const char ST_0006[] = "Aborted";
-static const char ST_0007[] = "Quit";
-static const char ST_0008[] = "Bypass";
-static const char ST_0009[] = "Running (stop at checkpoint)";
-static const char ST_0010[] = "Autotuning";
-
 extern hc_global_data_t  data;
 extern hc_thread_mutex_t mux_hwmon;
 
@@ -123,26 +111,6 @@ static void format_speed_display (double val, char *buf, size_t len)
   }
 }
 
-static char *strstatus (const uint devices_status)
-{
-  switch (devices_status)
-  {
-    case  STATUS_INIT:               return ((char *) ST_0000);
-    case  STATUS_STARTING:           return ((char *) ST_0001);
-    case  STATUS_RUNNING:            return ((char *) ST_0002);
-    case  STATUS_PAUSED:             return ((char *) ST_0003);
-    case  STATUS_EXHAUSTED:          return ((char *) ST_0004);
-    case  STATUS_CRACKED:            return ((char *) ST_0005);
-    case  STATUS_ABORTED:            return ((char *) ST_0006);
-    case  STATUS_QUIT:               return ((char *) ST_0007);
-    case  STATUS_BYPASS:             return ((char *) ST_0008);
-    case  STATUS_STOP_AT_CHECKPOINT: return ((char *) ST_0009);
-    case  STATUS_AUTOTUNE:           return ((char *) ST_0010);
-  }
-
-  return ((char *) "Unknown");
-}
-
 double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
 {
   int exec_pos = (int) device_param->exec_pos - last_num_entries;
@@ -172,10 +140,12 @@ double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_en
 
 void status_display_machine_readable (opencl_ctx_t *opencl_ctx, const hashes_t *hashes)
 {
-  if (opencl_ctx->devices_status == STATUS_INIT)     return;
-  if (opencl_ctx->devices_status == STATUS_STARTING) return;
+  if (opencl_ctx->devices_status == STATUS_INIT)
+  {
+    log_error ("ERROR: status view is not available during initialization phase");
 
-  if (hashes == NULL) return;
+    return;
+  }
 
   FILE *out = stdout;
 
@@ -321,11 +291,12 @@ void status_display_machine_readable (opencl_ctx_t *opencl_ctx, const hashes_t *
 
 void status_display (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashconfig, const hashes_t *hashes)
 {
-  if (opencl_ctx->devices_status == STATUS_INIT)     return;
-  if (opencl_ctx->devices_status == STATUS_STARTING) return;
+  if (opencl_ctx->devices_status == STATUS_INIT)
+  {
+    log_error ("ERROR: status view is not available during initialization phase");
 
-  if (hashconfig == NULL) return;
-  if (hashes     == NULL) return;
+    return;
+  }
 
   // in this case some required buffers are free'd, ascii_digest() would run into segfault
   if (data.shutdown_inner == 1) return;
@@ -1063,10 +1034,7 @@ void status_display (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashconfig, c
 
   #if defined (HAVE_HWMON)
 
-  if (opencl_ctx->devices_status == STATUS_EXHAUSTED)  return;
-  if (opencl_ctx->devices_status == STATUS_CRACKED)    return;
-  if (opencl_ctx->devices_status == STATUS_ABORTED)    return;
-  if (opencl_ctx->devices_status == STATUS_QUIT)       return;
+  if (opencl_ctx->run_main_level1 == false) return;
 
   if (data.gpu_temp_disable == 0)
   {
@@ -1157,10 +1125,12 @@ void status_display (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashconfig, c
 
 void status_benchmark_automate (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashconfig)
 {
-  if (opencl_ctx->devices_status == STATUS_INIT)     return;
-  if (opencl_ctx->devices_status == STATUS_STARTING) return;
+  if (opencl_ctx->devices_status == STATUS_INIT)
+  {
+    log_error ("ERROR: status view is not available during initialization phase");
 
-  if (hashconfig == NULL) return;
+    return;
+  }
 
   u64    speed_cnt[DEVICES_MAX] = { 0 };
   double speed_ms[DEVICES_MAX]  = { 0 };
@@ -1203,10 +1173,12 @@ void status_benchmark_automate (opencl_ctx_t *opencl_ctx, const hashconfig_t *ha
 
 void status_benchmark (opencl_ctx_t *opencl_ctx, const hashconfig_t *hashconfig)
 {
-  if (opencl_ctx->devices_status == STATUS_INIT)     return;
-  if (opencl_ctx->devices_status == STATUS_STARTING) return;
+  if (opencl_ctx->devices_status == STATUS_INIT)
+  {
+    log_error ("ERROR: status view is not available during initialization phase");
 
-  if (hashconfig == NULL) return;
+    return;
+  }
 
   if (data.shutdown_inner == 1) return;
 
diff --git a/src/thread.c b/src/thread.c
index 1e43cad15..3089c5d90 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -140,14 +140,58 @@ void hc_signal (void (callback) (int))
 
 #endif
 
+void mycracked (opencl_ctx_t *opencl_ctx)
+{
+  if (opencl_ctx->devices_status != STATUS_RUNNING) return;
+
+  opencl_ctx->devices_status = STATUS_CRACKED;
+
+  opencl_ctx->run_main_level1   = false;
+  opencl_ctx->run_main_level2   = false;
+  opencl_ctx->run_main_level3   = false;
+  opencl_ctx->run_thread_level1 = false;
+  opencl_ctx->run_thread_level2 = false;
+}
+
 void myabort (opencl_ctx_t *opencl_ctx)
 {
+  if (opencl_ctx->devices_status != STATUS_RUNNING) return;
+
   opencl_ctx->devices_status = STATUS_ABORTED;
+
+  opencl_ctx->run_main_level1   = false;
+  opencl_ctx->run_main_level2   = false;
+  opencl_ctx->run_main_level3   = false;
+  opencl_ctx->run_thread_level1 = false;
+  opencl_ctx->run_thread_level2 = false;
 }
 
 void myquit (opencl_ctx_t *opencl_ctx)
 {
+  if (opencl_ctx->devices_status != STATUS_RUNNING) return;
+
   opencl_ctx->devices_status = STATUS_QUIT;
+
+  opencl_ctx->run_main_level1   = false;
+  opencl_ctx->run_main_level2   = false;
+  opencl_ctx->run_main_level3   = false;
+  opencl_ctx->run_thread_level1 = false;
+  opencl_ctx->run_thread_level2 = false;
+}
+
+void bypass (opencl_ctx_t *opencl_ctx)
+{
+  if (opencl_ctx->devices_status != STATUS_RUNNING) return;
+
+  opencl_ctx->devices_status = STATUS_BYPASS;
+
+  opencl_ctx->run_main_level1   = true;
+  opencl_ctx->run_main_level2   = true;
+  opencl_ctx->run_main_level3   = true;
+  opencl_ctx->run_thread_level1 = false;
+  opencl_ctx->run_thread_level2 = false;
+
+  log_info ("Next dictionary / mask in queue selected, bypassing current one");
 }
 
 void SuspendThreads (opencl_ctx_t *opencl_ctx)
@@ -175,10 +219,3 @@ void ResumeThreads (opencl_ctx_t *opencl_ctx)
 
   log_info ("Resumed");
 }
-
-void bypass (opencl_ctx_t *opencl_ctx)
-{
-  opencl_ctx->devices_status = STATUS_BYPASS;
-
-  log_info ("Next dictionary / mask in queue selected, bypassing current one");
-}