diff --git a/docs/changes.txt b/docs/changes.txt
index d828a6045..ee36109cb 100644
--- a/docs/changes.txt
+++ b/docs/changes.txt
@@ -4,6 +4,7 @@
 ## Improvements
 ##
 
+- Added the current first and last password candidate test queued for execution per device on status view
 - Use .gitmodules to handle OpenCL headers depency
 - Allow loading of bcrypt hashes with signature $2b$ (February 2014)
 - Replaced some uint macros with enums types
diff --git a/include/convert.h b/include/convert.h
index b4b89b61f..d1a58d269 100644
--- a/include/convert.h
+++ b/include/convert.h
@@ -8,6 +8,9 @@
 
 #include <ctype.h>
 
+bool need_hexify (const u8 *buf, const int len);
+void exec_hexify (const u8 *buf, const int len, u8 *out);
+
 bool is_valid_hex_char (const u8 c);
 
 u8 hex_convert (const u8 c);
diff --git a/include/hashes.h b/include/hashes.h
index 8bed9b358..1d0bcb235 100644
--- a/include/hashes.h
+++ b/include/hashes.h
@@ -11,10 +11,6 @@ int sort_by_salt         (const void *v1, const void *v2);
 int sort_by_hash         (const void *v1, const void *v2, void *v3);
 int sort_by_hash_no_salt (const void *v1, const void *v2, void *v3);
 
-void build_plain     (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len);
-void build_crackpos  (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos);
-void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len);
-
 void save_hash (const user_options_t *user_options, const hashconfig_t *hashconfig, const hashes_t *hashes);
 
 void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain);
diff --git a/include/outfile.h b/include/outfile.h
index 9c08782f2..44f91fe17 100644
--- a/include/outfile.h
+++ b/include/outfile.h
@@ -10,6 +10,10 @@
 #include <time.h>
 #include <inttypes.h>
 
+void build_plain     (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len);
+void build_crackpos  (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos);
+void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len);
+
 void outfile_init           (outfile_ctx_t *outfile_ctx, const user_options_t *user_options);
 void outfile_destroy        (outfile_ctx_t *outfile_ctx);
 void outfile_format_plain   (outfile_ctx_t *outfile_ctx, const unsigned char *plain_ptr, const u32 plain_len);
diff --git a/src/convert.c b/src/convert.c
index 59e0b051d..43abc01a6 100644
--- a/src/convert.c
+++ b/src/convert.c
@@ -7,6 +7,38 @@
 #include "types.h"
 #include "convert.h"
 
+bool need_hexify (const u8 *buf, const int len)
+{
+  for (int i = 0; i < len; i++)
+  {
+    const u8 c = buf[i];
+
+    if (c < 0x20) return true;
+    if (c > 0x7f) return true;
+  }
+
+  return false;
+}
+
+void exec_hexify (const u8 *buf, const int len, u8 *out)
+{
+  for (int i = len - 1, j = i * 2; i >= 0; i -= 1, j -= 2)
+  {
+    const u8 v = buf[i];
+
+    u8 h0 = v >> 4 & 15;
+    u8 h1 = v >> 0 & 15;
+
+    u8 add;
+
+    h0 += 6; add = ((h0 & 0x10) >> 4) * 39; h0 += 42 + add;
+    h1 += 6; add = ((h1 & 0x10) >> 4) * 39; h1 += 42 + add;
+
+    out[j + 0] = h0;
+    out[j + 1] = h1;
+  }
+}
+
 bool is_valid_hex_char (const u8 c)
 {
   if ((c >= '0') && (c <= '9')) return true;
diff --git a/src/hashes.c b/src/hashes.c
index c220d054f..d8c26006d 100644
--- a/src/hashes.c
+++ b/src/hashes.c
@@ -117,249 +117,6 @@ int sort_by_hash_no_salt (const void *v1, const void *v2, void *v3)
   return sort_by_digest_p0p1 (d1, d2, v3);
 }
 
-void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len)
-{
-  combinator_ctx_t      *combinator_ctx     = hashcat_ctx->combinator_ctx;
-  hashconfig_t          *hashconfig         = hashcat_ctx->hashconfig;
-  hashes_t              *hashes             = hashcat_ctx->hashes;
-  mask_ctx_t            *mask_ctx           = hashcat_ctx->mask_ctx;
-  opencl_ctx_t          *opencl_ctx         = hashcat_ctx->opencl_ctx;
-  straight_ctx_t        *straight_ctx       = hashcat_ctx->straight_ctx;
-  user_options_t        *user_options       = hashcat_ctx->user_options;
-
-  const u32 gidvid      = plain->gidvid;
-  const u32 il_pos      = plain->il_pos;
-
-  int plain_len = 0;
-
-  u8 *plain_ptr = (u8 *) plain_buf;
-
-  if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
-  {
-    pw_t pw;
-
-    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
-
-    for (int i = 0; i < 16; i++)
-    {
-      plain_buf[i] = pw.i[i];
-    }
-
-    plain_len = (int) pw.pw_len;
-
-    const u32 off = device_param->innerloop_pos + il_pos;
-
-    plain_len = (int) apply_rules (straight_ctx->kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], (u32) plain_len);
-
-    if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
-  }
-  else if (user_options->attack_mode == ATTACK_MODE_COMBI)
-  {
-    pw_t pw;
-
-    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
-
-    for (int i = 0; i < 16; i++)
-    {
-      plain_buf[i] = pw.i[i];
-    }
-
-    plain_len = (int) pw.pw_len;
-
-    char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
-    u32   comb_len =          device_param->combs_buf[il_pos].pw_len;
-
-    if (combinator_ctx->combs_mode == COMBINATOR_MODE_BASE_LEFT)
-    {
-      memcpy (plain_ptr + plain_len, comb_buf, (size_t) comb_len);
-    }
-    else
-    {
-      memmove (plain_ptr + comb_len, plain_ptr, (size_t) plain_len);
-
-      memcpy (plain_ptr, comb_buf, comb_len);
-    }
-
-    plain_len += comb_len;
-
-    if (hashconfig->pw_max != PW_DICTMAX1)
-    {
-      if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
-    }
-  }
-  else if (user_options->attack_mode == ATTACK_MODE_BF)
-  {
-    u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
-    u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
-
-    u32 l_start = device_param->kernel_params_mp_l_buf32[5];
-    u32 r_start = device_param->kernel_params_mp_r_buf32[5];
-
-    u32 l_stop = device_param->kernel_params_mp_l_buf32[4];
-    u32 r_stop = device_param->kernel_params_mp_r_buf32[4];
-
-    sp_exec (l_off, (char *) plain_ptr + l_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, l_start, l_start + l_stop);
-    sp_exec (r_off, (char *) plain_ptr + r_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, r_start, r_start + r_stop);
-
-    plain_len = (int) mask_ctx->css_cnt;
-  }
-  else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
-  {
-    pw_t pw;
-
-    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
-
-    for (int i = 0; i < 16; i++)
-    {
-      plain_buf[i] = pw.i[i];
-    }
-
-    plain_len = (int) pw.pw_len;
-
-    u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
-
-    u32 start = 0;
-    u32 stop  = device_param->kernel_params_mp_buf32[4];
-
-    sp_exec (off, (char *) plain_ptr + plain_len, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
-
-    plain_len += start + stop;
-
-    if (hashconfig->pw_max != PW_DICTMAX1)
-    {
-      if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
-    }
-  }
-  else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
-  {
-    pw_t pw;
-
-    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
-
-    for (int i = 0; i < 16; i++)
-    {
-      plain_buf[i] = pw.i[i];
-    }
-
-    plain_len = (int) pw.pw_len;
-
-    u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
-
-    u32 start = 0;
-    u32 stop  = device_param->kernel_params_mp_buf32[4];
-
-    memmove (plain_ptr + stop, plain_ptr, plain_len);
-
-    sp_exec (off, (char *) plain_ptr, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
-
-    plain_len += start + stop;
-
-    if (hashconfig->pw_max != PW_DICTMAX1)
-    {
-      if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
-    }
-  }
-
-  if (user_options->attack_mode == ATTACK_MODE_BF)
-  {
-    if (hashconfig->opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
-    {
-      if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH)
-      {
-        if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT)
-        {
-          plain_len = plain_len - hashes->salts_buf[0].salt_len;
-        }
-      }
-
-      if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
-      {
-        for (int i = 0, j = 0; i < plain_len; i += 2, j += 1)
-        {
-          plain_ptr[j] = plain_ptr[i];
-        }
-
-        plain_len = plain_len / 2;
-      }
-    }
-  }
-
-  *out_len = plain_len;
-}
-
-void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos)
-{
-  combinator_ctx_t      *combinator_ctx     = hashcat_ctx->combinator_ctx;
-  mask_ctx_t            *mask_ctx           = hashcat_ctx->mask_ctx;
-  straight_ctx_t        *straight_ctx       = hashcat_ctx->straight_ctx;
-  user_options_extra_t  *user_options_extra = hashcat_ctx->user_options_extra;
-
-  const u32 gidvid      = plain->gidvid;
-  const u32 il_pos      = plain->il_pos;
-
-  u64 crackpos = device_param->words_off;
-
-  if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
-  {
-    crackpos += gidvid;
-    crackpos *= straight_ctx->kernel_rules_cnt;
-    crackpos += device_param->innerloop_pos + il_pos;
-  }
-  else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
-  {
-    crackpos += gidvid;
-    crackpos *= combinator_ctx->combs_cnt;
-    crackpos += device_param->innerloop_pos + il_pos;
-  }
-  else if (user_options_extra->attack_kern == ATTACK_MODE_BF)
-  {
-    crackpos += gidvid;
-    crackpos *= mask_ctx->bfs_cnt;
-    crackpos += device_param->innerloop_pos + il_pos;
-  }
-
-  *out_pos = crackpos;
-}
-
-void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len)
-{
-  debugfile_ctx_t       *debugfile_ctx      = hashcat_ctx->debugfile_ctx;
-  opencl_ctx_t          *opencl_ctx         = hashcat_ctx->opencl_ctx;
-  straight_ctx_t        *straight_ctx       = hashcat_ctx->straight_ctx;
-  user_options_t        *user_options       = hashcat_ctx->user_options;
-
-  const u32 gidvid      = plain->gidvid;
-  const u32 il_pos      = plain->il_pos;
-
-  if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) return;
-
-  const u32 debug_mode = debugfile_ctx->mode;
-
-  if (debug_mode == 0) return;
-
-  pw_t pw;
-
-  gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
-
-  int plain_len = (int) pw.pw_len;
-
-  const u32 off = device_param->innerloop_pos + il_pos;
-
-  // save rule
-  if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
-  {
-    *debug_rule_len = kernel_rule_to_cpu_rule ((char *) debug_rule_buf, &straight_ctx->kernel_rules_buf[off]);
-  }
-
-  // save plain
-  if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
-  {
-    memcpy (debug_plain_ptr, (char *) pw.i, (size_t) plain_len);
-
-    *debug_plain_len = plain_len;
-  }
-}
-
 void save_hash (const user_options_t *user_options, const hashconfig_t *hashconfig, const hashes_t *hashes)
 {
   char *hashfile = hashes->hashfile;
diff --git a/src/opencl.c b/src/opencl.c
index 5f782cab1..1f07197ad 100644
--- a/src/opencl.c
+++ b/src/opencl.c
@@ -1034,6 +1034,10 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
                    + device_param->kernel_params_mp_l_buf32[5];
   }
 
+  // we make use of this in status view
+
+  device_param->outerloop_left = pws_cnt;
+
   // loop start: most outer loop = salt iteration, then innerloops (if multi)
 
   for (u32 salt_pos = 0; salt_pos < hashes->salts_cnt; salt_pos++)
diff --git a/src/outfile.c b/src/outfile.c
index e47147d58..571a9c75b 100644
--- a/src/outfile.c
+++ b/src/outfile.c
@@ -9,8 +9,255 @@
 #include "logging.h"
 #include "interface.h"
 #include "hashes.h"
+#include "mpsp.h"
+#include "rp.h"
+#include "rp_kernel_on_cpu.h"
+#include "opencl.h"
 #include "outfile.h"
 
+void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len)
+{
+  combinator_ctx_t      *combinator_ctx     = hashcat_ctx->combinator_ctx;
+  hashconfig_t          *hashconfig         = hashcat_ctx->hashconfig;
+  hashes_t              *hashes             = hashcat_ctx->hashes;
+  mask_ctx_t            *mask_ctx           = hashcat_ctx->mask_ctx;
+  opencl_ctx_t          *opencl_ctx         = hashcat_ctx->opencl_ctx;
+  straight_ctx_t        *straight_ctx       = hashcat_ctx->straight_ctx;
+  user_options_t        *user_options       = hashcat_ctx->user_options;
+
+  const u32 gidvid      = plain->gidvid;
+  const u32 il_pos      = plain->il_pos;
+
+  int plain_len = 0;
+
+  u8 *plain_ptr = (u8 *) plain_buf;
+
+  if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
+  {
+    pw_t pw;
+
+    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
+
+    for (int i = 0; i < 16; i++)
+    {
+      plain_buf[i] = pw.i[i];
+    }
+
+    plain_len = (int) pw.pw_len;
+
+    const u32 off = device_param->innerloop_pos + il_pos;
+
+    plain_len = (int) apply_rules (straight_ctx->kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], (u32) plain_len);
+
+    if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
+  }
+  else if (user_options->attack_mode == ATTACK_MODE_COMBI)
+  {
+    pw_t pw;
+
+    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
+
+    for (int i = 0; i < 16; i++)
+    {
+      plain_buf[i] = pw.i[i];
+    }
+
+    plain_len = (int) pw.pw_len;
+
+    char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
+    u32   comb_len =          device_param->combs_buf[il_pos].pw_len;
+
+    if (combinator_ctx->combs_mode == COMBINATOR_MODE_BASE_LEFT)
+    {
+      memcpy (plain_ptr + plain_len, comb_buf, (size_t) comb_len);
+    }
+    else
+    {
+      memmove (plain_ptr + comb_len, plain_ptr, (size_t) plain_len);
+
+      memcpy (plain_ptr, comb_buf, comb_len);
+    }
+
+    plain_len += comb_len;
+
+    if (hashconfig->pw_max != PW_DICTMAX1)
+    {
+      if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
+    }
+  }
+  else if (user_options->attack_mode == ATTACK_MODE_BF)
+  {
+    u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
+    u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
+
+    u32 l_start = device_param->kernel_params_mp_l_buf32[5];
+    u32 r_start = device_param->kernel_params_mp_r_buf32[5];
+
+    u32 l_stop = device_param->kernel_params_mp_l_buf32[4];
+    u32 r_stop = device_param->kernel_params_mp_r_buf32[4];
+
+    sp_exec (l_off, (char *) plain_ptr + l_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, l_start, l_start + l_stop);
+    sp_exec (r_off, (char *) plain_ptr + r_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, r_start, r_start + r_stop);
+
+    plain_len = (int) mask_ctx->css_cnt;
+  }
+  else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
+  {
+    pw_t pw;
+
+    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
+
+    for (int i = 0; i < 16; i++)
+    {
+      plain_buf[i] = pw.i[i];
+    }
+
+    plain_len = (int) pw.pw_len;
+
+    u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
+
+    u32 start = 0;
+    u32 stop  = device_param->kernel_params_mp_buf32[4];
+
+    sp_exec (off, (char *) plain_ptr + plain_len, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
+
+    plain_len += start + stop;
+
+    if (hashconfig->pw_max != PW_DICTMAX1)
+    {
+      if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
+    }
+  }
+  else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
+  {
+    pw_t pw;
+
+    gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
+
+    for (int i = 0; i < 16; i++)
+    {
+      plain_buf[i] = pw.i[i];
+    }
+
+    plain_len = (int) pw.pw_len;
+
+    u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
+
+    u32 start = 0;
+    u32 stop  = device_param->kernel_params_mp_buf32[4];
+
+    memmove (plain_ptr + stop, plain_ptr, plain_len);
+
+    sp_exec (off, (char *) plain_ptr, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
+
+    plain_len += start + stop;
+
+    if (hashconfig->pw_max != PW_DICTMAX1)
+    {
+      if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
+    }
+  }
+
+  if (user_options->attack_mode == ATTACK_MODE_BF)
+  {
+    if (hashconfig->opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
+    {
+      if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH)
+      {
+        if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT)
+        {
+          plain_len = plain_len - hashes->salts_buf[0].salt_len;
+        }
+      }
+
+      if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
+      {
+        for (int i = 0, j = 0; i < plain_len; i += 2, j += 1)
+        {
+          plain_ptr[j] = plain_ptr[i];
+        }
+
+        plain_len = plain_len / 2;
+      }
+    }
+  }
+
+  *out_len = plain_len;
+}
+
+void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos)
+{
+  combinator_ctx_t      *combinator_ctx     = hashcat_ctx->combinator_ctx;
+  mask_ctx_t            *mask_ctx           = hashcat_ctx->mask_ctx;
+  straight_ctx_t        *straight_ctx       = hashcat_ctx->straight_ctx;
+  user_options_extra_t  *user_options_extra = hashcat_ctx->user_options_extra;
+
+  const u32 gidvid      = plain->gidvid;
+  const u32 il_pos      = plain->il_pos;
+
+  u64 crackpos = device_param->words_off;
+
+  if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
+  {
+    crackpos += gidvid;
+    crackpos *= straight_ctx->kernel_rules_cnt;
+    crackpos += device_param->innerloop_pos + il_pos;
+  }
+  else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
+  {
+    crackpos += gidvid;
+    crackpos *= combinator_ctx->combs_cnt;
+    crackpos += device_param->innerloop_pos + il_pos;
+  }
+  else if (user_options_extra->attack_kern == ATTACK_MODE_BF)
+  {
+    crackpos += gidvid;
+    crackpos *= mask_ctx->bfs_cnt;
+    crackpos += device_param->innerloop_pos + il_pos;
+  }
+
+  *out_pos = crackpos;
+}
+
+void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len)
+{
+  debugfile_ctx_t       *debugfile_ctx      = hashcat_ctx->debugfile_ctx;
+  opencl_ctx_t          *opencl_ctx         = hashcat_ctx->opencl_ctx;
+  straight_ctx_t        *straight_ctx       = hashcat_ctx->straight_ctx;
+  user_options_t        *user_options       = hashcat_ctx->user_options;
+
+  const u32 gidvid      = plain->gidvid;
+  const u32 il_pos      = plain->il_pos;
+
+  if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) return;
+
+  const u32 debug_mode = debugfile_ctx->mode;
+
+  if (debug_mode == 0) return;
+
+  pw_t pw;
+
+  gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
+
+  int plain_len = (int) pw.pw_len;
+
+  const u32 off = device_param->innerloop_pos + il_pos;
+
+  // save rule
+  if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
+  {
+    *debug_rule_len = kernel_rule_to_cpu_rule ((char *) debug_rule_buf, &straight_ctx->kernel_rules_buf[off]);
+  }
+
+  // save plain
+  if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
+  {
+    memcpy (debug_plain_ptr, (char *) pw.i, (size_t) plain_len);
+
+    *debug_plain_len = plain_len;
+  }
+}
+
 void outfile_init (outfile_ctx_t *outfile_ctx, const user_options_t *user_options)
 {
   if (user_options->outfile == NULL)
diff --git a/src/rp_kernel_on_cpu.c b/src/rp_kernel_on_cpu.c
index 8a9d37eb1..ab0835c15 100644
--- a/src/rp_kernel_on_cpu.c
+++ b/src/rp_kernel_on_cpu.c
@@ -9,6 +9,7 @@
 #include "common.h"
 #include "types.h"
 #include "bitops.h"
+#include "rp.h"
 #include "rp_kernel_on_cpu.h"
 
 u32 swap_workaround (const u32 n)
diff --git a/src/status.c b/src/status.c
index 3a6443c23..77d218e82 100644
--- a/src/status.c
+++ b/src/status.c
@@ -7,11 +7,13 @@
 #include "types.h"
 #include "memory.h"
 #include "logging.h"
+#include "convert.h"
 #include "restore.h"
 #include "thread.h"
 #include "timer.h"
 #include "interface.h"
 #include "hwmon.h"
+#include "outfile.h"
 #include "status.h"
 
 static const char ST_0000[] = "Initializing";
@@ -164,6 +166,13 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
     return;
   }
 
+  if (status_ctx->devices_status == STATUS_AUTOTUNE)
+  {
+    log_error ("ERROR: status view is not available during autotune phase");
+
+    return;
+  }
+
   FILE *out = stdout;
 
   fprintf (out, "STATUS\t%u\t", status_ctx->devices_status);
@@ -326,6 +335,13 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
     return;
   }
 
+  if (status_ctx->devices_status == STATUS_AUTOTUNE)
+  {
+    log_error ("ERROR: status view is not available during autotune phase");
+
+    return;
+  }
+
   // in this case some required buffers are free'd, ascii_digest() would run into segfault
   if (status_ctx->shutdown_inner == 1) return;
 
@@ -859,7 +875,44 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
 
     if (device_param->skipped) continue;
 
-//    log_info ("Plain.Txt.#%d...: xxx", device_id + 1);
+    const u32 outerloop_first = 0;
+    const u32 outerloop_last  = (device_param->outerloop_left) ? device_param->outerloop_left - 1 : 0;
+
+    const u32 innerloop_first = 0;
+    const u32 innerloop_last  = (device_param->innerloop_left) ? device_param->innerloop_left - 1 : 0;
+
+    plain_t plain1 = { 0, 0, 0, outerloop_first, innerloop_first };
+    plain_t plain2 = { 0, 0, 0, outerloop_last,  innerloop_last  };
+
+    u32 plain_buf1[16] = { 0 };
+    u32 plain_buf2[16] = { 0 };
+
+    u8 *plain_ptr1 = (u8 *) plain_buf1;
+    u8 *plain_ptr2 = (u8 *) plain_buf2;
+
+    int plain_len1 = 0;
+    int plain_len2 = 0;
+
+    build_plain (hashcat_ctx, device_param, &plain1, plain_buf1, &plain_len1);
+    build_plain (hashcat_ctx, device_param, &plain2, plain_buf2, &plain_len2);
+
+    bool need_hex1 = need_hexify (plain_ptr1, plain_len1);
+    bool need_hex2 = need_hexify (plain_ptr2, plain_len2);
+
+    if ((need_hex1 == true) || (need_hex2 == true))
+    {
+      exec_hexify (plain_ptr1, plain_len1, plain_ptr1);
+      exec_hexify (plain_ptr2, plain_len2, plain_ptr2);
+
+      plain_ptr1[plain_len1 * 2] = 0;
+      plain_ptr2[plain_len2 * 2] = 0;
+
+      log_info ("Guess.Pass.#%d..: $HEX[%s] -> $HEX[%s]", device_id + 1, plain_ptr1, plain_ptr2);
+    }
+    else
+    {
+      log_info ("Guess.Pass.#%d..: %s -> %s", device_id + 1, plain_ptr1, plain_ptr2);
+    }
   }
 
   for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
@@ -1123,6 +1176,13 @@ void status_benchmark_automate (hashcat_ctx_t *hashcat_ctx)
     return;
   }
 
+  if (status_ctx->devices_status == STATUS_AUTOTUNE)
+  {
+    log_error ("ERROR: status view is not available during autotune phase");
+
+    return;
+  }
+
   u64    speed_cnt[DEVICES_MAX] = { 0 };
   double speed_ms[DEVICES_MAX]  = { 0 };
 
@@ -1175,6 +1235,13 @@ void status_benchmark (hashcat_ctx_t *hashcat_ctx)
     return;
   }
 
+  if (status_ctx->devices_status == STATUS_AUTOTUNE)
+  {
+    log_error ("ERROR: status view is not available during autotune phase");
+
+    return;
+  }
+
   if (status_ctx->shutdown_inner == 1) return;
 
   if (user_options->machine_readable == true)