diff --git a/docs/changes.txt b/docs/changes.txt
index f99eb33dd..514ce1ca9 100644
--- a/docs/changes.txt
+++ b/docs/changes.txt
@@ -26,6 +26,7 @@
 - Fixed undefined function call to hc_byte_perm_S() in hash-mode 17010 on non-CUDA compute devices
 - Fixed wordlist handling in -m 3000 when candidate passwords use the $HEX[...] syntax
 - Fixed false negative on Unit Test with hash-type 25400
+- Fixed bug on benchmark engine, from now it will not stop at the first error detected
 
 ##
 ## Technical
@@ -45,6 +46,7 @@
 - HIP Backend: moved functions to ext_hip.c/ext_hiprtc.c and includes to ext_hip.h/ext_hiprtc.h
 - CUDA Backend: moved functions to ext_cuda.c/ext_nvrtc.c and includes to ext_cuda.h/ext_nvrtc.h
 - Makefile: updated MACOSX_DEPLOYMENT_TARGET to 10.15 and removed OpenCL framework from LFLAGS_NATIVE on MacOS
+- Status code: updated negative status code, usefull in Unit tests engine (test.sh)
 
 * changes v6.2.4 -> v6.2.5
 
diff --git a/docs/status_codes.txt b/docs/status_codes.txt
index 0c8c831b4..b7889ff2e 100644
--- a/docs/status_codes.txt
+++ b/docs/status_codes.txt
@@ -1,6 +1,12 @@
 status codes on exit:
 =====================
 
+-8 = mixed backend errors (combo of -3, -4, -5, -6, -7 errors type)
+-7 = backend error: Invalid module_extra_buffer_size
+-6 = backend error: Too many compute units to keep minimum kernel accel limit
+-5 = backend error: main kernel build error
+-4 = backend error: memory hit
+-3 = backend error: skipping hash-type due to module_unstable_warning settings
 -2 = gpu-watchdog alarm
 -1 = error
  0 = OK/cracked
diff --git a/include/types.h b/include/types.h
index fa3e2de6c..d665dd8ad 100644
--- a/include/types.h
+++ b/include/types.h
@@ -1683,6 +1683,17 @@ typedef struct backend_ctx
 {
   bool                enabled;
 
+  // global rc
+
+  bool                memory_hit_warning;
+  bool                runtime_skip_warning;
+  bool                kernel_build_warning;
+  bool                kernel_accel_warnings;
+  bool                extra_size_warning;
+  bool                mixed_warnings;
+
+  // generic
+
   void               *cuda;
   void               *hip;
   void               *ocl;
diff --git a/src/autotune.c b/src/autotune.c
index b5a66f75f..c89373126 100644
--- a/src/autotune.c
+++ b/src/autotune.c
@@ -525,7 +525,6 @@ HC_API_CALL void *thread_autotune (void *p)
   hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid;
 
   if (device_param->skipped == true) return NULL;
-
   if (device_param->skipped_warning == true) return NULL;
 
   if (device_param->is_cuda == true)
diff --git a/src/backend.c b/src/backend.c
index 63fbba09b..53a2fb819 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -112,7 +112,6 @@ static int backend_ctx_find_alias_devices (hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *backend_device = &backend_ctx->devices_param[backend_devices_pos];
 
     if (backend_device->skipped == true) continue;
-
     if (backend_device->skipped_warning == true) continue;
 
     for (int device_id_alias_pos = 0; device_id_alias_pos < backend_device->device_id_alias_cnt; device_id_alias_pos++)
@@ -122,7 +121,6 @@ static int backend_ctx_find_alias_devices (hashcat_ctx_t *hashcat_ctx)
       hc_device_param_t *alias_device = &backend_ctx->devices_param[alias_pos];
 
       if (alias_device->skipped == true) continue;
-
       if (alias_device->skipped_warning == true) continue;
 
       // this lets CUDA devices survive over OpenCL
@@ -6433,7 +6431,6 @@ void backend_ctx_devices_sync_tuning (hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param_src = &backend_ctx->devices_param[backend_devices_cnt_src];
 
     if (device_param_src->skipped == true) continue;
-
     if (device_param_src->skipped_warning == true) continue;
 
     for (int backend_devices_cnt_dst = backend_devices_cnt_src + 1; backend_devices_cnt_dst < backend_ctx->backend_devices_cnt; backend_devices_cnt_dst++)
@@ -6441,7 +6438,6 @@ void backend_ctx_devices_sync_tuning (hashcat_ctx_t *hashcat_ctx)
       hc_device_param_t *device_param_dst = &backend_ctx->devices_param[backend_devices_cnt_dst];
 
       if (device_param_dst->skipped == true) continue;
-
       if (device_param_dst->skipped_warning == true) continue;
 
       if (is_same_device_type (device_param_src, device_param_dst) == false) continue;
@@ -6477,7 +6473,6 @@ void backend_ctx_devices_update_power (hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     kernel_power_all += device_param->kernel_power;
@@ -6525,7 +6520,6 @@ void backend_ctx_devices_kernel_loops (hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     device_param->kernel_loops_min = device_param->kernel_loops_min_sav;
@@ -7321,6 +7315,19 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
   u32 hardware_power_all = 0;
 
+  int backend_memory_hit_warnings = 0;
+  int backend_runtime_skip_warnings = 0;
+  int backend_kernel_build_warnings = 0;
+  int backend_kernel_accel_warnings = 0;
+  int backend_extra_size_warning = 0;
+
+  backend_ctx->memory_hit_warning = false;
+  backend_ctx->runtime_skip_warning = false;
+  backend_ctx->kernel_build_warning = false;
+  backend_ctx->kernel_accel_warnings = false;
+  backend_ctx->extra_size_warning = false;
+  backend_ctx->mixed_warnings = false;
+
   for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++)
   {
     /**
@@ -7351,8 +7358,9 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
         event_log_warning (hashcat_ctx, "             This is due to a known CUDA/HIP/OpenCL runtime/driver issue (not a hashcat issue)");
         event_log_warning (hashcat_ctx, "             You can use --force to override, but do not report related errors.");
 
-        device_param->skipped_warning = true;
+        backend_runtime_skip_warnings++;
 
+        device_param->skipped_warning = true;
         continue;
       }
     }
@@ -7940,7 +7948,9 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       {
         event_log_error (hashcat_ctx, "Invalid extra buffer size.");
 
-        device_param->skipped = true;
+        backend_extra_size_warning++;
+
+        device_param->skipped_warning = true;
         continue;
       }
 
@@ -8475,7 +8485,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       {
         event_log_error (hashcat_ctx, "* Device #%u: Kernel %s build failed.", device_param->device_id + 1, source_file);
 
-        return -1;
+        backend_kernel_build_warnings++;
+
+        device_param->skipped_warning = true;
+        continue;
       }
 
       hcfree (build_options_module_buf);
@@ -8636,7 +8649,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
     {
       event_log_error (hashcat_ctx, "* Device #%u: Not enough allocatable device memory for this hashlist/ruleset.", device_id + 1);
 
-      return -1;
+      backend_memory_hit_warnings++;
+
+      device_param->skipped_warning = true;
+      continue;
     }
 
     if (device_param->is_cuda == true)
@@ -11226,7 +11242,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       event_log_error (hashcat_ctx, "* Device #%u: Too many compute units to keep minimum kernel accel limit.", device_id + 1);
       event_log_error (hashcat_ctx, "             Retry with lower --backend-kernel-threads value.");
 
-      return -1;
+      backend_kernel_accel_warnings++;
+
+      device_param->skipped_warning = true;
+      continue;
     }
 
     // Opposite direction check: find out if we would request too much memory on memory blocks which are based on kernel_accel
@@ -11411,7 +11430,10 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
     {
       event_log_error (hashcat_ctx, "* Device #%u: Not enough allocatable device memory for this attack.", device_id + 1);
 
-      return -1;
+      backend_memory_hit_warnings++;
+
+      device_param->skipped_warning = true;
+      continue;
     }
 
     // similar process for association attack
@@ -11740,6 +11762,32 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
     EVENT_DATA (EVENT_BACKEND_DEVICE_INIT_POST, &backend_devices_idx, sizeof (int));
   }
 
+  int rc = 0;
+
+  backend_ctx->memory_hit_warning = (backend_memory_hit_warnings == backend_ctx->backend_devices_active);
+  backend_ctx->runtime_skip_warning = (backend_runtime_skip_warnings == backend_ctx->backend_devices_active);
+  backend_ctx->kernel_build_warning = (backend_kernel_build_warnings == backend_ctx->backend_devices_active);
+  backend_ctx->kernel_accel_warnings = (backend_kernel_accel_warnings == backend_ctx->backend_devices_active);
+  backend_ctx->extra_size_warning = (backend_extra_size_warning == backend_ctx->backend_devices_active);
+
+  // if all active devices failed, set rc to -1
+  // later we prevent hashcat exit if is started in benchmark mode
+  if ((backend_ctx->memory_hit_warning == true) ||
+      (backend_ctx->runtime_skip_warning == true) ||
+      (backend_ctx->kernel_build_warning == true) ||
+      (backend_ctx->kernel_accel_warnings == true) ||
+      (backend_ctx->extra_size_warning == true))
+  {
+    rc = -1;
+  }
+  else
+  {
+    // handle mix of, in case of multiple devices with different warnings
+    backend_ctx->mixed_warnings = ((backend_memory_hit_warnings + backend_runtime_skip_warnings + backend_kernel_build_warnings + backend_kernel_accel_warnings + backend_extra_size_warning) == backend_ctx->backend_devices_active);
+
+    if (backend_ctx->mixed_warnings) rc = -1;
+  }
+
   if (user_options->benchmark == false)
   {
     if (hardware_power_all == 0) return -1;
@@ -11749,7 +11797,7 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
   EVENT_DATA (EVENT_BACKEND_SESSION_HOSTMEM, &size_total_host_all, sizeof (u64));
 
-  return 0;
+  return rc;
 }
 
 void backend_session_destroy (hashcat_ctx_t *hashcat_ctx)
@@ -12264,7 +12312,6 @@ int backend_session_update_combinator (hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     // kernel_params
@@ -12310,7 +12357,6 @@ int backend_session_update_mp (hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     device_param->kernel_params_mp_buf64[3] = 0;
@@ -12355,7 +12401,6 @@ int backend_session_update_mp_rl (hashcat_ctx_t *hashcat_ctx, const u32 css_cnt_
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     device_param->kernel_params_mp_l_buf64[3] = 0;
diff --git a/src/dispatch.c b/src/dispatch.c
index 2078cfdac..d8870d033 100644
--- a/src/dispatch.c
+++ b/src/dispatch.c
@@ -32,7 +32,6 @@ static u64 get_highest_words_done (const hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     const u64 words_done = device_param->words_done;
@@ -54,7 +53,6 @@ static u64 get_lowest_words_done (const hashcat_ctx_t *hashcat_ctx)
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
     if (device_param->skipped == true) continue;
-
     if (device_param->skipped_warning == true) continue;
 
     const u64 words_done = device_param->words_done;
@@ -353,7 +351,6 @@ HC_API_CALL void *thread_calc_stdin (void *p)
   hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid;
 
   if (device_param->skipped) return NULL;
-
   if (device_param->skipped_warning == true) return NULL;
 
   if (device_param->is_cuda == true)
@@ -1605,7 +1602,6 @@ HC_API_CALL void *thread_calc (void *p)
   hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid;
 
   if (device_param->skipped) return NULL;
-
   if (device_param->skipped_warning == true) return NULL;
 
   if (device_param->is_cuda == true)
diff --git a/src/hashcat.c b/src/hashcat.c
index bf936ccc0..91a25f2cf 100644
--- a/src/hashcat.c
+++ b/src/hashcat.c
@@ -767,7 +767,38 @@ static int outer_loop (hashcat_ctx_t *hashcat_ctx)
 
   EVENT (EVENT_BACKEND_SESSION_PRE);
 
-  if (backend_session_begin (hashcat_ctx) == -1) return -1;
+  if (backend_session_begin (hashcat_ctx) == -1)
+  {
+    if (user_options->benchmark == true)
+    {
+      if (user_options->hash_mode_chgd == false)
+      {
+        // finalize backend session
+
+        backend_session_destroy (hashcat_ctx);
+
+        // clean up
+
+        #ifdef WITH_BRAIN
+        brain_ctx_destroy       (hashcat_ctx);
+        #endif
+
+        bitmap_ctx_destroy      (hashcat_ctx);
+        combinator_ctx_destroy  (hashcat_ctx);
+        cpt_ctx_destroy         (hashcat_ctx);
+        hashconfig_destroy      (hashcat_ctx);
+        hashes_destroy          (hashcat_ctx);
+        mask_ctx_destroy        (hashcat_ctx);
+        status_progress_destroy (hashcat_ctx);
+        straight_ctx_destroy    (hashcat_ctx);
+        wl_data_destroy         (hashcat_ctx);
+
+        return 0;
+      }
+    }
+
+    return -1;
+  }
 
   EVENT (EVENT_BACKEND_SESSION_POST);
 
@@ -1500,6 +1531,7 @@ int hashcat_session_execute (hashcat_ctx_t *hashcat_ctx)
   logfile_ctx_t   *logfile_ctx   = hashcat_ctx->logfile_ctx;
   status_ctx_t    *status_ctx    = hashcat_ctx->status_ctx;
   user_options_t  *user_options  = hashcat_ctx->user_options;
+  backend_ctx_t   *backend_ctx   = hashcat_ctx->backend_ctx;
 
   // start logfile entry
 
@@ -1712,6 +1744,17 @@ int hashcat_session_execute (hashcat_ctx_t *hashcat_ctx)
     if (status_ctx->devices_status == STATUS_CRACKED)             rc_final =  0;
     if (status_ctx->devices_status == STATUS_ERROR)               rc_final = -1;
   }
+  else if (rc_final == -1)
+  {
+    // setup the new negative status code, usefull in test.sh
+    // -2 is marked as used in status_codes.txt
+    if (backend_ctx->runtime_skip_warning  == true)               rc_final = -3;
+    if (backend_ctx->memory_hit_warning    == true)               rc_final = -4;
+    if (backend_ctx->kernel_build_warning  == true)               rc_final = -5;
+    if (backend_ctx->kernel_accel_warnings == true)               rc_final = -6;
+    if (backend_ctx->extra_size_warning    == true)               rc_final = -7;
+    if (backend_ctx->mixed_warnings        == true)               rc_final = -8;
+  }
 
   // special case for --stdout
 
diff --git a/src/monitor.c b/src/monitor.c
index b61a41824..ce02a7a90 100644
--- a/src/monitor.c
+++ b/src/monitor.c
@@ -151,7 +151,6 @@ static int monitor (hashcat_ctx_t *hashcat_ctx)
         hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
         if (device_param->skipped == true) continue;
-
         if (device_param->skipped_warning == true) continue;
 
         const int rc_throttle = hm_get_throttle_with_devices_idx (hashcat_ctx, backend_devices_idx);
@@ -261,7 +260,6 @@ static int monitor (hashcat_ctx_t *hashcat_ctx)
         hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
         if (device_param->skipped == true) continue;
-
         if (device_param->skipped_warning == true) continue;
 
         exec_cnt++;
diff --git a/src/selftest.c b/src/selftest.c
index 5379650aa..28b7b6d4f 100644
--- a/src/selftest.c
+++ b/src/selftest.c
@@ -900,7 +900,6 @@ HC_API_CALL void *thread_selftest (void *p)
   hc_device_param_t *device_param = backend_ctx->devices_param + thread_param->tid;
 
   if (device_param->skipped == true) return NULL;
-
   if (device_param->skipped_warning == true) return NULL;
 
   if (device_param->is_cuda == true)
diff --git a/src/status.c b/src/status.c
index 8bf13d4b3..ed7d0ba9a 100644
--- a/src/status.c
+++ b/src/status.c
@@ -1885,6 +1885,7 @@ char *status_get_brain_rx_all (const hashcat_ctx_t *hashcat_ctx)
   for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++)
   {
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
+
     if ((device_param->skipped == false) && (device_param->skipped_warning == false))
     {
       brain_rx_all += device_param->brain_link_recv_bytes;
@@ -1927,6 +1928,7 @@ char *status_get_brain_tx_all (const hashcat_ctx_t *hashcat_ctx)
   for (int backend_devices_idx = 0; backend_devices_idx < backend_ctx->backend_devices_cnt; backend_devices_idx++)
   {
     hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
+
     if ((device_param->skipped == false) && (device_param->skipped_warning == false))
     {
       brain_tx_all += device_param->brain_link_send_bytes;
@@ -2024,7 +2026,6 @@ char *status_get_hwmon_dev (const hashcat_ctx_t *hashcat_ctx, const int backend_
   snprintf (output_buf, HCBUFSIZ_TINY, "N/A");
 
   if (device_param->skipped == true) return output_buf;
-
   if (device_param->skipped_warning == true) return output_buf;
 
   status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
@@ -2093,7 +2094,6 @@ int status_get_corespeed_dev (const hashcat_ctx_t *hashcat_ctx, const int backen
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return -1;
-
   if (device_param->skipped_warning == true) return -1;
 
   status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
@@ -2114,7 +2114,6 @@ int status_get_memoryspeed_dev (const hashcat_ctx_t *hashcat_ctx, const int back
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return -1;
-
   if (device_param->skipped_warning == true) return -1;
 
   status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
@@ -2135,7 +2134,6 @@ u64 status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int backend
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return 0;
-
   if (device_param->skipped_warning == true) return 0;
 
   return device_param->outerloop_left;
@@ -2148,7 +2146,6 @@ double status_get_runtime_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return 0;
-
   if (device_param->skipped_warning == true) return 0;
 
   return device_param->outerloop_msec;
@@ -2161,7 +2158,6 @@ int status_get_kernel_accel_dev (const hashcat_ctx_t *hashcat_ctx, const int bac
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return 0;
-
   if (device_param->skipped_warning == true) return 0;
 
   if (device_param->kernel_accel_prev) return device_param->kernel_accel_prev;
@@ -2176,7 +2172,6 @@ int status_get_kernel_loops_dev (const hashcat_ctx_t *hashcat_ctx, const int bac
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return 0;
-
   if (device_param->skipped_warning == true) return 0;
 
   if (device_param->kernel_loops_prev) return device_param->kernel_loops_prev;
@@ -2191,7 +2186,6 @@ int status_get_kernel_threads_dev (const hashcat_ctx_t *hashcat_ctx, const int b
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return 0;
-
   if (device_param->skipped_warning == true) return 0;
 
   if (device_param->kernel_threads_prev) return device_param->kernel_threads_prev;
@@ -2206,7 +2200,6 @@ int status_get_vector_width_dev (const hashcat_ctx_t *hashcat_ctx, const int bac
   hc_device_param_t *device_param = &backend_ctx->devices_param[backend_devices_idx];
 
   if (device_param->skipped == true) return 0;
-
   if (device_param->skipped_warning == true) return 0;
 
   return device_param->vector_width;
diff --git a/src/terminal.c b/src/terminal.c
index 81381b2dc..2660b72ba 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -1175,7 +1175,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     printf ("%" PRIu64 "\t", (u64) (device_info->hashes_msec_dev * 1000));
@@ -1191,7 +1190,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     printf ("%f\t", device_info->exec_msec_dev);
@@ -1214,7 +1212,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
       const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
       if (device_info->skipped_dev == true) continue;
-
       if (device_info->skipped_warning_dev == true) continue;
 
       const int temp = hm_get_temperature_with_devices_idx (hashcat_ctx, device_id);
@@ -1232,7 +1229,6 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     // ok, little cheat here again...
@@ -1351,7 +1347,6 @@ void status_display_status_json (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     if (device_num != 0)
@@ -1784,7 +1779,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx,
@@ -1901,7 +1895,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
       const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
       if (device_info->skipped_dev == true) continue;
-
       if (device_info->skipped_warning_dev == true) continue;
 
       if (device_info->brain_link_status_dev == BRAIN_LINK_STATUS_CONNECTED)
@@ -1978,7 +1971,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx,
@@ -2005,7 +1997,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     if (device_info->guess_candidates_dev == NULL) continue;
@@ -2026,7 +2017,6 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
       const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
       if (device_info->skipped_dev == true) continue;
-
       if (device_info->skipped_warning_dev == true) continue;
 
       if (device_info->hwmon_dev == NULL) continue;
@@ -2070,7 +2060,6 @@ void status_benchmark_machine_readable (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx, "%d:%u:%d:%d:%.2f:%" PRIu64, device_id + 1, hash_mode, device_info->corespeed_dev, device_info->memoryspeed_dev, device_info->exec_msec_dev, (u64) (device_info->hashes_msec_dev_benchmark * 1000));
@@ -2106,7 +2095,6 @@ void status_benchmark (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx,
@@ -2147,7 +2135,6 @@ void status_speed_machine_readable (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx, "%d:%" PRIu64, device_id + 1, (u64) (device_info->hashes_msec_dev_benchmark * 1000));
@@ -2178,7 +2165,6 @@ void status_speed_json (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     if (device_num != 0)
@@ -2230,7 +2216,6 @@ void status_speed (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx,
@@ -2267,7 +2252,6 @@ void status_progress_machine_readable (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx, "%d:%" PRIu64 ":%0.2f", device_id + 1, device_info->progress_dev, device_info->runtime_msec_dev);
@@ -2298,7 +2282,6 @@ void status_progress_json (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     if (device_num != 0)
@@ -2351,7 +2334,6 @@ void status_progress (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx,
@@ -2364,7 +2346,6 @@ void status_progress (hashcat_ctx_t *hashcat_ctx)
     const device_info_t *device_info = hashcat_status->device_info_buf + device_id;
 
     if (device_info->skipped_dev == true) continue;
-
     if (device_info->skipped_warning_dev == true) continue;
 
     event_log_info (hashcat_ctx,