diff --git a/include/common.h b/include/common.h
index fa0243f48..363364b53 100644
--- a/include/common.h
+++ b/include/common.h
@@ -95,7 +95,6 @@ but this is nededed for VS compiler which doesn't have inline keyword but has __
 #define EXEC_CACHE          128
 #define SPEED_CACHE         128
 #define SPEED_MAXAGE        4096
-#define BLOCK_SIZE          64
 #define EXPECTED_ITERATIONS 10000
 
 #if defined (_WIN)
diff --git a/include/rp.h b/include/rp.h
index 5b1f66cc1..c24f2fd15 100644
--- a/include/rp.h
+++ b/include/rp.h
@@ -8,7 +8,8 @@
 
 #include <string.h>
 
-#define RP_RULE_BUFSIZ 0x100
+#define RP_RULE_SIZE      256
+#define RP_PASSWORD_SIZE  256
 
 #define INCR_RULES 10000
 
@@ -23,7 +24,7 @@ bool class_alpha (const u8 c);
 int conv_ctoi (const u8 c);
 int conv_itoc (const u8 c);
 
-int generate_random_rule (char rule_buf[RP_RULE_BUFSIZ], const u32 rp_gen_func_min, const u32 rp_gen_func_max);
+int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min, const u32 rp_gen_func_max);
 
 int cpu_rule_to_kernel_rule (char *rule_buf, u32 rule_len, kernel_rule_t *rule);
 int kernel_rule_to_cpu_rule (char *rule_buf, kernel_rule_t *rule);
diff --git a/include/rp_cpu.h b/include/rp_cpu.h
index ebb91c9a0..da1b088d0 100644
--- a/include/rp_cpu.h
+++ b/include/rp_cpu.h
@@ -11,7 +11,7 @@
 #define RULE_RC_SYNTAX_ERROR -1
 #define RULE_RC_REJECT_ERROR -2
 
-int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len, char out[BLOCK_SIZE]);
+int _old_apply_rule (char *rule, int rule_len, char in[RP_PASSWORD_SIZE], int in_len, char out[RP_PASSWORD_SIZE]);
 
 int run_rule_engine (const int rule_len, const char *rule_buf);
 
diff --git a/src/dispatch.c b/src/dispatch.c
index cd7bfd962..ccf540f73 100644
--- a/src/dispatch.c
+++ b/src/dispatch.c
@@ -13,6 +13,7 @@
 #include "shared.h"
 #include "thread.h"
 #include "filehandling.h"
+#include "rp.h"
 #include "rp_cpu.h"
 #include "dispatch.h"
 
@@ -180,11 +181,11 @@ static int calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_par
 
       // post-process rule engine
 
-      char rule_buf_out[BLOCK_SIZE];
+      char rule_buf_out[RP_PASSWORD_SIZE];
 
       if (run_rule_engine ((int) user_options_extra->rule_len_l, user_options->rule_buf_l))
       {
-        if (line_len >= BLOCK_SIZE) continue;
+        if (line_len >= RP_PASSWORD_SIZE) continue;
 
         memset (rule_buf_out, 0, sizeof (rule_buf_out));
 
@@ -496,7 +497,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
         char *line_buf;
         u32   line_len;
 
-        char rule_buf_out[BLOCK_SIZE];
+        char rule_buf_out[RP_PASSWORD_SIZE];
 
         for ( ; words_cur < words_off; words_cur++) get_next_word (hashcat_ctx_tmp, fd, &line_buf, &line_len);
 
@@ -510,7 +511,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
 
           if (run_rule_engine ((int) user_options_extra->rule_len_l, user_options->rule_buf_l))
           {
-            if (line_len >= BLOCK_SIZE) continue;
+            if (line_len >= RP_PASSWORD_SIZE) continue;
 
             memset (rule_buf_out, 0, sizeof (rule_buf_out));
 
diff --git a/src/hashes.c b/src/hashes.c
index 8de767f72..a0397c74d 100644
--- a/src/hashes.c
+++ b/src/hashes.c
@@ -263,10 +263,10 @@ void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
 
   // debug
 
-  u8  debug_rule_buf[BLOCK_SIZE] = { 0 };
+  u8  debug_rule_buf[RP_PASSWORD_SIZE] = { 0 };
   int debug_rule_len  = 0; // -1 error
 
-  u8  debug_plain_ptr[BLOCK_SIZE] = { 0 };
+  u8  debug_plain_ptr[RP_PASSWORD_SIZE] = { 0 };
   int debug_plain_len = 0;
 
   build_debugdata (hashcat_ctx, device_param, plain, debug_rule_buf, &debug_rule_len, debug_plain_ptr, &debug_plain_len);
diff --git a/src/opencl.c b/src/opencl.c
index ee9ab76ef..f5ee60394 100644
--- a/src/opencl.c
+++ b/src/opencl.c
@@ -10,6 +10,7 @@
 #include "thread.h"
 #include "timer.h"
 #include "tuningdb.h"
+#include "rp.h"
 #include "rp_cpu.h"
 #include "mpsp.h"
 #include "straight.h"
@@ -2038,11 +2039,11 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
 
               char *line_buf_new = line_buf;
 
-              char rule_buf_out[BLOCK_SIZE];
+              char rule_buf_out[RP_PASSWORD_SIZE];
 
               if (run_rule_engine (user_options_extra->rule_len_r, user_options->rule_buf_r))
               {
-                if (line_len >= BLOCK_SIZE) continue;
+                if (line_len >= RP_PASSWORD_SIZE) continue;
 
                 memset (rule_buf_out, 0, sizeof (rule_buf_out));
 
@@ -2155,11 +2156,11 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
 
               char *line_buf_new = line_buf;
 
-              char rule_buf_out[BLOCK_SIZE];
+              char rule_buf_out[RP_PASSWORD_SIZE];
 
               if (run_rule_engine (user_options_extra->rule_len_r, user_options->rule_buf_r))
               {
-                if (line_len >= BLOCK_SIZE) continue;
+                if (line_len >= RP_PASSWORD_SIZE) continue;
 
                 memset (rule_buf_out, 0, sizeof (rule_buf_out));
 
diff --git a/src/rp.c b/src/rp.c
index a7f106a91..36a8181fd 100644
--- a/src/rp.c
+++ b/src/rp.c
@@ -137,7 +137,7 @@ int conv_itoc (const u8 c)
   return -1;
 }
 
-int generate_random_rule (char rule_buf[RP_RULE_BUFSIZ], const u32 rp_gen_func_min, const u32 rp_gen_func_max)
+int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min, const u32 rp_gen_func_max)
 {
   u32 rp_gen_num = get_random_num (rp_gen_func_min, rp_gen_func_max);
 
@@ -731,9 +731,6 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32
 
     char *rp_file = user_options->rp_files[i];
 
-    char in[BLOCK_SIZE]  = { 0 };
-    char out[BLOCK_SIZE] = { 0 };
-
     FILE *fp = NULL;
 
     u32 rule_line = 0;
@@ -767,8 +764,11 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32
         kernel_rules_avail += INCR_RULES;
       }
 
-      memset (in,  0, BLOCK_SIZE);
-      memset (out, 0, BLOCK_SIZE);
+      char in[RP_PASSWORD_SIZE];
+      char out[RP_PASSWORD_SIZE];
+
+      memset (in,  0, sizeof (in));
+      memset (out, 0, sizeof (out));
 
       int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
 
@@ -872,11 +872,11 @@ int kernel_rules_generate (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf,
   u32            kernel_rules_cnt = 0;
   kernel_rule_t *kernel_rules_buf = hccalloc (user_options->rp_gen, sizeof (kernel_rule_t));
 
-  char *rule_buf = (char *) hcmalloc (RP_RULE_BUFSIZ);
+  char *rule_buf = (char *) hcmalloc (RP_RULE_SIZE);
 
   for (kernel_rules_cnt = 0; kernel_rules_cnt < user_options->rp_gen; kernel_rules_cnt++)
   {
-    memset (rule_buf, 0, RP_RULE_BUFSIZ);
+    memset (rule_buf, 0, RP_RULE_SIZE);
 
     int rule_len = (int) generate_random_rule (rule_buf, user_options->rp_gen_func_min, user_options->rp_gen_func_max);
 
diff --git a/src/rp_cpu.c b/src/rp_cpu.c
index 2568f1c55..4b89532dc 100644
--- a/src/rp_cpu.c
+++ b/src/rp_cpu.c
@@ -11,7 +11,8 @@
 #define NEXT_RULEPOS(rp)      if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
 #define NEXT_RPTOI(r,rp,up)   if (((up) = conv_pos ((r)[(rp)], pos_mem)) == -1) return (RULE_RC_SYNTAX_ERROR)
 
-static int conv_pos (const u8 c, const int pos_mem) {
+static int conv_pos (const u8 c, const int pos_mem)
+{
   if (c == RULE_LAST_REJECTED_SAVED_POS)
   {
     return pos_mem;
@@ -44,7 +45,7 @@ static void MANGLE_SWITCH (char *arr, const int l, const int r)
   arr[l] = c;
 }
 
-static int mangle_lrest (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_lrest (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   int pos;
 
@@ -53,7 +54,7 @@ static int mangle_lrest (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len);
 }
 
-static int mangle_urest (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_urest (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   int pos;
 
@@ -62,7 +63,7 @@ static int mangle_urest (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len);
 }
 
-static int mangle_trest (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_trest (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   int pos;
 
@@ -71,7 +72,7 @@ static int mangle_trest (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len);
 }
 
-static int mangle_reverse (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_reverse (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   int l;
 
@@ -87,18 +88,18 @@ static int mangle_reverse (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len);
 }
 
-static int mangle_double (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_double (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
-  if ((arr_len * 2) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len * 2) >= RP_PASSWORD_SIZE) return (arr_len);
 
   memcpy (&arr[arr_len], arr, (size_t) arr_len);
 
   return (arr_len * 2);
 }
 
-static int mangle_double_times (char arr[BLOCK_SIZE], int arr_len, int times)
+static int mangle_double_times (char arr[RP_PASSWORD_SIZE], int arr_len, int times)
 {
-  if (((arr_len * times) + arr_len) >= BLOCK_SIZE) return (arr_len);
+  if (((arr_len * times) + arr_len) >= RP_PASSWORD_SIZE) return (arr_len);
 
   int orig_len = arr_len;
 
@@ -114,9 +115,9 @@ static int mangle_double_times (char arr[BLOCK_SIZE], int arr_len, int times)
   return (arr_len);
 }
 
-static int mangle_reflect (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_reflect (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
-  if ((arr_len * 2) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len * 2) >= RP_PASSWORD_SIZE) return (arr_len);
 
   mangle_double (arr, arr_len);
 
@@ -125,7 +126,7 @@ static int mangle_reflect (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len * 2);
 }
 
-static int mangle_rotate_left (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_rotate_left (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   int l;
   int r;
@@ -138,7 +139,7 @@ static int mangle_rotate_left (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len);
 }
 
-static int mangle_rotate_right (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_rotate_right (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   int l;
   int r;
@@ -151,18 +152,18 @@ static int mangle_rotate_right (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len);
 }
 
-static int mangle_append (char arr[BLOCK_SIZE], int arr_len, char c)
+static int mangle_append (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
 {
-  if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + 1) >= RP_PASSWORD_SIZE) return (arr_len);
 
   arr[arr_len] = c;
 
   return (arr_len + 1);
 }
 
-static int mangle_prepend (char arr[BLOCK_SIZE], int arr_len, char c)
+static int mangle_prepend (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
 {
-  if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + 1) >= RP_PASSWORD_SIZE) return (arr_len);
 
   int arr_pos;
 
@@ -176,7 +177,7 @@ static int mangle_prepend (char arr[BLOCK_SIZE], int arr_len, char c)
   return (arr_len + 1);
 }
 
-static int mangle_delete_at (char arr[BLOCK_SIZE], int arr_len, int upos)
+static int mangle_delete_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -190,7 +191,7 @@ static int mangle_delete_at (char arr[BLOCK_SIZE], int arr_len, int upos)
   return (arr_len - 1);
 }
 
-static int mangle_extract (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
+static int mangle_extract (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int ulen)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -206,7 +207,7 @@ static int mangle_extract (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen
   return (ulen);
 }
 
-static int mangle_omit (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
+static int mangle_omit (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int ulen)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -222,11 +223,11 @@ static int mangle_omit (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
   return (arr_len - ulen);
 }
 
-static int mangle_insert (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
+static int mangle_insert (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, char c)
 {
   if (upos > arr_len) return (arr_len);
 
-  if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + 1) >= RP_PASSWORD_SIZE) return (arr_len);
 
   int arr_pos;
 
@@ -240,9 +241,9 @@ static int mangle_insert (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
   return (arr_len + 1);
 }
 
-static int mangle_insert_multi (char arr[BLOCK_SIZE], int arr_len, int arr_pos, char arr2[BLOCK_SIZE], int arr2_len, int arr2_pos, int arr2_cpy)
+static int mangle_insert_multi (char arr[RP_PASSWORD_SIZE], int arr_len, int arr_pos, char arr2[RP_PASSWORD_SIZE], int arr2_len, int arr2_pos, int arr2_cpy)
 {
-  if ((arr_len + arr2_cpy) > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
+  if ((arr_len + arr2_cpy) > RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
 
   if (arr_pos > arr_len) return (RULE_RC_REJECT_ERROR);
 
@@ -261,7 +262,7 @@ static int mangle_insert_multi (char arr[BLOCK_SIZE], int arr_len, int arr_pos,
   return (arr_len + arr2_cpy);
 }
 
-static int mangle_overstrike (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
+static int mangle_overstrike (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, char c)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -270,7 +271,7 @@ static int mangle_overstrike (char arr[BLOCK_SIZE], int arr_len, int upos, char
   return (arr_len);
 }
 
-static int mangle_truncate_at (char arr[BLOCK_SIZE], int arr_len, int upos)
+static int mangle_truncate_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -279,7 +280,7 @@ static int mangle_truncate_at (char arr[BLOCK_SIZE], int arr_len, int upos)
   return (upos);
 }
 
-static int mangle_replace (char arr[BLOCK_SIZE], int arr_len, char oldc, char newc)
+static int mangle_replace (char arr[RP_PASSWORD_SIZE], int arr_len, char oldc, char newc)
 {
   int arr_pos;
 
@@ -293,7 +294,7 @@ static int mangle_replace (char arr[BLOCK_SIZE], int arr_len, char oldc, char ne
   return (arr_len);
 }
 
-static int mangle_purgechar (char arr[BLOCK_SIZE], int arr_len, char c)
+static int mangle_purgechar (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
 {
   int arr_pos;
 
@@ -311,11 +312,11 @@ static int mangle_purgechar (char arr[BLOCK_SIZE], int arr_len, char c)
   return (ret_len);
 }
 
-static int mangle_dupeblock_prepend (char arr[BLOCK_SIZE], int arr_len, int ulen)
+static int mangle_dupeblock_prepend (char arr[RP_PASSWORD_SIZE], int arr_len, int ulen)
 {
   if (ulen > arr_len) return (arr_len);
 
-  if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + ulen) >= RP_PASSWORD_SIZE) return (arr_len);
 
   char cs[100] = { 0 };
 
@@ -333,11 +334,11 @@ static int mangle_dupeblock_prepend (char arr[BLOCK_SIZE], int arr_len, int ulen
   return (arr_len);
 }
 
-static int mangle_dupeblock_append (char arr[BLOCK_SIZE], int arr_len, int ulen)
+static int mangle_dupeblock_append (char arr[RP_PASSWORD_SIZE], int arr_len, int ulen)
 {
   if (ulen > arr_len) return (arr_len);
 
-  if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + ulen) >= RP_PASSWORD_SIZE) return (arr_len);
 
   int upos = arr_len - ulen;
 
@@ -353,10 +354,10 @@ static int mangle_dupeblock_append (char arr[BLOCK_SIZE], int arr_len, int ulen)
   return (arr_len);
 }
 
-static int mangle_dupechar_at (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
+static int mangle_dupechar_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int ulen)
 {
   if ( arr_len         ==  0) return (arr_len);
-  if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + ulen) >= RP_PASSWORD_SIZE) return (arr_len);
 
   char c = arr[upos];
 
@@ -370,10 +371,10 @@ static int mangle_dupechar_at (char arr[BLOCK_SIZE], int arr_len, int upos, int
   return (arr_len);
 }
 
-static int mangle_dupechar (char arr[BLOCK_SIZE], int arr_len)
+static int mangle_dupechar (char arr[RP_PASSWORD_SIZE], int arr_len)
 {
   if ( arr_len            ==  0) return (arr_len);
-  if ((arr_len + arr_len) >= BLOCK_SIZE) return (arr_len);
+  if ((arr_len + arr_len) >= RP_PASSWORD_SIZE) return (arr_len);
 
   int arr_pos;
 
@@ -389,7 +390,7 @@ static int mangle_dupechar (char arr[BLOCK_SIZE], int arr_len)
   return (arr_len * 2);
 }
 
-static int mangle_switch_at_check (char arr[BLOCK_SIZE], int arr_len, int upos, int upos2)
+static int mangle_switch_at_check (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int upos2)
 {
   if (upos  >= arr_len) return (arr_len);
   if (upos2 >= arr_len) return (arr_len);
@@ -399,14 +400,14 @@ static int mangle_switch_at_check (char arr[BLOCK_SIZE], int arr_len, int upos,
   return (arr_len);
 }
 
-static int mangle_switch_at (char arr[BLOCK_SIZE], int arr_len, int upos, int upos2)
+static int mangle_switch_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int upos2)
 {
   MANGLE_SWITCH (arr, upos, upos2);
 
   return (arr_len);
 }
 
-static int mangle_chr_shiftl (char arr[BLOCK_SIZE], int arr_len, int upos)
+static int mangle_chr_shiftl (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -415,7 +416,7 @@ static int mangle_chr_shiftl (char arr[BLOCK_SIZE], int arr_len, int upos)
   return (arr_len);
 }
 
-static int mangle_chr_shiftr (char arr[BLOCK_SIZE], int arr_len, int upos)
+static int mangle_chr_shiftr (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -424,7 +425,7 @@ static int mangle_chr_shiftr (char arr[BLOCK_SIZE], int arr_len, int upos)
   return (arr_len);
 }
 
-static int mangle_chr_incr (char arr[BLOCK_SIZE], int arr_len, int upos)
+static int mangle_chr_incr (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -433,7 +434,7 @@ static int mangle_chr_incr (char arr[BLOCK_SIZE], int arr_len, int upos)
   return (arr_len);
 }
 
-static int mangle_chr_decr (char arr[BLOCK_SIZE], int arr_len, int upos)
+static int mangle_chr_decr (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
 {
   if (upos >= arr_len) return (arr_len);
 
@@ -442,7 +443,7 @@ static int mangle_chr_decr (char arr[BLOCK_SIZE], int arr_len, int upos)
   return (arr_len);
 }
 
-static int mangle_title_sep (char arr[BLOCK_SIZE], int arr_len, char c)
+static int mangle_title_sep (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
 {
   int upper_next = 1;
 
@@ -472,16 +473,17 @@ static int mangle_title_sep (char arr[BLOCK_SIZE], int arr_len, char c)
   return (arr_len);
 }
 
-int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len, char out[BLOCK_SIZE])
+int _old_apply_rule (char *rule, int rule_len, char in[RP_PASSWORD_SIZE], int in_len, char out[RP_PASSWORD_SIZE])
 {
-  char mem[BLOCK_SIZE] = { 0 };
+  char mem[RP_PASSWORD_SIZE] = { 0 };
+
   int pos_mem = -1;
 
   if (in == NULL) return (RULE_RC_REJECT_ERROR);
 
   if (out == NULL) return (RULE_RC_REJECT_ERROR);
 
-  if (in_len < 1 || in_len > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
+  if (in_len < 1 || in_len > RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
 
   if (rule_len < 1) return (RULE_RC_REJECT_ERROR);
 
@@ -736,14 +738,14 @@ int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len,
 
       case RULE_OP_MANGLE_APPEND_MEMORY:
         if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
-        if ((out_len + mem_len) >= BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
+        if ((out_len + mem_len) >= RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
         memcpy (out + out_len, mem, mem_len);
         out_len += mem_len;
         break;
 
       case RULE_OP_MANGLE_PREPEND_MEMORY:
         if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
-        if ((mem_len + out_len) >= BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
+        if ((mem_len + out_len) >= RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
         memcpy (mem + mem_len, out, out_len);
         out_len += mem_len;
         memcpy (out, mem, out_len);
@@ -814,7 +816,8 @@ int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len,
         if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
         NEXT_RULEPOS (rule_pos);
         int c; int cnt;
-        for (c = 0, cnt = 0; c < out_len && cnt < upos; c++) {
+        for (c = 0, cnt = 0; c < out_len && cnt < upos; c++)
+        {
           if (out[c] == rule[rule_pos])
           {
             cnt++;
@@ -834,7 +837,7 @@ int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len,
     }
   }
 
-  memset (out + out_len, 0, BLOCK_SIZE - out_len);
+  memset (out + out_len, 0, RP_PASSWORD_SIZE - out_len);
 
   return (out_len);
 }
diff --git a/src/wordlist.c b/src/wordlist.c
index a95b4fb74..7593c1cac 100644
--- a/src/wordlist.c
+++ b/src/wordlist.c
@@ -10,6 +10,7 @@
 #include "convert.h"
 #include "dictstat.h"
 #include "thread.h"
+#include "rp.h"
 #include "rp_cpu.h"
 #include "shared.h"
 #include "wordlist.h"
@@ -203,9 +204,9 @@ void get_next_word (hashcat_ctx_t *hashcat_ctx, FILE *fd, char **out_buf, u32 *o
 
     if (run_rule_engine (user_options_extra->rule_len_l, user_options->rule_buf_l))
     {
-      if (len >= BLOCK_SIZE) continue;
+      if (len >= RP_PASSWORD_SIZE) continue;
 
-      char rule_buf_out[BLOCK_SIZE];
+      char rule_buf_out[RP_PASSWORD_SIZE];
 
       memset (rule_buf_out, 0, sizeof (rule_buf_out));
 
@@ -400,9 +401,9 @@ int count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile, u64
 
       if (run_rule_engine (user_options_extra->rule_len_l, user_options->rule_buf_l))
       {
-        if (len >= BLOCK_SIZE) continue;
+        if (len >= RP_PASSWORD_SIZE) continue;
 
-        char rule_buf_out[BLOCK_SIZE];
+        char rule_buf_out[RP_PASSWORD_SIZE];
 
         memset (rule_buf_out, 0, sizeof (rule_buf_out));