diff --git a/OpenCL/inc_cipher_aes-gcm.cl b/OpenCL/inc_cipher_aes-gcm.cl
new file mode 100644
index 000000000..5ea054fb3
--- /dev/null
+++ b/OpenCL/inc_cipher_aes-gcm.cl
@@ -0,0 +1,306 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.h"
+#include "inc_common.h"
+#include "inc_cipher_aes.h"
+#include "inc_cipher_aes-gcm.h"
+
+DECLSPEC void AES_GCM_inc32 (u32 *block)
+{
+  block[3] += 1;
+}
+
+DECLSPEC void AES_GCM_xor_block (u32 *dst, const u32 *src)
+{
+  dst[0] ^= src[0];
+  dst[1] ^= src[1];
+  dst[2] ^= src[2];
+  dst[3] ^= src[3];
+}
+
+DECLSPEC void AES_GCM_gf_mult (const u32 *x, const u32 *y, u32 *z)
+{
+  z[0] = 0;
+  z[1] = 0;
+  z[2] = 0;
+  z[3] = 0;
+
+  u32 t[4];
+
+  t[0] = y[0];
+  t[1] = y[1];
+  t[2] = y[2];
+  t[3] = y[3];
+
+  for (int i = 0; i < 4; i++)
+  {
+    const u32 tv = x[i];
+
+    for (int j = 0; j < 32; j++)
+    {
+      if ((tv >> (31 - j)) & 1)
+      {
+        z[0] ^= t[0];
+        z[1] ^= t[1];
+        z[2] ^= t[2];
+        z[3] ^= t[3];
+      }
+
+      const int m = t[3] & 1; // save lost bit
+
+      t[3] = (t[2] << 31) | (t[3] >> 1);
+      t[2] = (t[1] << 31) | (t[2] >> 1);
+      t[1] = (t[0] << 31) | (t[1] >> 1);
+      t[0] =            0 | (t[0] >> 1);
+
+      t[0] ^= m * 0xe1000000;
+    }
+  }
+}
+
+DECLSPEC void AES_GCM_ghash (const u32 *subkey, const u32 *in, int in_len, u32 *out)
+{
+  int i;
+  int j;
+
+  for (i = 0, j = 0; i < in_len - 15; i += 16, j += 4)
+  {
+    u32 t2[4];
+
+    t2[0] = in[j + 0];
+    t2[1] = in[j + 1];
+    t2[2] = in[j + 2];
+    t2[3] = in[j + 3];
+
+    AES_GCM_xor_block (out, t2);
+
+    u32 tmp[4];
+
+    AES_GCM_gf_mult (out, subkey, tmp);
+
+    out[0] = tmp[0];
+    out[1] = tmp[1];
+    out[2] = tmp[2];
+    out[3] = tmp[3];
+  }
+
+  const int left = in_len - i;
+
+  if (left > 0)
+  {
+    u32 t2[4];
+
+    t2[0] = (left >  0) ? in[j + 0] : 0;
+    t2[1] = (left >  4) ? in[j + 1] : 0;
+    t2[2] = (left >  8) ? in[j + 2] : 0;
+    t2[3] = (left > 12) ? in[j + 3] : 0;
+
+    AES_GCM_xor_block (out, t2);
+
+    u32 tmp[4];
+
+    AES_GCM_gf_mult (out, subkey, tmp);
+
+    out[0] = tmp[0];
+    out[1] = tmp[1];
+    out[2] = tmp[2];
+    out[3] = tmp[3];
+  }
+}
+
+DECLSPEC void AES_GCM_ghash_global (const u32 *subkey, GLOBAL_AS const u32 *in, int in_len, u32 *out)
+{
+  int i;
+  int j;
+
+  for (i = 0, j = 0; i < in_len - 15; i += 16, j += 4)
+  {
+    u32 t2[4];
+
+    t2[0] = in[j + 0];
+    t2[1] = in[j + 1];
+    t2[2] = in[j + 2];
+    t2[3] = in[j + 3];
+
+    AES_GCM_xor_block (out, t2);
+
+    u32 tmp[4];
+
+    AES_GCM_gf_mult (out, subkey, tmp);
+
+    out[0] = tmp[0];
+    out[1] = tmp[1];
+    out[2] = tmp[2];
+    out[3] = tmp[3];
+  }
+
+  const int left = in_len - i;
+
+  if (left > 0)
+  {
+    u32 t2[4];
+
+    t2[0] = (left >  0) ? in[j + 0] : 0;
+    t2[1] = (left >  4) ? in[j + 1] : 0;
+    t2[2] = (left >  8) ? in[j + 2] : 0;
+    t2[3] = (left > 12) ? in[j + 3] : 0;
+
+    AES_GCM_xor_block (out, t2);
+
+    u32 tmp[4];
+
+    AES_GCM_gf_mult (out, subkey, tmp);
+
+    out[0] = tmp[0];
+    out[1] = tmp[1];
+    out[2] = tmp[2];
+    out[3] = tmp[3];
+  }
+}
+
+DECLSPEC void AES_GCM_Init (const u32 *ukey, int key_len, u32 *key, u32 *subkey, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4)
+{
+  if (key_len == 128)
+  {
+    AES128_set_encrypt_key (key, ukey, s_te0, s_te1, s_te2, s_te3);
+
+    AES192_encrypt (key, subkey, subkey, s_te0, s_te1, s_te2, s_te3, s_te4);
+  }
+  else if (key_len == 192)
+  {
+    AES192_set_encrypt_key (key, ukey, s_te0, s_te1, s_te2, s_te3);
+
+    AES192_encrypt (key, subkey, subkey, s_te0, s_te1, s_te2, s_te3, s_te4);
+  }
+  else if (key_len == 256)
+  {
+    AES256_set_encrypt_key (key, ukey, s_te0, s_te1, s_te2, s_te3);
+
+    AES256_encrypt (key, subkey, subkey, s_te0, s_te1, s_te2, s_te3, s_te4);
+  }
+}
+
+DECLSPEC void AES_GCM_Prepare_J0 (const u32 *iv, int iv_len, const u32 *subkey, u32 *J0)
+{
+  if (iv_len == 12)
+  {
+    J0[0] = iv[0];
+    J0[1] = iv[1];
+    J0[2] = iv[2];
+    J0[3] = 0x00000001;
+  }
+  else
+  {
+    AES_GCM_gf_mult (iv, subkey, J0);
+
+    u32 len_buf[4] = { 0 };
+
+    len_buf[3] = iv_len * 8;
+
+    AES_GCM_xor_block (len_buf, J0);
+
+    AES_GCM_gf_mult (len_buf, subkey, J0);
+  }
+}
+
+DECLSPEC void AES_GCM_gctr (const u32 *key, const u32 *iv, const u32 *in, int in_len, u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4)
+{
+  const u32 *xpos = in;
+
+  u32 *ypos = out;
+
+  u32 iv_buf[4];
+
+  iv_buf[0] = iv[0];
+  iv_buf[1] = iv[1];
+  iv_buf[2] = iv[2];
+  iv_buf[3] = iv[3];
+
+  const int n = in_len / 16;
+
+  for (u32 i = 0; i < n; i++)
+  {
+    AES256_encrypt (key, iv_buf, ypos, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+    AES_GCM_xor_block (ypos, xpos);
+
+    xpos += 4;
+    ypos += 4;
+
+    AES_GCM_inc32 (iv_buf);
+  }
+
+  // this is not byte accurate but 4-byte accurate. needs fix?
+
+  int last = in + (in_len/4) - xpos;
+
+  if (last)
+  {
+    u32 tmp[4] = { 0 };
+
+    AES256_encrypt (key, iv_buf, tmp, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+    if (last >= 1) *ypos++ = *xpos++ ^ tmp[0];
+    if (last >= 2) *ypos++ = *xpos++ ^ tmp[1];
+    if (last >= 3) *ypos++ = *xpos++ ^ tmp[2];
+  }
+}
+
+DECLSPEC void AES_GCM_GCTR (u32 *key, u32 *J0, const u32 *in, int in_len, u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4)
+{
+  u32 J0_incr[4];
+
+  J0_incr[0] = J0[0];
+  J0_incr[1] = J0[1];
+  J0_incr[2] = J0[2];
+  J0_incr[3] = J0[3];
+
+  AES_GCM_gctr (key, J0_incr, in, in_len, out, s_te0, s_te1, s_te2, s_te3, s_te4);
+}
+
+DECLSPEC void AES_GCM_GHASH (const u32 *subkey, const u32 *aad_buf, int aad_len, const u32 *enc_buf, int enc_len, u32 *out)
+{
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+
+  AES_GCM_ghash (subkey, aad_buf, aad_len, out);
+
+  AES_GCM_ghash (subkey, enc_buf, enc_len, out);
+
+  u32 len_buf[4];
+
+  len_buf[0] = aad_len * 8;
+  len_buf[1] = 0;
+  len_buf[2] = 0;
+  len_buf[3] = enc_len * 8;
+
+  AES_GCM_ghash (subkey, len_buf, 16, out);
+}
+
+DECLSPEC void AES_GCM_GHASH_GLOBAL (const u32 *subkey, const u32 *aad_buf, int aad_len, GLOBAL_AS const u32 *enc_buf, int enc_len, u32 *out)
+{
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+
+  AES_GCM_ghash (subkey, aad_buf, aad_len, out);
+
+  AES_GCM_ghash_global (subkey, enc_buf, enc_len, out);
+
+  u32 len_buf[4];
+
+  len_buf[0] = aad_len * 8;
+  len_buf[1] = 0;
+  len_buf[2] = 0;
+  len_buf[3] = enc_len * 8;
+
+  AES_GCM_ghash (subkey, len_buf, 16, out);
+}
diff --git a/OpenCL/inc_cipher_aes-gcm.h b/OpenCL/inc_cipher_aes-gcm.h
new file mode 100644
index 000000000..753a4d0c7
--- /dev/null
+++ b/OpenCL/inc_cipher_aes-gcm.h
@@ -0,0 +1,21 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#ifndef _INC_CIPHER_AES_GCM_H
+#define _INC_CIPHER_AES_GCM_H
+
+DECLSPEC void AES_GCM_inc32 (u32 *block);
+DECLSPEC void AES_GCM_xor_block (u32 *dst, const u32 *src);
+DECLSPEC void AES_GCM_gf_mult (const u32 *x, const u32 *y, u32 *z);
+DECLSPEC void AES_GCM_ghash (const u32 *subkey, const u32 *in, int in_len, u32 *out);
+DECLSPEC void AES_GCM_ghash_global (const u32 *subkey, GLOBAL_AS const u32 *in, int in_len, u32 *out);
+DECLSPEC void AES_GCM_Init (const u32 *ukey, int key_len, u32 *key, u32 *subkey, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4);
+DECLSPEC void AES_GCM_Prepare_J0 (const u32 *iv, int iv_len, const u32 *subkey, u32 *J0);
+DECLSPEC void AES_GCM_gctr (const u32 *key, const u32 *iv, const u32 *in, int in_len, u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4);
+DECLSPEC void AES_GCM_GCTR (u32 *key, u32 *J0, const u32 *in, int in_len, u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4);
+DECLSPEC void AES_GCM_GHASH (const u32 *subkey, const u32 *aad_buf, int aad_len, const u32 *enc_buf, int enc_len, u32 *out);
+DECLSPEC void AES_GCM_GHASH_GLOBAL (const u32 *subkey, const u32 *aad_buf, int aad_len, GLOBAL_AS const u32 *enc_buf, int enc_len, u32 *out);
+
+#endif // _INC_CIPHER_AES_GCM_H
diff --git a/OpenCL/inc_common.cl b/OpenCL/inc_common.cl
index ba6edcc56..f8fc15724 100644
--- a/OpenCL/inc_common.cl
+++ b/OpenCL/inc_common.cl
@@ -1981,6 +1981,268 @@ DECLSPEC int find_hash (const u32 *digest, const u32 digests_cnt, GLOBAL_AS cons
 }
 #endif
 
+// Constants and some code snippets from unicode.org's ConvertUTF.c
+// Compiler can perfectly translate some of the branches and switch cases this into MOVC
+// which is faster than lookup tables
+
+#define halfShift 10
+
+#define halfBase 0x0010000
+#define halfMask 0x3FF
+
+#define UNI_MAX_BMP          0xFFFF
+#define UNI_SUR_HIGH_START   0xD800
+#define UNI_SUR_HIGH_END     0xDBFF
+#define UNI_SUR_LOW_START    0xDC00
+#define UNI_SUR_LOW_END      0xDFFF
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+
+#define offsetsFromUTF8_0 0x00000000UL
+#define offsetsFromUTF8_1 0x00003080UL
+#define offsetsFromUTF8_2 0x000E2080UL
+#define offsetsFromUTF8_3 0x03C82080UL
+#define offsetsFromUTF8_4 0xFA082080UL
+#define offsetsFromUTF8_5 0x82082080UL
+
+DECLSPEC int utf8_to_utf16le (const u32 *src_buf, int src_len, int src_size, u32 *dst_buf, int dst_size)
+{
+  const u8  *src_ptr = (const u8  *) src_buf;
+        u16 *dst_ptr = (      u16 *) dst_buf;
+
+  int src_pos = 0;
+  int dst_pos = 0;
+  int dst_len = 0;
+
+  while (src_pos < src_len)
+  {
+    const u8 c = src_ptr[src_pos];
+
+    int extraBytesToRead = 0;
+
+    if (c >= 0xfc)
+    {
+      extraBytesToRead = 5;
+    }
+    else if (c >= 0xf8)
+    {
+      extraBytesToRead = 4;
+    }
+    else if (c >= 0xf0)
+    {
+      extraBytesToRead = 3;
+    }
+    else if (c >= 0xe0)
+    {
+      extraBytesToRead = 2;
+    }
+    else if (c >= 0xc0)
+    {
+      extraBytesToRead = 1;
+    }
+
+    if ((src_pos + extraBytesToRead) >= src_size) return dst_len;
+
+    u32 ch = 0;
+
+    switch (extraBytesToRead)
+    {
+      case 5:
+        ch += src_ptr[src_pos++]; ch <<= 6; /* remember, illegal UTF-8 */
+        ch += src_ptr[src_pos++]; ch <<= 6; /* remember, illegal UTF-8 */
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_5;
+        break;
+      case 4:
+        ch += src_ptr[src_pos++]; ch <<= 6; /* remember, illegal UTF-8 */
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_4;
+        break;
+      case 3:
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_3;
+        break;
+      case 2:
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_2;
+        break;
+      case 1:
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_1;
+        break;
+      case 0:
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_0;
+        break;
+    }
+
+    /* Target is a character <= 0xFFFF */
+    if (ch <= UNI_MAX_BMP)
+    {
+      if ((dst_len + 2) >= dst_size) return dst_len;
+
+      dst_ptr[dst_pos++] = (u16) ch;
+
+      dst_len += 2;
+    }
+    else
+    {
+      if ((dst_len + 4) >= dst_size) return dst_len;
+
+      ch -= halfBase;
+
+      dst_ptr[dst_pos++] = (u16) ((ch >> halfShift) + UNI_SUR_HIGH_START);
+      dst_ptr[dst_pos++] = (u16) ((ch  & halfMask)  + UNI_SUR_LOW_START);
+
+      dst_len += 4;
+    }
+  }
+
+  return dst_len;
+}
+
+DECLSPEC int utf8_to_utf16le_global (GLOBAL_AS const u32 *src_buf, int src_len, int src_size, u32 *dst_buf, int dst_size)
+{
+  GLOBAL_AS const u8  *src_ptr = (GLOBAL_AS const u8  *) src_buf;
+                  u16 *dst_ptr = (                u16 *) dst_buf;
+
+  int src_pos = 0;
+  int dst_pos = 0;
+  int dst_len = 0;
+
+  while (src_pos < src_len)
+  {
+    const u8 c = src_ptr[src_pos];
+
+    int extraBytesToRead = 0;
+
+    if (c >= 0xfc)
+    {
+      extraBytesToRead = 5;
+    }
+    else if (c >= 0xf8)
+    {
+      extraBytesToRead = 4;
+    }
+    else if (c >= 0xf0)
+    {
+      extraBytesToRead = 3;
+    }
+    else if (c >= 0xe0)
+    {
+      extraBytesToRead = 2;
+    }
+    else if (c >= 0xc0)
+    {
+      extraBytesToRead = 1;
+    }
+
+    if ((src_pos + extraBytesToRead) >= src_size) return dst_len;
+
+    u32 ch = 0;
+
+    switch (extraBytesToRead)
+    {
+      case 5:
+        ch += src_ptr[src_pos++]; ch <<= 6; /* remember, illegal UTF-8 */
+        ch += src_ptr[src_pos++]; ch <<= 6; /* remember, illegal UTF-8 */
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_5;
+        break;
+      case 4:
+        ch += src_ptr[src_pos++]; ch <<= 6; /* remember, illegal UTF-8 */
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_4;
+        break;
+      case 3:
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_3;
+        break;
+      case 2:
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_2;
+        break;
+      case 1:
+        ch += src_ptr[src_pos++]; ch <<= 6;
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_1;
+        break;
+      case 0:
+        ch += src_ptr[src_pos++];
+        ch -= offsetsFromUTF8_0;
+        break;
+    }
+
+    /* Target is a character <= 0xFFFF */
+    if (ch <= UNI_MAX_BMP)
+    {
+      if ((dst_len + 2) >= dst_size) return dst_len;
+
+      dst_ptr[dst_pos++] = (u16) ch;
+
+      dst_len += 2;
+    }
+    else
+    {
+      if ((dst_len + 4) >= dst_size) return dst_len;
+
+      ch -= halfBase;
+
+      dst_ptr[dst_pos++] = (u16) ((ch >> halfShift) + UNI_SUR_HIGH_START);
+      dst_ptr[dst_pos++] = (u16) ((ch  & halfMask)  + UNI_SUR_LOW_START);
+
+      dst_len += 4;
+    }
+  }
+
+  return dst_len;
+}
+
+#undef halfShift
+
+#undef halfBase
+#undef halfMask
+
+#undef UNI_MAX_BMP
+#undef UNI_SUR_HIGH_START
+#undef UNI_SUR_HIGH_END
+#undef UNI_SUR_LOW_START
+#undef UNI_SUR_LOW_END
+
+#undef offsetsFromUTF8_0
+#undef offsetsFromUTF8_1
+#undef offsetsFromUTF8_2
+#undef offsetsFromUTF8_3
+#undef offsetsFromUTF8_4
+#undef offsetsFromUTF8_5
+
 DECLSPEC int pkcs_padding_bs8 (const u32 *data_buf, const int data_len)
 {
   if (data_len == 0) return -1; // cannot have zero length, is important to avoid out of boundary reads
diff --git a/OpenCL/inc_common.h b/OpenCL/inc_common.h
index ebdbe4675..9b3437326 100644
--- a/OpenCL/inc_common.h
+++ b/OpenCL/inc_common.h
@@ -234,6 +234,8 @@ DECLSPEC int hash_comp (const u32 *d1, GLOBAL_AS const u32 *d2);
 DECLSPEC int find_hash (const u32 *digest, const u32 digests_cnt, GLOBAL_AS const digest_t *digests_buf);
 #endif
 
+DECLSPEC int utf8_to_utf16le (const u32 *src_buf, int src_len, int src_size, u32 *dst_buf, int dst_size);
+DECLSPEC int utf8_to_utf16le_global (GLOBAL_AS const u32 *src_buf, int src_len, int src_size, u32 *dst_buf, int dst_size);
 DECLSPEC int pkcs_padding_bs8 (const u32 *data_buf, const int data_len);
 DECLSPEC int pkcs_padding_bs16 (const u32 *data_buf, const int data_len);
 DECLSPEC int asn1_detect (const u32 *buf, const int len);
diff --git a/OpenCL/inc_hash_md4.cl b/OpenCL/inc_hash_md4.cl
index eeb28cd17..3fa89680c 100644
--- a/OpenCL/inc_hash_md4.cl
+++ b/OpenCL/inc_hash_md4.cl
@@ -363,120 +363,20 @@ DECLSPEC void md4_update_swap (md4_ctx_t *ctx, const u32 *w, const int len)
 
 DECLSPEC void md4_update_utf16le (md4_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    md4_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  md4_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md4_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md4_update_utf16le_swap (md4_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    md4_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-
-  md4_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md4_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md4_update_global (md4_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -619,120 +519,20 @@ DECLSPEC void md4_update_global_swap (md4_ctx_t *ctx, GLOBAL_AS const u32 *w, co
 
 DECLSPEC void md4_update_global_utf16le (md4_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
+  u32 w_utf16_buf[64] = { 0 };
 
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    md4_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  md4_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md4_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md4_update_global_utf16le_swap (md4_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    md4_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  md4_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md4_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md4_final (md4_ctx_t *ctx)
@@ -1068,16 +868,6 @@ DECLSPEC void md4_hmac_update_swap (md4_hmac_ctx_t *ctx, const u32 *w, const int
   md4_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void md4_hmac_update_utf16le (md4_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  md4_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void md4_hmac_update_utf16le_swap (md4_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  md4_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void md4_hmac_update_global (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   md4_update_global (&ctx->ipad, w, len);
@@ -1088,16 +878,6 @@ DECLSPEC void md4_hmac_update_global_swap (md4_hmac_ctx_t *ctx, GLOBAL_AS const
   md4_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void md4_hmac_update_global_utf16le (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  md4_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void md4_hmac_update_global_utf16le_swap (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  md4_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void md4_hmac_final (md4_hmac_ctx_t *ctx)
 {
   md4_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_md4.h b/OpenCL/inc_hash_md4.h
index 7c3b31894..c8b3351a1 100644
--- a/OpenCL/inc_hash_md4.h
+++ b/OpenCL/inc_hash_md4.h
@@ -102,12 +102,8 @@ DECLSPEC void md4_hmac_init_global_swap (md4_hmac_ctx_t *ctx, GLOBAL_AS const u3
 DECLSPEC void md4_hmac_update_64 (md4_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void md4_hmac_update (md4_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void md4_hmac_update_swap (md4_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void md4_hmac_update_utf16le (md4_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void md4_hmac_update_utf16le_swap (md4_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void md4_hmac_update_global (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void md4_hmac_update_global_swap (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void md4_hmac_update_global_utf16le (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void md4_hmac_update_global_utf16le_swap (md4_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void md4_hmac_final (md4_hmac_ctx_t *ctx);
 DECLSPEC void md4_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest);
 DECLSPEC void md4_init_vector (md4_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_md5.cl b/OpenCL/inc_hash_md5.cl
index 3c52c1f40..73d236467 100644
--- a/OpenCL/inc_hash_md5.cl
+++ b/OpenCL/inc_hash_md5.cl
@@ -399,120 +399,20 @@ DECLSPEC void md5_update_swap (md5_ctx_t *ctx, const u32 *w, const int len)
 
 DECLSPEC void md5_update_utf16le (md5_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    md5_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  md5_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md5_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md5_update_utf16le_swap (md5_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    md5_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-
-  md5_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md5_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md5_update_global (md5_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -655,120 +555,20 @@ DECLSPEC void md5_update_global_swap (md5_ctx_t *ctx, GLOBAL_AS const u32 *w, co
 
 DECLSPEC void md5_update_global_utf16le (md5_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
+  u32 w_utf16_buf[64] = { 0 };
 
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    md5_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  md5_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md5_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md5_update_global_utf16le_swap (md5_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    md5_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  md5_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  md5_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void md5_final (md5_ctx_t *ctx)
@@ -1104,16 +904,6 @@ DECLSPEC void md5_hmac_update_swap (md5_hmac_ctx_t *ctx, const u32 *w, const int
   md5_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void md5_hmac_update_utf16le (md5_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  md5_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void md5_hmac_update_utf16le_swap (md5_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  md5_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void md5_hmac_update_global (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   md5_update_global (&ctx->ipad, w, len);
@@ -1124,16 +914,6 @@ DECLSPEC void md5_hmac_update_global_swap (md5_hmac_ctx_t *ctx, GLOBAL_AS const
   md5_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void md5_hmac_update_global_utf16le (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  md5_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void md5_hmac_update_global_utf16le_swap (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  md5_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void md5_hmac_final (md5_hmac_ctx_t *ctx)
 {
   md5_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_md5.h b/OpenCL/inc_hash_md5.h
index 1e6eaaf93..273a35bb3 100644
--- a/OpenCL/inc_hash_md5.h
+++ b/OpenCL/inc_hash_md5.h
@@ -109,12 +109,8 @@ DECLSPEC void md5_hmac_init_global_swap (md5_hmac_ctx_t *ctx, GLOBAL_AS const u3
 DECLSPEC void md5_hmac_update_64 (md5_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void md5_hmac_update (md5_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void md5_hmac_update_swap (md5_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void md5_hmac_update_utf16le (md5_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void md5_hmac_update_utf16le_swap (md5_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void md5_hmac_update_global (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void md5_hmac_update_global_swap (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void md5_hmac_update_global_utf16le (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void md5_hmac_update_global_utf16le_swap (md5_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void md5_hmac_final (md5_hmac_ctx_t *ctx);
 DECLSPEC void md5_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest);
 DECLSPEC void md5_init_vector (md5_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_ripemd160.cl b/OpenCL/inc_hash_ripemd160.cl
index bcf1074ac..1b18f01b8 100644
--- a/OpenCL/inc_hash_ripemd160.cl
+++ b/OpenCL/inc_hash_ripemd160.cl
@@ -497,120 +497,20 @@ DECLSPEC void ripemd160_update_swap (ripemd160_ctx_t *ctx, const u32 *w, const i
 
 DECLSPEC void ripemd160_update_utf16le (ripemd160_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    ripemd160_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  ripemd160_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  ripemd160_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void ripemd160_update_utf16le_swap (ripemd160_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    ripemd160_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-
-  ripemd160_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  ripemd160_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void ripemd160_update_global (ripemd160_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -753,120 +653,20 @@ DECLSPEC void ripemd160_update_global_swap (ripemd160_ctx_t *ctx, GLOBAL_AS cons
 
 DECLSPEC void ripemd160_update_global_utf16le (ripemd160_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
+  u32 w_utf16_buf[64] = { 0 };
 
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    ripemd160_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  ripemd160_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  ripemd160_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void ripemd160_update_global_utf16le_swap (ripemd160_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    ripemd160_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  ripemd160_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  ripemd160_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void ripemd160_final (ripemd160_ctx_t *ctx)
@@ -1202,16 +1002,6 @@ DECLSPEC void ripemd160_hmac_update_swap (ripemd160_hmac_ctx_t *ctx, const u32 *
   ripemd160_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void ripemd160_hmac_update_utf16le (ripemd160_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  ripemd160_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void ripemd160_hmac_update_utf16le_swap (ripemd160_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  ripemd160_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void ripemd160_hmac_update_global (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   ripemd160_update_global (&ctx->ipad, w, len);
@@ -1222,16 +1012,6 @@ DECLSPEC void ripemd160_hmac_update_global_swap (ripemd160_hmac_ctx_t *ctx, GLOB
   ripemd160_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void ripemd160_hmac_update_global_utf16le (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  ripemd160_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void ripemd160_hmac_update_global_utf16le_swap (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  ripemd160_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void ripemd160_hmac_final (ripemd160_hmac_ctx_t *ctx)
 {
   ripemd160_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_ripemd160.h b/OpenCL/inc_hash_ripemd160.h
index 25a69ed56..70fa3f60f 100644
--- a/OpenCL/inc_hash_ripemd160.h
+++ b/OpenCL/inc_hash_ripemd160.h
@@ -122,12 +122,8 @@ DECLSPEC void ripemd160_hmac_init_global_swap (ripemd160_hmac_ctx_t *ctx, GLOBAL
 DECLSPEC void ripemd160_hmac_update_64 (ripemd160_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void ripemd160_hmac_update (ripemd160_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void ripemd160_hmac_update_swap (ripemd160_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void ripemd160_hmac_update_utf16le (ripemd160_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void ripemd160_hmac_update_utf16le_swap (ripemd160_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void ripemd160_hmac_update_global (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void ripemd160_hmac_update_global_swap (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void ripemd160_hmac_update_global_utf16le (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void ripemd160_hmac_update_global_utf16le_swap (ripemd160_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void ripemd160_hmac_final (ripemd160_hmac_ctx_t *ctx);
 DECLSPEC void ripemd160_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest);
 DECLSPEC void ripemd160_init_vector (ripemd160_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_sha1.cl b/OpenCL/inc_hash_sha1.cl
index a8f754c1a..f71f04193 100644
--- a/OpenCL/inc_hash_sha1.cl
+++ b/OpenCL/inc_hash_sha1.cl
@@ -612,120 +612,20 @@ DECLSPEC void sha1_update_swap (sha1_ctx_t *ctx, const u32 *w, const int len)
 
 DECLSPEC void sha1_update_utf16le (sha1_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    sha1_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  sha1_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha1_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha1_update_utf16le_swap (sha1_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    sha1_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  sha1_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha1_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha1_update_utf16be (sha1_ctx_t *ctx, const u32 *w, const int len)
@@ -986,120 +886,20 @@ DECLSPEC void sha1_update_global_swap (sha1_ctx_t *ctx, GLOBAL_AS const u32 *w,
 
 DECLSPEC void sha1_update_global_utf16le (sha1_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  u32 w_utf16_buf[64] = { 0 };
 
-    sha1_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  sha1_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha1_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha1_update_global_utf16le_swap (sha1_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    sha1_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
+  u32 w_utf16_buf[64] = { 0 };
 
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  sha1_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha1_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha1_update_global_utf16be (sha1_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -1553,16 +1353,6 @@ DECLSPEC void sha1_hmac_update_swap (sha1_hmac_ctx_t *ctx, const u32 *w, const i
   sha1_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha1_hmac_update_utf16le (sha1_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha1_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha1_hmac_update_utf16le_swap (sha1_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha1_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha1_hmac_update_global (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   sha1_update_global (&ctx->ipad, w, len);
@@ -1573,16 +1363,6 @@ DECLSPEC void sha1_hmac_update_global_swap (sha1_hmac_ctx_t *ctx, GLOBAL_AS cons
   sha1_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha1_hmac_update_global_utf16le (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha1_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha1_hmac_update_global_utf16le_swap (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha1_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha1_hmac_final (sha1_hmac_ctx_t *ctx)
 {
   sha1_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_sha1.h b/OpenCL/inc_hash_sha1.h
index 2ff36fdad..69f6b58d4 100644
--- a/OpenCL/inc_hash_sha1.h
+++ b/OpenCL/inc_hash_sha1.h
@@ -114,12 +114,8 @@ DECLSPEC void sha1_hmac_init_global_swap (sha1_hmac_ctx_t *ctx, GLOBAL_AS const
 DECLSPEC void sha1_hmac_update_64 (sha1_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void sha1_hmac_update (sha1_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha1_hmac_update_swap (sha1_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha1_hmac_update_utf16le (sha1_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha1_hmac_update_utf16le_swap (sha1_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha1_hmac_update_global (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha1_hmac_update_global_swap (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha1_hmac_update_global_utf16le (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha1_hmac_update_global_utf16le_swap (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha1_hmac_final (sha1_hmac_ctx_t *ctx);
 DECLSPEC void sha1_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest);
 DECLSPEC void sha1_init_vector (sha1_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_sha224.cl b/OpenCL/inc_hash_sha224.cl
index 72f3dac99..a5b780376 100644
--- a/OpenCL/inc_hash_sha224.cl
+++ b/OpenCL/inc_hash_sha224.cl
@@ -414,120 +414,20 @@ DECLSPEC void sha224_update_swap (sha224_ctx_t *ctx, const u32 *w, const int len
 
 DECLSPEC void sha224_update_utf16le (sha224_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    sha224_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  sha224_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha224_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha224_update_utf16le_swap (sha224_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    sha224_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-
-  sha224_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha224_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha224_update_global (sha224_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -670,120 +570,20 @@ DECLSPEC void sha224_update_global_swap (sha224_ctx_t *ctx, GLOBAL_AS const u32
 
 DECLSPEC void sha224_update_global_utf16le (sha224_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
+  u32 w_utf16_buf[64] = { 0 };
 
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    sha224_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  sha224_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha224_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha224_update_global_utf16le_swap (sha224_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    sha224_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  sha224_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha224_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha224_final (sha224_ctx_t *ctx)
@@ -1119,16 +919,6 @@ DECLSPEC void sha224_hmac_update_swap (sha224_hmac_ctx_t *ctx, const u32 *w, con
   sha224_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha224_hmac_update_utf16le (sha224_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha224_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha224_hmac_update_utf16le_swap (sha224_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha224_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha224_hmac_update_global (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   sha224_update_global (&ctx->ipad, w, len);
@@ -1139,16 +929,6 @@ DECLSPEC void sha224_hmac_update_global_swap (sha224_hmac_ctx_t *ctx, GLOBAL_AS
   sha224_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha224_hmac_update_global_utf16le (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha224_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha224_hmac_update_global_utf16le_swap (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha224_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha224_hmac_final (sha224_hmac_ctx_t *ctx)
 {
   sha224_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_sha224.h b/OpenCL/inc_hash_sha224.h
index d68c79d65..46f03a35d 100644
--- a/OpenCL/inc_hash_sha224.h
+++ b/OpenCL/inc_hash_sha224.h
@@ -109,12 +109,8 @@ DECLSPEC void sha224_hmac_init_global_swap (sha224_hmac_ctx_t *ctx, GLOBAL_AS co
 DECLSPEC void sha224_hmac_update_64 (sha224_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void sha224_hmac_update (sha224_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha224_hmac_update_swap (sha224_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha224_hmac_update_utf16le (sha224_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha224_hmac_update_utf16le_swap (sha224_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha224_hmac_update_global (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha224_hmac_update_global_swap (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha224_hmac_update_global_utf16le (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha224_hmac_update_global_utf16le_swap (sha224_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha224_hmac_final (sha224_hmac_ctx_t *ctx);
 DECLSPEC void sha224_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest);
 DECLSPEC void sha224_init_vector (sha224_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_sha256.cl b/OpenCL/inc_hash_sha256.cl
index 430b0e8b9..49bb19f3d 100644
--- a/OpenCL/inc_hash_sha256.cl
+++ b/OpenCL/inc_hash_sha256.cl
@@ -414,120 +414,20 @@ DECLSPEC void sha256_update_swap (sha256_ctx_t *ctx, const u32 *w, const int len
 
 DECLSPEC void sha256_update_utf16le (sha256_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    sha256_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  sha256_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha256_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha256_update_utf16le_swap (sha256_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    sha256_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-
-  sha256_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha256_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha256_update_global (sha256_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -670,120 +570,20 @@ DECLSPEC void sha256_update_global_swap (sha256_ctx_t *ctx, GLOBAL_AS const u32
 
 DECLSPEC void sha256_update_global_utf16le (sha256_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
+  u32 w_utf16_buf[64] = { 0 };
 
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    sha256_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  sha256_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha256_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha256_update_global_utf16le_swap (sha256_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    sha256_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  sha256_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  sha256_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha256_final (sha256_ctx_t *ctx)
@@ -1119,16 +919,6 @@ DECLSPEC void sha256_hmac_update_swap (sha256_hmac_ctx_t *ctx, const u32 *w, con
   sha256_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha256_hmac_update_utf16le (sha256_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha256_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha256_hmac_update_utf16le_swap (sha256_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha256_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha256_hmac_update_global (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   sha256_update_global (&ctx->ipad, w, len);
@@ -1139,16 +929,6 @@ DECLSPEC void sha256_hmac_update_global_swap (sha256_hmac_ctx_t *ctx, GLOBAL_AS
   sha256_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha256_hmac_update_global_utf16le (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha256_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha256_hmac_update_global_utf16le_swap (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha256_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha256_hmac_final (sha256_hmac_ctx_t *ctx)
 {
   sha256_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_sha256.h b/OpenCL/inc_hash_sha256.h
index ccf5a79f8..bc655d80b 100644
--- a/OpenCL/inc_hash_sha256.h
+++ b/OpenCL/inc_hash_sha256.h
@@ -109,12 +109,8 @@ DECLSPEC void sha256_hmac_init_global_swap (sha256_hmac_ctx_t *ctx, GLOBAL_AS co
 DECLSPEC void sha256_hmac_update_64 (sha256_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void sha256_hmac_update (sha256_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha256_hmac_update_swap (sha256_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha256_hmac_update_utf16le (sha256_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha256_hmac_update_utf16le_swap (sha256_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha256_hmac_update_global (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha256_hmac_update_global_swap (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha256_hmac_update_global_utf16le (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha256_hmac_update_global_utf16le_swap (sha256_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha256_hmac_final (sha256_hmac_ctx_t *ctx);
 DECLSPEC void sha256_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest);
 DECLSPEC void sha256_init_vector (sha256_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_sha384.cl b/OpenCL/inc_hash_sha384.cl
index d63a5ab2b..ef09c26f6 100644
--- a/OpenCL/inc_hash_sha384.cl
+++ b/OpenCL/inc_hash_sha384.cl
@@ -622,200 +622,20 @@ DECLSPEC void sha384_update_swap (sha384_ctx_t *ctx, const u32 *w, const int len
 
 DECLSPEC void sha384_update_utf16le (sha384_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
-
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha384_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha384_update_utf16le_swap (sha384_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
-
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-    w4[0] = hc_swap32_S (w4[0]);
-    w4[1] = hc_swap32_S (w4[1]);
-    w4[2] = hc_swap32_S (w4[2]);
-    w4[3] = hc_swap32_S (w4[3]);
-    w5[0] = hc_swap32_S (w5[0]);
-    w5[1] = hc_swap32_S (w5[1]);
-    w5[2] = hc_swap32_S (w5[2]);
-    w5[3] = hc_swap32_S (w5[3]);
-    w6[0] = hc_swap32_S (w6[0]);
-    w6[1] = hc_swap32_S (w6[1]);
-    w6[2] = hc_swap32_S (w6[2]);
-    w6[3] = hc_swap32_S (w6[3]);
-    w7[0] = hc_swap32_S (w7[0]);
-    w7[1] = hc_swap32_S (w7[1]);
-    w7[2] = hc_swap32_S (w7[2]);
-    w7[3] = hc_swap32_S (w7[3]);
-
-    sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-  w4[0] = hc_swap32_S (w4[0]);
-  w4[1] = hc_swap32_S (w4[1]);
-  w4[2] = hc_swap32_S (w4[2]);
-  w4[3] = hc_swap32_S (w4[3]);
-  w5[0] = hc_swap32_S (w5[0]);
-  w5[1] = hc_swap32_S (w5[1]);
-  w5[2] = hc_swap32_S (w5[2]);
-  w5[3] = hc_swap32_S (w5[3]);
-  w6[0] = hc_swap32_S (w6[0]);
-  w6[1] = hc_swap32_S (w6[1]);
-  w6[2] = hc_swap32_S (w6[2]);
-  w6[3] = hc_swap32_S (w6[3]);
-  w7[0] = hc_swap32_S (w7[0]);
-  w7[1] = hc_swap32_S (w7[1]);
-  w7[2] = hc_swap32_S (w7[2]);
-  w7[3] = hc_swap32_S (w7[3]);
-
-  sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha384_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha384_update_global (sha384_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -1062,200 +882,20 @@ DECLSPEC void sha384_update_global_swap (sha384_ctx_t *ctx, GLOBAL_AS const u32
 
 DECLSPEC void sha384_update_global_utf16le (sha384_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
-
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha384_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha384_update_global_utf16le_swap (sha384_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
-
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-    w4[0] = hc_swap32_S (w4[0]);
-    w4[1] = hc_swap32_S (w4[1]);
-    w4[2] = hc_swap32_S (w4[2]);
-    w4[3] = hc_swap32_S (w4[3]);
-    w5[0] = hc_swap32_S (w5[0]);
-    w5[1] = hc_swap32_S (w5[1]);
-    w5[2] = hc_swap32_S (w5[2]);
-    w5[3] = hc_swap32_S (w5[3]);
-    w6[0] = hc_swap32_S (w6[0]);
-    w6[1] = hc_swap32_S (w6[1]);
-    w6[2] = hc_swap32_S (w6[2]);
-    w6[3] = hc_swap32_S (w6[3]);
-    w7[0] = hc_swap32_S (w7[0]);
-    w7[1] = hc_swap32_S (w7[1]);
-    w7[2] = hc_swap32_S (w7[2]);
-    w7[3] = hc_swap32_S (w7[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
-
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-  w4[0] = hc_swap32_S (w4[0]);
-  w4[1] = hc_swap32_S (w4[1]);
-  w4[2] = hc_swap32_S (w4[2]);
-  w4[3] = hc_swap32_S (w4[3]);
-  w5[0] = hc_swap32_S (w5[0]);
-  w5[1] = hc_swap32_S (w5[1]);
-  w5[2] = hc_swap32_S (w5[2]);
-  w5[3] = hc_swap32_S (w5[3]);
-  w6[0] = hc_swap32_S (w6[0]);
-  w6[1] = hc_swap32_S (w6[1]);
-  w6[2] = hc_swap32_S (w6[2]);
-  w6[3] = hc_swap32_S (w6[3]);
-  w7[0] = hc_swap32_S (w7[0]);
-  w7[1] = hc_swap32_S (w7[1]);
-  w7[2] = hc_swap32_S (w7[2]);
-  w7[3] = hc_swap32_S (w7[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  sha384_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha384_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha384_final (sha384_ctx_t *ctx)
@@ -1787,16 +1427,6 @@ DECLSPEC void sha384_hmac_update_swap (sha384_hmac_ctx_t *ctx, const u32 *w, con
   sha384_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha384_hmac_update_utf16le (sha384_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha384_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha384_hmac_update_utf16le_swap (sha384_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha384_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha384_hmac_update_global (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   sha384_update_global (&ctx->ipad, w, len);
@@ -1807,16 +1437,6 @@ DECLSPEC void sha384_hmac_update_global_swap (sha384_hmac_ctx_t *ctx, GLOBAL_AS
   sha384_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha384_hmac_update_global_utf16le (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha384_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha384_hmac_update_global_utf16le_swap (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha384_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha384_hmac_final (sha384_hmac_ctx_t *ctx)
 {
   sha384_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_sha384.h b/OpenCL/inc_hash_sha384.h
index 92266b24a..e3705c206 100644
--- a/OpenCL/inc_hash_sha384.h
+++ b/OpenCL/inc_hash_sha384.h
@@ -123,12 +123,8 @@ DECLSPEC void sha384_hmac_init_global_swap (sha384_hmac_ctx_t *ctx, GLOBAL_AS co
 DECLSPEC void sha384_hmac_update_128 (sha384_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, u32 *w4, u32 *w5, u32 *w6, u32 *w7, const int len);
 DECLSPEC void sha384_hmac_update (sha384_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha384_hmac_update_swap (sha384_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha384_hmac_update_utf16le (sha384_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha384_hmac_update_utf16le_swap (sha384_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha384_hmac_update_global (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha384_hmac_update_global_swap (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha384_hmac_update_global_utf16le (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha384_hmac_update_global_utf16le_swap (sha384_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha384_hmac_final (sha384_hmac_ctx_t *ctx);
 DECLSPEC void sha384_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, const u32x *w4, const u32x *w5, const u32x *w6, const u32x *w7, u64x *digest);
 DECLSPEC void sha384_init_vector (sha384_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_sha512.cl b/OpenCL/inc_hash_sha512.cl
index 0f5ca288a..19aee7368 100644
--- a/OpenCL/inc_hash_sha512.cl
+++ b/OpenCL/inc_hash_sha512.cl
@@ -622,200 +622,20 @@ DECLSPEC void sha512_update_swap (sha512_ctx_t *ctx, const u32 *w, const int len
 
 DECLSPEC void sha512_update_utf16le (sha512_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
+  u32 w_utf16_buf[64] = { 0 };
 
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
-
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha512_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha512_update_utf16le_swap (sha512_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
+  u32 w_utf16_buf[64] = { 0 };
 
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-    w4[0] = hc_swap32_S (w4[0]);
-    w4[1] = hc_swap32_S (w4[1]);
-    w4[2] = hc_swap32_S (w4[2]);
-    w4[3] = hc_swap32_S (w4[3]);
-    w5[0] = hc_swap32_S (w5[0]);
-    w5[1] = hc_swap32_S (w5[1]);
-    w5[2] = hc_swap32_S (w5[2]);
-    w5[3] = hc_swap32_S (w5[3]);
-    w6[0] = hc_swap32_S (w6[0]);
-    w6[1] = hc_swap32_S (w6[1]);
-    w6[2] = hc_swap32_S (w6[2]);
-    w6[3] = hc_swap32_S (w6[3]);
-    w7[0] = hc_swap32_S (w7[0]);
-    w7[1] = hc_swap32_S (w7[1]);
-    w7[2] = hc_swap32_S (w7[2]);
-    w7[3] = hc_swap32_S (w7[3]);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-    sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
-
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-  w4[0] = hc_swap32_S (w4[0]);
-  w4[1] = hc_swap32_S (w4[1]);
-  w4[2] = hc_swap32_S (w4[2]);
-  w4[3] = hc_swap32_S (w4[3]);
-  w5[0] = hc_swap32_S (w5[0]);
-  w5[1] = hc_swap32_S (w5[1]);
-  w5[2] = hc_swap32_S (w5[2]);
-  w5[3] = hc_swap32_S (w5[3]);
-  w6[0] = hc_swap32_S (w6[0]);
-  w6[1] = hc_swap32_S (w6[1]);
-  w6[2] = hc_swap32_S (w6[2]);
-  w6[3] = hc_swap32_S (w6[3]);
-  w7[0] = hc_swap32_S (w7[0]);
-  w7[1] = hc_swap32_S (w7[1]);
-  w7[2] = hc_swap32_S (w7[2]);
-  w7[3] = hc_swap32_S (w7[3]);
-
-  sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha512_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha512_update_global (sha512_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -1062,200 +882,20 @@ DECLSPEC void sha512_update_global_swap (sha512_ctx_t *ctx, GLOBAL_AS const u32
 
 DECLSPEC void sha512_update_global_utf16le (sha512_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
-
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  u32 w_utf16_buf[64] = { 0 };
 
-    sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
-
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha512_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha512_update_global_utf16le_swap (sha512_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
+  u32 w_utf16_buf[64] = { 0 };
 
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 64; pos1 += 64, pos4 += 16)
-  {
-    w0[0] = w[pos4 +  0];
-    w0[1] = w[pos4 +  1];
-    w0[2] = w[pos4 +  2];
-    w0[3] = w[pos4 +  3];
-    w1[0] = w[pos4 +  4];
-    w1[1] = w[pos4 +  5];
-    w1[2] = w[pos4 +  6];
-    w1[3] = w[pos4 +  7];
-    w2[0] = w[pos4 +  8];
-    w2[1] = w[pos4 +  9];
-    w2[2] = w[pos4 + 10];
-    w2[3] = w[pos4 + 11];
-    w3[0] = w[pos4 + 12];
-    w3[1] = w[pos4 + 13];
-    w3[2] = w[pos4 + 14];
-    w3[3] = w[pos4 + 15];
-
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-    w4[0] = hc_swap32_S (w4[0]);
-    w4[1] = hc_swap32_S (w4[1]);
-    w4[2] = hc_swap32_S (w4[2]);
-    w4[3] = hc_swap32_S (w4[3]);
-    w5[0] = hc_swap32_S (w5[0]);
-    w5[1] = hc_swap32_S (w5[1]);
-    w5[2] = hc_swap32_S (w5[2]);
-    w5[3] = hc_swap32_S (w5[3]);
-    w6[0] = hc_swap32_S (w6[0]);
-    w6[1] = hc_swap32_S (w6[1]);
-    w6[2] = hc_swap32_S (w6[2]);
-    w6[3] = hc_swap32_S (w6[3]);
-    w7[0] = hc_swap32_S (w7[0]);
-    w7[1] = hc_swap32_S (w7[1]);
-    w7[2] = hc_swap32_S (w7[2]);
-    w7[3] = hc_swap32_S (w7[3]);
-
-    sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, 64 * 2);
-  }
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = w[pos4 +  0];
-  w0[1] = w[pos4 +  1];
-  w0[2] = w[pos4 +  2];
-  w0[3] = w[pos4 +  3];
-  w1[0] = w[pos4 +  4];
-  w1[1] = w[pos4 +  5];
-  w1[2] = w[pos4 +  6];
-  w1[3] = w[pos4 +  7];
-  w2[0] = w[pos4 +  8];
-  w2[1] = w[pos4 +  9];
-  w2[2] = w[pos4 + 10];
-  w2[3] = w[pos4 + 11];
-  w3[0] = w[pos4 + 12];
-  w3[1] = w[pos4 + 13];
-  w3[2] = w[pos4 + 14];
-  w3[3] = w[pos4 + 15];
-
-  make_utf16le_S (w3, w6, w7);
-  make_utf16le_S (w2, w4, w5);
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-  w4[0] = hc_swap32_S (w4[0]);
-  w4[1] = hc_swap32_S (w4[1]);
-  w4[2] = hc_swap32_S (w4[2]);
-  w4[3] = hc_swap32_S (w4[3]);
-  w5[0] = hc_swap32_S (w5[0]);
-  w5[1] = hc_swap32_S (w5[1]);
-  w5[2] = hc_swap32_S (w5[2]);
-  w5[3] = hc_swap32_S (w5[3]);
-  w6[0] = hc_swap32_S (w6[0]);
-  w6[1] = hc_swap32_S (w6[1]);
-  w6[2] = hc_swap32_S (w6[2]);
-  w6[3] = hc_swap32_S (w6[3]);
-  w7[0] = hc_swap32_S (w7[0]);
-  w7[1] = hc_swap32_S (w7[1]);
-  w7[2] = hc_swap32_S (w7[2]);
-  w7[3] = hc_swap32_S (w7[3]);
-
-  sha512_update_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7, (len - pos1) * 2);
+  sha512_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha512_final (sha512_ctx_t *ctx)
@@ -1772,121 +1412,22 @@ DECLSPEC void sha512_hmac_init_global_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS co
   sha512_hmac_init_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7);
 }
 
-DECLSPEC void sha512_hmac_init_global_utf16le_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
+DECLSPEC void sha512_hmac_init_global_ut16le (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-  u32 w4[4];
-  u32 w5[4];
-  u32 w6[4];
-  u32 w7[4];
-
-  const int len_new = len * 2;
-
-  if (len_new > 128)
-  {
-    sha512_ctx_t tmp;
-
-    sha512_init (&tmp);
+  u32 w_utf16_buf[64] = { 0 };
 
-    sha512_update_global_utf16le_swap (&tmp, w, len);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    sha512_final (&tmp);
-
-    w0[0] = h32_from_64_S (tmp.h[0]);
-    w0[1] = l32_from_64_S (tmp.h[0]);
-    w0[2] = h32_from_64_S (tmp.h[1]);
-    w0[3] = l32_from_64_S (tmp.h[1]);
-    w1[0] = h32_from_64_S (tmp.h[2]);
-    w1[1] = l32_from_64_S (tmp.h[2]);
-    w1[2] = h32_from_64_S (tmp.h[3]);
-    w1[3] = l32_from_64_S (tmp.h[3]);
-    w2[0] = h32_from_64_S (tmp.h[4]);
-    w2[1] = l32_from_64_S (tmp.h[4]);
-    w2[2] = h32_from_64_S (tmp.h[5]);
-    w2[3] = l32_from_64_S (tmp.h[5]);
-    w3[0] = h32_from_64_S (tmp.h[6]);
-    w3[1] = l32_from_64_S (tmp.h[6]);
-    w3[2] = h32_from_64_S (tmp.h[7]);
-    w3[3] = l32_from_64_S (tmp.h[7]);
-    w4[0] = 0;
-    w4[1] = 0;
-    w4[2] = 0;
-    w4[3] = 0;
-    w5[0] = 0;
-    w5[1] = 0;
-    w5[2] = 0;
-    w5[3] = 0;
-    w6[0] = 0;
-    w6[1] = 0;
-    w6[2] = 0;
-    w6[3] = 0;
-    w7[0] = 0;
-    w7[1] = 0;
-    w7[2] = 0;
-    w7[3] = 0;
-  }
-  else
-  {
-    w0[0] = w[ 0];
-    w0[1] = w[ 1];
-    w0[2] = w[ 2];
-    w0[3] = w[ 3];
-    w1[0] = w[ 4];
-    w1[1] = w[ 5];
-    w1[2] = w[ 6];
-    w1[3] = w[ 7];
-    w2[0] = w[ 8];
-    w2[1] = w[ 9];
-    w2[2] = w[10];
-    w2[3] = w[11];
-    w3[0] = w[12];
-    w3[1] = w[13];
-    w3[2] = w[14];
-    w3[3] = w[15];
+  sha512_hmac_init (ctx, w_utf16_buf, w_utf16_len);
+}
 
-    make_utf16le_S (w3, w6, w7);
-    make_utf16le_S (w2, w4, w5);
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+DECLSPEC void sha512_hmac_init_global_utf16le_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
+{
+  u32 w_utf16_buf[64] = { 0 };
 
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-    w4[0] = hc_swap32_S (w4[0]);
-    w4[1] = hc_swap32_S (w4[1]);
-    w4[2] = hc_swap32_S (w4[2]);
-    w4[3] = hc_swap32_S (w4[3]);
-    w5[0] = hc_swap32_S (w5[0]);
-    w5[1] = hc_swap32_S (w5[1]);
-    w5[2] = hc_swap32_S (w5[2]);
-    w5[3] = hc_swap32_S (w5[3]);
-    w6[0] = hc_swap32_S (w6[0]);
-    w6[1] = hc_swap32_S (w6[1]);
-    w6[2] = hc_swap32_S (w6[2]);
-    w6[3] = hc_swap32_S (w6[3]);
-    w7[0] = hc_swap32_S (w7[0]);
-    w7[1] = hc_swap32_S (w7[1]);
-    w7[2] = hc_swap32_S (w7[2]);
-    w7[3] = hc_swap32_S (w7[3]);
-  }
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  sha512_hmac_init_128 (ctx, w0, w1, w2, w3, w4, w5, w6, w7);
+  sha512_hmac_init_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void sha512_hmac_update_128 (sha512_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, u32 *w4, u32 *w5, u32 *w6, u32 *w7, const int len)
@@ -1904,16 +1445,6 @@ DECLSPEC void sha512_hmac_update_swap (sha512_hmac_ctx_t *ctx, const u32 *w, con
   sha512_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha512_hmac_update_utf16le (sha512_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha512_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha512_hmac_update_utf16le_swap (sha512_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  sha512_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha512_hmac_update_global (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   sha512_update_global (&ctx->ipad, w, len);
@@ -1924,16 +1455,6 @@ DECLSPEC void sha512_hmac_update_global_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS
   sha512_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void sha512_hmac_update_global_utf16le (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha512_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void sha512_hmac_update_global_utf16le_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  sha512_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void sha512_hmac_final (sha512_hmac_ctx_t *ctx)
 {
   sha512_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_sha512.h b/OpenCL/inc_hash_sha512.h
index c66aa1fb9..7009b7d4a 100644
--- a/OpenCL/inc_hash_sha512.h
+++ b/OpenCL/inc_hash_sha512.h
@@ -120,16 +120,13 @@ DECLSPEC void sha512_hmac_init (sha512_hmac_ctx_t *ctx, const u32 *w, const int
 DECLSPEC void sha512_hmac_init_swap (sha512_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha512_hmac_init_global (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha512_hmac_init_global_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
+DECLSPEC void sha512_hmac_init_global_ut16le (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha512_hmac_init_global_utf16le_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha512_hmac_update_128 (sha512_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, u32 *w4, u32 *w5, u32 *w6, u32 *w7, const int len);
 DECLSPEC void sha512_hmac_update (sha512_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha512_hmac_update_swap (sha512_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha512_hmac_update_utf16le (sha512_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void sha512_hmac_update_utf16le_swap (sha512_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void sha512_hmac_update_global (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha512_hmac_update_global_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha512_hmac_update_global_utf16le (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void sha512_hmac_update_global_utf16le_swap (sha512_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void sha512_hmac_final (sha512_hmac_ctx_t *ctx);
 DECLSPEC void sha512_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, const u32x *w4, const u32x *w5, const u32x *w6, const u32x *w7, u64x *digest);
 DECLSPEC void sha512_init_vector (sha512_ctx_vector_t *ctx);
diff --git a/OpenCL/inc_hash_whirlpool.cl b/OpenCL/inc_hash_whirlpool.cl
index 2835fc72d..5b30615f7 100644
--- a/OpenCL/inc_hash_whirlpool.cl
+++ b/OpenCL/inc_hash_whirlpool.cl
@@ -1018,120 +1018,20 @@ DECLSPEC void whirlpool_update_swap (whirlpool_ctx_t *ctx, const u32 *w, const i
 
 DECLSPEC void whirlpool_update_utf16le (whirlpool_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    whirlpool_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  whirlpool_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  whirlpool_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void whirlpool_update_utf16le_swap (whirlpool_ctx_t *ctx, const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
-
-    whirlpool_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
+  u32 w_utf16_buf[64] = { 0 };
 
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le (w, len, 256, w_utf16_buf, 256);
 
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
-
-  whirlpool_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  whirlpool_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void whirlpool_update_global (whirlpool_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
@@ -1274,120 +1174,20 @@ DECLSPEC void whirlpool_update_global_swap (whirlpool_ctx_t *ctx, GLOBAL_AS cons
 
 DECLSPEC void whirlpool_update_global_utf16le (whirlpool_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
+  u32 w_utf16_buf[64] = { 0 };
 
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-    whirlpool_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  whirlpool_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  whirlpool_update (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void whirlpool_update_global_utf16le_swap (whirlpool_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
-  u32 w0[4];
-  u32 w1[4];
-  u32 w2[4];
-  u32 w3[4];
-
-  int pos1;
-  int pos4;
-
-  for (pos1 = 0, pos4 = 0; pos1 < len - 32; pos1 += 32, pos4 += 8)
-  {
-    w0[0] = w[pos4 + 0];
-    w0[1] = w[pos4 + 1];
-    w0[2] = w[pos4 + 2];
-    w0[3] = w[pos4 + 3];
-    w1[0] = w[pos4 + 4];
-    w1[1] = w[pos4 + 5];
-    w1[2] = w[pos4 + 6];
-    w1[3] = w[pos4 + 7];
-
-    make_utf16le_S (w1, w2, w3);
-    make_utf16le_S (w0, w0, w1);
-
-    w0[0] = hc_swap32_S (w0[0]);
-    w0[1] = hc_swap32_S (w0[1]);
-    w0[2] = hc_swap32_S (w0[2]);
-    w0[3] = hc_swap32_S (w0[3]);
-    w1[0] = hc_swap32_S (w1[0]);
-    w1[1] = hc_swap32_S (w1[1]);
-    w1[2] = hc_swap32_S (w1[2]);
-    w1[3] = hc_swap32_S (w1[3]);
-    w2[0] = hc_swap32_S (w2[0]);
-    w2[1] = hc_swap32_S (w2[1]);
-    w2[2] = hc_swap32_S (w2[2]);
-    w2[3] = hc_swap32_S (w2[3]);
-    w3[0] = hc_swap32_S (w3[0]);
-    w3[1] = hc_swap32_S (w3[1]);
-    w3[2] = hc_swap32_S (w3[2]);
-    w3[3] = hc_swap32_S (w3[3]);
+  u32 w_utf16_buf[64] = { 0 };
 
-    whirlpool_update_64 (ctx, w0, w1, w2, w3, 32 * 2);
-  }
-
-  w0[0] = w[pos4 + 0];
-  w0[1] = w[pos4 + 1];
-  w0[2] = w[pos4 + 2];
-  w0[3] = w[pos4 + 3];
-  w1[0] = w[pos4 + 4];
-  w1[1] = w[pos4 + 5];
-  w1[2] = w[pos4 + 6];
-  w1[3] = w[pos4 + 7];
-
-  make_utf16le_S (w1, w2, w3);
-  make_utf16le_S (w0, w0, w1);
-
-  w0[0] = hc_swap32_S (w0[0]);
-  w0[1] = hc_swap32_S (w0[1]);
-  w0[2] = hc_swap32_S (w0[2]);
-  w0[3] = hc_swap32_S (w0[3]);
-  w1[0] = hc_swap32_S (w1[0]);
-  w1[1] = hc_swap32_S (w1[1]);
-  w1[2] = hc_swap32_S (w1[2]);
-  w1[3] = hc_swap32_S (w1[3]);
-  w2[0] = hc_swap32_S (w2[0]);
-  w2[1] = hc_swap32_S (w2[1]);
-  w2[2] = hc_swap32_S (w2[2]);
-  w2[3] = hc_swap32_S (w2[3]);
-  w3[0] = hc_swap32_S (w3[0]);
-  w3[1] = hc_swap32_S (w3[1]);
-  w3[2] = hc_swap32_S (w3[2]);
-  w3[3] = hc_swap32_S (w3[3]);
+  const int w_utf16_len = utf8_to_utf16le_global (w, len, 256, w_utf16_buf, 256);
 
-  whirlpool_update_64 (ctx, w0, w1, w2, w3, (len - pos1) * 2);
+  whirlpool_update_swap (ctx, w_utf16_buf, w_utf16_len);
 }
 
 DECLSPEC void whirlpool_final (whirlpool_ctx_t *ctx)
@@ -1723,16 +1523,6 @@ DECLSPEC void whirlpool_hmac_update_swap (whirlpool_hmac_ctx_t *ctx, const u32 *
   whirlpool_update_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void whirlpool_hmac_update_utf16le (whirlpool_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  whirlpool_update_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void whirlpool_hmac_update_utf16le_swap (whirlpool_hmac_ctx_t *ctx, const u32 *w, const int len)
-{
-  whirlpool_update_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void whirlpool_hmac_update_global (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
 {
   whirlpool_update_global (&ctx->ipad, w, len);
@@ -1743,16 +1533,6 @@ DECLSPEC void whirlpool_hmac_update_global_swap (whirlpool_hmac_ctx_t *ctx, GLOB
   whirlpool_update_global_swap (&ctx->ipad, w, len);
 }
 
-DECLSPEC void whirlpool_hmac_update_global_utf16le (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  whirlpool_update_global_utf16le (&ctx->ipad, w, len);
-}
-
-DECLSPEC void whirlpool_hmac_update_global_utf16le_swap (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
-{
-  whirlpool_update_global_utf16le_swap (&ctx->ipad, w, len);
-}
-
 DECLSPEC void whirlpool_hmac_final (whirlpool_hmac_ctx_t *ctx)
 {
   whirlpool_final (&ctx->ipad);
diff --git a/OpenCL/inc_hash_whirlpool.h b/OpenCL/inc_hash_whirlpool.h
index e13ec9960..b7600feca 100644
--- a/OpenCL/inc_hash_whirlpool.h
+++ b/OpenCL/inc_hash_whirlpool.h
@@ -104,12 +104,8 @@ DECLSPEC void whirlpool_hmac_init_global_swap (whirlpool_hmac_ctx_t *ctx, GLOBAL
 DECLSPEC void whirlpool_hmac_update_64 (whirlpool_hmac_ctx_t *ctx, u32 *w0, u32 *w1, u32 *w2, u32 *w3, const int len);
 DECLSPEC void whirlpool_hmac_update (whirlpool_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void whirlpool_hmac_update_swap (whirlpool_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void whirlpool_hmac_update_utf16le (whirlpool_hmac_ctx_t *ctx, const u32 *w, const int len);
-DECLSPEC void whirlpool_hmac_update_utf16le_swap (whirlpool_hmac_ctx_t *ctx, const u32 *w, const int len);
 DECLSPEC void whirlpool_hmac_update_global (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void whirlpool_hmac_update_global_swap (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void whirlpool_hmac_update_global_utf16le (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
-DECLSPEC void whirlpool_hmac_update_global_utf16le_swap (whirlpool_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len);
 DECLSPEC void whirlpool_hmac_final (whirlpool_hmac_ctx_t *ctx);
 DECLSPEC void whirlpool_transform_vector (const u32x *w0, const u32x *w1, const u32x *w2, const u32x *w3, u32x *digest, SHM_TYPE u64 *s_MT0, SHM_TYPE u64 *s_MT1, SHM_TYPE u64 *s_MT2, SHM_TYPE u64 *s_MT3, SHM_TYPE u64 *s_MT4, SHM_TYPE u64 *s_MT5, SHM_TYPE u64 *s_MT6, SHM_TYPE u64 *s_MT7);
 DECLSPEC void whirlpool_init_vector (whirlpool_ctx_vector_t *ctx, SHM_TYPE u64 *s_MT0, SHM_TYPE u64 *s_MT1, SHM_TYPE u64 *s_MT2, SHM_TYPE u64 *s_MT3, SHM_TYPE u64 *s_MT4, SHM_TYPE u64 *s_MT5, SHM_TYPE u64 *s_MT6, SHM_TYPE u64 *s_MT7);
diff --git a/OpenCL/m02100-pure.cl b/OpenCL/m02100-pure.cl
index 9242bf6e6..e9a3bd04e 100644
--- a/OpenCL/m02100-pure.cl
+++ b/OpenCL/m02100-pure.cl
@@ -28,6 +28,11 @@ typedef struct dcc2_tmp
 
 } dcc2_tmp_t;
 
+DECLSPEC void sha1_hmac_update_global_utf16le_swap (sha1_hmac_ctx_t *ctx, GLOBAL_AS const u32 *w, const int len)
+{
+  sha1_update_global_utf16le_swap (&ctx->ipad, w, len);
+}
+
 DECLSPEC void hmac_sha1_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
 {
   digest[0] = ipad[0];
diff --git a/OpenCL/m24100-pure.cl b/OpenCL/m24100-pure.cl
new file mode 100644
index 000000000..3b2cb60f3
--- /dev/null
+++ b/OpenCL/m24100-pure.cl
@@ -0,0 +1,366 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#define NEW_SIMD_CODE
+
+#ifdef KERNEL_STATIC
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+#include "inc_hash_md5.cl"
+#include "inc_hash_sha1.cl"
+#endif
+
+#define COMPARE_S "inc_comp_single.cl"
+#define COMPARE_M "inc_comp_multi.cl"
+
+typedef struct mongodb_sha1_tmp
+{
+  u32  ipad[5];
+  u32  opad[5];
+
+  u32  dgst[5];
+  u32  out[5];
+
+} mongodb_sha1_tmp_t;
+
+typedef struct mongodb_sha1
+{
+  u32 salt[16];
+  u32 user[16];
+
+  u32 user_len;
+
+} mongodb_sha1_t;
+
+DECLSPEC void hmac_sha1_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
+{
+  digest[0] = ipad[0];
+  digest[1] = ipad[1];
+  digest[2] = ipad[2];
+  digest[3] = ipad[3];
+  digest[4] = ipad[4];
+
+  sha1_transform_vector (w0, w1, w2, w3, digest);
+
+  w0[0] = digest[0];
+  w0[1] = digest[1];
+  w0[2] = digest[2];
+  w0[3] = digest[3];
+  w1[0] = digest[4];
+  w1[1] = 0x80000000;
+  w1[2] = 0;
+  w1[3] = 0;
+  w2[0] = 0;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = (64 + 20) * 8;
+
+  digest[0] = opad[0];
+  digest[1] = opad[1];
+  digest[2] = opad[2];
+  digest[3] = opad[3];
+  digest[4] = opad[4];
+
+  sha1_transform_vector (w0, w1, w2, w3, digest);
+}
+
+KERNEL_FQ void m24100_init (KERN_ATTR_TMPS_ESALT (mongodb_sha1_tmp_t, mongodb_sha1_t))
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * bin2asc table
+   */
+
+  LOCAL_VK u32 l_bin2asc[256];
+
+  for (u32 i = lid; i < 256; i += lsz)
+  {
+    const u32 i0 = (i >> 0) & 15;
+    const u32 i1 = (i >> 4) & 15;
+
+    l_bin2asc[i] = ((i0 < 10) ? '0' + i0 : 'a' - 10 + i0) << 0
+                 | ((i1 < 10) ? '0' + i1 : 'a' - 10 + i1) << 8;
+  }
+
+  SYNC_THREADS ();
+
+  if (gid >= gid_max) return;
+
+  md5_ctx_t md5_ctx;
+
+  md5_init (&md5_ctx);
+
+  md5_update_global (&md5_ctx, esalt_bufs[DIGESTS_OFFSET].user, esalt_bufs[DIGESTS_OFFSET].user_len);
+  md5_update_global (&md5_ctx, pws[gid].i, pws[gid].pw_len);
+
+  md5_final (&md5_ctx);
+
+  u32 a = md5_ctx.h[0];
+  u32 b = md5_ctx.h[1];
+  u32 c = md5_ctx.h[2];
+  u32 d = md5_ctx.h[3];
+
+  #define uint_to_hex_lower8(i) l_bin2asc[(i)]
+
+  u32 hex[16] = { 0 };
+
+  hex[0] = uint_to_hex_lower8 ((a >>  8) & 255) <<  0
+         | uint_to_hex_lower8 ((a >>  0) & 255) << 16;
+  hex[1] = uint_to_hex_lower8 ((a >> 24) & 255) <<  0
+         | uint_to_hex_lower8 ((a >> 16) & 255) << 16;
+  hex[2] = uint_to_hex_lower8 ((b >>  8) & 255) <<  0
+         | uint_to_hex_lower8 ((b >>  0) & 255) << 16;
+  hex[3] = uint_to_hex_lower8 ((b >> 24) & 255) <<  0
+         | uint_to_hex_lower8 ((b >> 16) & 255) << 16;
+  hex[4] = uint_to_hex_lower8 ((c >>  8) & 255) <<  0
+         | uint_to_hex_lower8 ((c >>  0) & 255) << 16;
+  hex[5] = uint_to_hex_lower8 ((c >> 24) & 255) <<  0
+         | uint_to_hex_lower8 ((c >> 16) & 255) << 16;
+  hex[6] = uint_to_hex_lower8 ((d >>  8) & 255) <<  0
+         | uint_to_hex_lower8 ((d >>  0) & 255) << 16;
+  hex[7] = uint_to_hex_lower8 ((d >> 24) & 255) <<  0
+         | uint_to_hex_lower8 ((d >> 16) & 255) << 16;
+
+  sha1_hmac_ctx_t sha1_hmac_ctx;
+
+  sha1_hmac_init (&sha1_hmac_ctx, hex, 32);
+
+  tmps[gid].ipad[0] = sha1_hmac_ctx.ipad.h[0];
+  tmps[gid].ipad[1] = sha1_hmac_ctx.ipad.h[1];
+  tmps[gid].ipad[2] = sha1_hmac_ctx.ipad.h[2];
+  tmps[gid].ipad[3] = sha1_hmac_ctx.ipad.h[3];
+  tmps[gid].ipad[4] = sha1_hmac_ctx.ipad.h[4];
+
+  tmps[gid].opad[0] = sha1_hmac_ctx.opad.h[0];
+  tmps[gid].opad[1] = sha1_hmac_ctx.opad.h[1];
+  tmps[gid].opad[2] = sha1_hmac_ctx.opad.h[2];
+  tmps[gid].opad[3] = sha1_hmac_ctx.opad.h[3];
+  tmps[gid].opad[4] = sha1_hmac_ctx.opad.h[4];
+
+  sha1_hmac_update_global (&sha1_hmac_ctx, esalt_bufs[DIGESTS_OFFSET].salt, 16);
+
+  for (u32 i = 0, j = 1; i < 4; i += 5, j += 1)
+  {
+    sha1_hmac_ctx_t sha1_hmac_ctx2 = sha1_hmac_ctx;
+
+    u32 w0[4];
+    u32 w1[4];
+    u32 w2[4];
+    u32 w3[4];
+
+    w0[0] = j;
+    w0[1] = 0;
+    w0[2] = 0;
+    w0[3] = 0;
+    w1[0] = 0;
+    w1[1] = 0;
+    w1[2] = 0;
+    w1[3] = 0;
+    w2[0] = 0;
+    w2[1] = 0;
+    w2[2] = 0;
+    w2[3] = 0;
+    w3[0] = 0;
+    w3[1] = 0;
+    w3[2] = 0;
+    w3[3] = 0;
+
+    sha1_hmac_update_64 (&sha1_hmac_ctx2, w0, w1, w2, w3, 4);
+
+    sha1_hmac_final (&sha1_hmac_ctx2);
+
+    tmps[gid].dgst[i + 0] = sha1_hmac_ctx2.opad.h[0];
+    tmps[gid].dgst[i + 1] = sha1_hmac_ctx2.opad.h[1];
+    tmps[gid].dgst[i + 2] = sha1_hmac_ctx2.opad.h[2];
+    tmps[gid].dgst[i + 3] = sha1_hmac_ctx2.opad.h[3];
+    tmps[gid].dgst[i + 4] = sha1_hmac_ctx2.opad.h[4];
+
+    tmps[gid].out[i + 0] = tmps[gid].dgst[i + 0];
+    tmps[gid].out[i + 1] = tmps[gid].dgst[i + 1];
+    tmps[gid].out[i + 2] = tmps[gid].dgst[i + 2];
+    tmps[gid].out[i + 3] = tmps[gid].dgst[i + 3];
+    tmps[gid].out[i + 4] = tmps[gid].dgst[i + 4];
+  }
+}
+
+KERNEL_FQ void m24100_loop (KERN_ATTR_TMPS_ESALT (mongodb_sha1_tmp_t, mongodb_sha1_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if ((gid * VECT_SIZE) >= gid_max) return;
+
+  u32x ipad[5];
+  u32x opad[5];
+
+  ipad[0] = packv (tmps, ipad, gid, 0);
+  ipad[1] = packv (tmps, ipad, gid, 1);
+  ipad[2] = packv (tmps, ipad, gid, 2);
+  ipad[3] = packv (tmps, ipad, gid, 3);
+  ipad[4] = packv (tmps, ipad, gid, 4);
+
+  opad[0] = packv (tmps, opad, gid, 0);
+  opad[1] = packv (tmps, opad, gid, 1);
+  opad[2] = packv (tmps, opad, gid, 2);
+  opad[3] = packv (tmps, opad, gid, 3);
+  opad[4] = packv (tmps, opad, gid, 4);
+
+  for (u32 i = 0; i < 4; i += 5)
+  {
+    u32x dgst[5];
+    u32x out[5];
+
+    dgst[0] = packv (tmps, dgst, gid, i + 0);
+    dgst[1] = packv (tmps, dgst, gid, i + 1);
+    dgst[2] = packv (tmps, dgst, gid, i + 2);
+    dgst[3] = packv (tmps, dgst, gid, i + 3);
+    dgst[4] = packv (tmps, dgst, gid, i + 4);
+
+    out[0] = packv (tmps, out, gid, i + 0);
+    out[1] = packv (tmps, out, gid, i + 1);
+    out[2] = packv (tmps, out, gid, i + 2);
+    out[3] = packv (tmps, out, gid, i + 3);
+    out[4] = packv (tmps, out, gid, i + 4);
+
+    for (u32 j = 0; j < loop_cnt; j++)
+    {
+      u32x w0[4];
+      u32x w1[4];
+      u32x w2[4];
+      u32x w3[4];
+
+      w0[0] = dgst[0];
+      w0[1] = dgst[1];
+      w0[2] = dgst[2];
+      w0[3] = dgst[3];
+      w1[0] = dgst[4];
+      w1[1] = 0x80000000;
+      w1[2] = 0;
+      w1[3] = 0;
+      w2[0] = 0;
+      w2[1] = 0;
+      w2[2] = 0;
+      w2[3] = 0;
+      w3[0] = 0;
+      w3[1] = 0;
+      w3[2] = 0;
+      w3[3] = (64 + 20) * 8;
+
+      hmac_sha1_run_V (w0, w1, w2, w3, ipad, opad, dgst);
+
+      out[0] ^= dgst[0];
+      out[1] ^= dgst[1];
+      out[2] ^= dgst[2];
+      out[3] ^= dgst[3];
+      out[4] ^= dgst[4];
+    }
+
+    unpackv (tmps, dgst, gid, i + 0, dgst[0]);
+    unpackv (tmps, dgst, gid, i + 1, dgst[1]);
+    unpackv (tmps, dgst, gid, i + 2, dgst[2]);
+    unpackv (tmps, dgst, gid, i + 3, dgst[3]);
+    unpackv (tmps, dgst, gid, i + 4, dgst[4]);
+
+    unpackv (tmps, out, gid, i + 0, out[0]);
+    unpackv (tmps, out, gid, i + 1, out[1]);
+    unpackv (tmps, out, gid, i + 2, out[2]);
+    unpackv (tmps, out, gid, i + 3, out[3]);
+    unpackv (tmps, out, gid, i + 4, out[4]);
+  }
+}
+
+KERNEL_FQ void m24100_comp (KERN_ATTR_TMPS_ESALT (mongodb_sha1_tmp_t, mongodb_sha1_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+
+  if (gid >= gid_max) return;
+
+  const u64 lid = get_local_id (0);
+
+  u32 out[5];
+
+  out[0] = tmps[gid].out[0];
+  out[1] = tmps[gid].out[1];
+  out[2] = tmps[gid].out[2];
+  out[3] = tmps[gid].out[3];
+  out[4] = tmps[gid].out[4];
+
+  // HMAC-SHA1 with "Server Key" salt:
+
+  u32 w0[4];
+  u32 w1[4];
+  u32 w2[4];
+  u32 w3[4];
+
+  w0[0] = out[0];
+  w0[1] = out[1];
+  w0[2] = out[2];
+  w0[3] = out[3];
+  w1[0] = out[4];
+  w1[1] = 0;
+  w1[2] = 0;
+  w1[3] = 0;
+  w2[0] = 0;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = 0;
+
+  sha1_hmac_ctx_t sha1_hmac_ctx;
+
+  sha1_hmac_init_64 (&sha1_hmac_ctx, w0, w1, w2, w3);
+
+  w0[0] = 0x53657276; // Serv
+  w0[1] = 0x6572204b; // er K
+  w0[2] = 0x65790000; // ey
+  w0[3] = 0;
+  w1[0] = 0;
+  w1[1] = 0;
+  w1[2] = 0;
+  w1[3] = 0;
+  w2[0] = 0;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = 0;
+
+  sha1_hmac_update_64 (&sha1_hmac_ctx, w0, w1, w2, w3, 10);
+
+  sha1_hmac_final (&sha1_hmac_ctx);
+
+  const u32 r0 = sha1_hmac_ctx.opad.h[DGST_R0];
+  const u32 r1 = sha1_hmac_ctx.opad.h[DGST_R1];
+  const u32 r2 = sha1_hmac_ctx.opad.h[DGST_R2];
+  const u32 r3 = sha1_hmac_ctx.opad.h[DGST_R3];
+
+  #define il_pos 0
+
+  #ifdef KERNEL_STATIC
+  #include COMPARE_M
+  #endif
+}
diff --git a/OpenCL/m24200-pure.cl b/OpenCL/m24200-pure.cl
new file mode 100644
index 000000000..0efa80e05
--- /dev/null
+++ b/OpenCL/m24200-pure.cl
@@ -0,0 +1,353 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#define NEW_SIMD_CODE
+
+#ifdef KERNEL_STATIC
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+#include "inc_hash_sha256.cl"
+#endif
+
+#define COMPARE_S "inc_comp_single.cl"
+#define COMPARE_M "inc_comp_multi.cl"
+
+typedef struct mongodb_sha256_tmp
+{
+  u32  ipad[8];
+  u32  opad[8];
+
+  u32  dgst[8];
+  u32  out[8];
+
+} mongodb_sha256_tmp_t;
+
+typedef struct mongodb_sha256
+{
+  u32 salt[16];
+  u32 user[16];
+
+  u32 user_len;
+
+} mongodb_sha256_t;
+
+DECLSPEC void hmac_sha256_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
+{
+  digest[0] = ipad[0];
+  digest[1] = ipad[1];
+  digest[2] = ipad[2];
+  digest[3] = ipad[3];
+  digest[4] = ipad[4];
+  digest[5] = ipad[5];
+  digest[6] = ipad[6];
+  digest[7] = ipad[7];
+
+  sha256_transform_vector (w0, w1, w2, w3, digest);
+
+  w0[0] = digest[0];
+  w0[1] = digest[1];
+  w0[2] = digest[2];
+  w0[3] = digest[3];
+  w1[0] = digest[4];
+  w1[1] = digest[5];
+  w1[2] = digest[6];
+  w1[3] = digest[7];
+  w2[0] = 0x80000000;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = (64 + 32) * 8;
+
+  digest[0] = opad[0];
+  digest[1] = opad[1];
+  digest[2] = opad[2];
+  digest[3] = opad[3];
+  digest[4] = opad[4];
+  digest[5] = opad[5];
+  digest[6] = opad[6];
+  digest[7] = opad[7];
+
+  sha256_transform_vector (w0, w1, w2, w3, digest);
+}
+
+KERNEL_FQ void m24200_init (KERN_ATTR_TMPS_ESALT (mongodb_sha256_tmp_t, mongodb_sha256_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+
+  if (gid >= gid_max) return;
+
+  sha256_hmac_ctx_t sha256_hmac_ctx;
+
+  sha256_hmac_init_global_swap (&sha256_hmac_ctx, pws[gid].i, pws[gid].pw_len);
+
+  tmps[gid].ipad[0] = sha256_hmac_ctx.ipad.h[0];
+  tmps[gid].ipad[1] = sha256_hmac_ctx.ipad.h[1];
+  tmps[gid].ipad[2] = sha256_hmac_ctx.ipad.h[2];
+  tmps[gid].ipad[3] = sha256_hmac_ctx.ipad.h[3];
+  tmps[gid].ipad[4] = sha256_hmac_ctx.ipad.h[4];
+  tmps[gid].ipad[5] = sha256_hmac_ctx.ipad.h[5];
+  tmps[gid].ipad[6] = sha256_hmac_ctx.ipad.h[6];
+  tmps[gid].ipad[7] = sha256_hmac_ctx.ipad.h[7];
+
+  tmps[gid].opad[0] = sha256_hmac_ctx.opad.h[0];
+  tmps[gid].opad[1] = sha256_hmac_ctx.opad.h[1];
+  tmps[gid].opad[2] = sha256_hmac_ctx.opad.h[2];
+  tmps[gid].opad[3] = sha256_hmac_ctx.opad.h[3];
+  tmps[gid].opad[4] = sha256_hmac_ctx.opad.h[4];
+  tmps[gid].opad[5] = sha256_hmac_ctx.opad.h[5];
+  tmps[gid].opad[6] = sha256_hmac_ctx.opad.h[6];
+  tmps[gid].opad[7] = sha256_hmac_ctx.opad.h[7];
+
+  sha256_hmac_update_global (&sha256_hmac_ctx, esalt_bufs[DIGESTS_OFFSET].salt, 28);
+
+  for (u32 i = 0, j = 1; i < 8; i += 8, j += 1)
+  {
+    sha256_hmac_ctx_t sha256_hmac_ctx2 = sha256_hmac_ctx;
+
+    u32 w0[4];
+    u32 w1[4];
+    u32 w2[4];
+    u32 w3[4];
+
+    w0[0] = j;
+    w0[1] = 0;
+    w0[2] = 0;
+    w0[3] = 0;
+    w1[0] = 0;
+    w1[1] = 0;
+    w1[2] = 0;
+    w1[3] = 0;
+    w2[0] = 0;
+    w2[1] = 0;
+    w2[2] = 0;
+    w2[3] = 0;
+    w3[0] = 0;
+    w3[1] = 0;
+    w3[2] = 0;
+    w3[3] = 0;
+
+    sha256_hmac_update_64 (&sha256_hmac_ctx2, w0, w1, w2, w3, 4);
+
+    sha256_hmac_final (&sha256_hmac_ctx2);
+
+    tmps[gid].dgst[i + 0] = sha256_hmac_ctx2.opad.h[0];
+    tmps[gid].dgst[i + 1] = sha256_hmac_ctx2.opad.h[1];
+    tmps[gid].dgst[i + 2] = sha256_hmac_ctx2.opad.h[2];
+    tmps[gid].dgst[i + 3] = sha256_hmac_ctx2.opad.h[3];
+    tmps[gid].dgst[i + 4] = sha256_hmac_ctx2.opad.h[4];
+    tmps[gid].dgst[i + 5] = sha256_hmac_ctx2.opad.h[5];
+    tmps[gid].dgst[i + 6] = sha256_hmac_ctx2.opad.h[6];
+    tmps[gid].dgst[i + 7] = sha256_hmac_ctx2.opad.h[7];
+
+    tmps[gid].out[i + 0] = tmps[gid].dgst[i + 0];
+    tmps[gid].out[i + 1] = tmps[gid].dgst[i + 1];
+    tmps[gid].out[i + 2] = tmps[gid].dgst[i + 2];
+    tmps[gid].out[i + 3] = tmps[gid].dgst[i + 3];
+    tmps[gid].out[i + 4] = tmps[gid].dgst[i + 4];
+    tmps[gid].out[i + 5] = tmps[gid].dgst[i + 5];
+    tmps[gid].out[i + 6] = tmps[gid].dgst[i + 6];
+    tmps[gid].out[i + 7] = tmps[gid].dgst[i + 7];
+  }
+}
+
+KERNEL_FQ void m24200_loop (KERN_ATTR_TMPS_ESALT (mongodb_sha256_tmp_t, mongodb_sha256_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if ((gid * VECT_SIZE) >= gid_max) return;
+
+  u32x ipad[8];
+  u32x opad[8];
+
+  ipad[0] = packv (tmps, ipad, gid, 0);
+  ipad[1] = packv (tmps, ipad, gid, 1);
+  ipad[2] = packv (tmps, ipad, gid, 2);
+  ipad[3] = packv (tmps, ipad, gid, 3);
+  ipad[4] = packv (tmps, ipad, gid, 4);
+  ipad[5] = packv (tmps, ipad, gid, 5);
+  ipad[6] = packv (tmps, ipad, gid, 6);
+  ipad[7] = packv (tmps, ipad, gid, 7);
+
+  opad[0] = packv (tmps, opad, gid, 0);
+  opad[1] = packv (tmps, opad, gid, 1);
+  opad[2] = packv (tmps, opad, gid, 2);
+  opad[3] = packv (tmps, opad, gid, 3);
+  opad[4] = packv (tmps, opad, gid, 4);
+  opad[5] = packv (tmps, opad, gid, 5);
+  opad[6] = packv (tmps, opad, gid, 6);
+  opad[7] = packv (tmps, opad, gid, 7);
+
+  for (u32 i = 0; i < 8; i += 8)
+  {
+    u32x dgst[8];
+    u32x out[8];
+
+    dgst[0] = packv (tmps, dgst, gid, i + 0);
+    dgst[1] = packv (tmps, dgst, gid, i + 1);
+    dgst[2] = packv (tmps, dgst, gid, i + 2);
+    dgst[3] = packv (tmps, dgst, gid, i + 3);
+    dgst[4] = packv (tmps, dgst, gid, i + 4);
+    dgst[5] = packv (tmps, dgst, gid, i + 5);
+    dgst[6] = packv (tmps, dgst, gid, i + 6);
+    dgst[7] = packv (tmps, dgst, gid, i + 7);
+
+    out[0] = packv (tmps, out, gid, i + 0);
+    out[1] = packv (tmps, out, gid, i + 1);
+    out[2] = packv (tmps, out, gid, i + 2);
+    out[3] = packv (tmps, out, gid, i + 3);
+    out[4] = packv (tmps, out, gid, i + 4);
+    out[5] = packv (tmps, out, gid, i + 5);
+    out[6] = packv (tmps, out, gid, i + 6);
+    out[7] = packv (tmps, out, gid, i + 7);
+
+    for (u32 j = 0; j < loop_cnt; j++)
+    {
+      u32x w0[4];
+      u32x w1[4];
+      u32x w2[4];
+      u32x w3[4];
+
+      w0[0] = dgst[0];
+      w0[1] = dgst[1];
+      w0[2] = dgst[2];
+      w0[3] = dgst[3];
+      w1[0] = dgst[4];
+      w1[1] = dgst[5];
+      w1[2] = dgst[6];
+      w1[3] = dgst[7];
+      w2[0] = 0x80000000;
+      w2[1] = 0;
+      w2[2] = 0;
+      w2[3] = 0;
+      w3[0] = 0;
+      w3[1] = 0;
+      w3[2] = 0;
+      w3[3] = (64 + 32) * 8;
+
+      hmac_sha256_run_V (w0, w1, w2, w3, ipad, opad, dgst);
+
+      out[0] ^= dgst[0];
+      out[1] ^= dgst[1];
+      out[2] ^= dgst[2];
+      out[3] ^= dgst[3];
+      out[4] ^= dgst[4];
+      out[5] ^= dgst[5];
+      out[6] ^= dgst[6];
+      out[7] ^= dgst[7];
+    }
+
+    unpackv (tmps, dgst, gid, i + 0, dgst[0]);
+    unpackv (tmps, dgst, gid, i + 1, dgst[1]);
+    unpackv (tmps, dgst, gid, i + 2, dgst[2]);
+    unpackv (tmps, dgst, gid, i + 3, dgst[3]);
+    unpackv (tmps, dgst, gid, i + 4, dgst[4]);
+    unpackv (tmps, dgst, gid, i + 5, dgst[5]);
+    unpackv (tmps, dgst, gid, i + 6, dgst[6]);
+    unpackv (tmps, dgst, gid, i + 7, dgst[7]);
+
+    unpackv (tmps, out, gid, i + 0, out[0]);
+    unpackv (tmps, out, gid, i + 1, out[1]);
+    unpackv (tmps, out, gid, i + 2, out[2]);
+    unpackv (tmps, out, gid, i + 3, out[3]);
+    unpackv (tmps, out, gid, i + 4, out[4]);
+    unpackv (tmps, out, gid, i + 5, out[5]);
+    unpackv (tmps, out, gid, i + 6, out[6]);
+    unpackv (tmps, out, gid, i + 7, out[7]);
+  }
+}
+
+KERNEL_FQ void m24200_comp (KERN_ATTR_TMPS_ESALT (mongodb_sha256_tmp_t, mongodb_sha256_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+
+  if (gid >= gid_max) return;
+
+  const u64 lid = get_local_id (0);
+
+  u32 out[8];
+
+  out[0] = tmps[gid].out[0];
+  out[1] = tmps[gid].out[1];
+  out[2] = tmps[gid].out[2];
+  out[3] = tmps[gid].out[3];
+  out[4] = tmps[gid].out[4];
+  out[5] = tmps[gid].out[5];
+  out[6] = tmps[gid].out[6];
+  out[7] = tmps[gid].out[7];
+
+  // HMAC-SHA256 with "Server Key" salt:
+
+  u32 w0[4];
+  u32 w1[4];
+  u32 w2[4];
+  u32 w3[4];
+
+  w0[0] = out[0];
+  w0[1] = out[1];
+  w0[2] = out[2];
+  w0[3] = out[3];
+  w1[0] = out[4];
+  w1[1] = out[5];
+  w1[2] = out[6];
+  w1[3] = out[7];
+  w2[0] = 0;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = 0;
+
+  sha256_hmac_ctx_t sha256_hmac_ctx;
+
+  sha256_hmac_init_64 (&sha256_hmac_ctx, w0, w1, w2, w3);
+
+  w0[0] = 0x53657276; // Serv
+  w0[1] = 0x6572204b; // er K
+  w0[2] = 0x65790000; // ey
+  w0[3] = 0;
+  w1[0] = 0;
+  w1[1] = 0;
+  w1[2] = 0;
+  w1[3] = 0;
+  w2[0] = 0;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = 0;
+
+  sha256_hmac_update_64 (&sha256_hmac_ctx, w0, w1, w2, w3, 10);
+
+  sha256_hmac_final (&sha256_hmac_ctx);
+
+  const u32 r0 = sha256_hmac_ctx.opad.h[DGST_R0];
+  const u32 r1 = sha256_hmac_ctx.opad.h[DGST_R1];
+  const u32 r2 = sha256_hmac_ctx.opad.h[DGST_R2];
+  const u32 r3 = sha256_hmac_ctx.opad.h[DGST_R3];
+
+  #define il_pos 0
+
+  #ifdef KERNEL_STATIC
+  #include COMPARE_M
+  #endif
+}
diff --git a/OpenCL/m25400-pure.cl b/OpenCL/m25400-pure.cl
new file mode 100644
index 000000000..0a0aba524
--- /dev/null
+++ b/OpenCL/m25400-pure.cl
@@ -0,0 +1,444 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+// TODO use user password as input for md5 of o_digest if no owner password is set
+// TODO dynamically add user password including padding to the RC4 input for the computation of the pdf o-value
+
+#ifdef KERNEL_STATIC
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_hash_md5.cl"
+#endif
+
+#define COMPARE_S "inc_comp_single.cl"
+#define COMPARE_M "inc_comp_multi.cl"
+
+CONSTANT_VK u32a padding[8] =
+{
+  0x5e4ebf28,
+  0x418a754e,
+  0x564e0064,
+  0x0801faff,
+  0xb6002e2e,
+  0x803e68d0,
+  0xfea90c2f,
+  0x7a695364
+};
+
+typedef struct pdf
+{
+  int  V;
+  int  R;
+  int  P;
+
+  int  enc_md;
+
+  u32  id_buf[8];
+  u32  u_buf[32];
+  u32  o_buf[32];
+
+  int  id_len;
+  int  o_len;
+  int  u_len;
+
+  u32  rc4key[2];
+  u32  rc4data[2];
+
+} pdf_t;
+
+typedef struct pdf14_tmp
+{
+  u32 digest[4];
+  u32 out[4];
+
+} pdf14_tmp_t;
+
+typedef struct
+{
+  u8 S[256];
+
+  u32 wtf_its_faster;
+
+} RC4_KEY;
+
+DECLSPEC void swap (LOCAL_AS RC4_KEY *rc4_key, const u8 i, const u8 j)
+{
+  u8 tmp;
+
+  tmp           = rc4_key->S[i];
+  rc4_key->S[i] = rc4_key->S[j];
+  rc4_key->S[j] = tmp;
+}
+
+DECLSPEC void rc4_init_16 (LOCAL_AS RC4_KEY *rc4_key, const u32 *data)
+{
+  u32 v = 0x03020100;
+  u32 a = 0x04040404;
+
+  LOCAL_AS u32 *ptr = (LOCAL_AS u32 *) rc4_key->S;
+
+  #ifdef _unroll
+  #pragma unroll
+  #endif
+  for (u32 i = 0; i < 64; i++)
+  {
+    *ptr++ = v; v += a;
+  }
+
+  u32 j = 0;
+
+  #ifdef _unroll
+  #pragma unroll
+  #endif
+  for (u32 i = 0; i < 16; i++)
+  {
+    u32 idx = i * 16;
+
+    u32 v;
+
+    v = data[0];
+
+    j += rc4_key->S[idx] + (v >>  0); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >>  8); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 16); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 24); swap (rc4_key, idx, j); idx++;
+
+    v = data[1];
+
+    j += rc4_key->S[idx] + (v >>  0); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >>  8); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 16); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 24); swap (rc4_key, idx, j); idx++;
+
+    v = data[2];
+
+    j += rc4_key->S[idx] + (v >>  0); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >>  8); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 16); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 24); swap (rc4_key, idx, j); idx++;
+
+    v = data[3];
+
+    j += rc4_key->S[idx] + (v >>  0); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >>  8); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 16); swap (rc4_key, idx, j); idx++;
+    j += rc4_key->S[idx] + (v >> 24); swap (rc4_key, idx, j); idx++;
+  }
+}
+
+DECLSPEC u8 rc4_next_16 (LOCAL_AS RC4_KEY *rc4_key, u8 i, u8 j, const u32 *in, u32 *out)
+{
+  #ifdef _unroll
+  #pragma unroll
+  #endif
+  for (u32 k = 0; k < 4; k++)
+  {
+    u32 xor4 = 0;
+
+    u8 idx;
+
+    i += 1;
+    j += rc4_key->S[i];
+
+    swap (rc4_key, i, j);
+
+    idx = rc4_key->S[i] + rc4_key->S[j];
+
+    xor4 |= rc4_key->S[idx] <<  0;
+
+    i += 1;
+    j += rc4_key->S[i];
+
+    swap (rc4_key, i, j);
+
+    idx = rc4_key->S[i] + rc4_key->S[j];
+
+    xor4 |= rc4_key->S[idx] <<  8;
+
+    i += 1;
+    j += rc4_key->S[i];
+
+    swap (rc4_key, i, j);
+
+    idx = rc4_key->S[i] + rc4_key->S[j];
+
+    xor4 |= rc4_key->S[idx] << 16;
+
+    i += 1;
+    j += rc4_key->S[i];
+
+    swap (rc4_key, i, j);
+
+    idx = rc4_key->S[i] + rc4_key->S[j];
+
+    xor4 |= rc4_key->S[idx] << 24;
+
+    out[k] = in[k] ^ xor4;
+  }
+
+  return j;
+}
+
+KERNEL_FQ void m25400_init (KERN_ATTR_TMPS_ESALT (pdf14_tmp_t, pdf_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+  //const u64 lid = get_local_id (0);
+
+  if (gid >= gid_max) return;
+
+  u32 w0[4];
+
+  w0[0] = pws[gid].i[ 0];
+  w0[1] = pws[gid].i[ 1];
+  w0[2] = pws[gid].i[ 2];
+  w0[3] = pws[gid].i[ 3];
+
+  u32 w1[4];
+
+  w1[0] = pws[gid].i[ 4];
+  w1[1] = pws[gid].i[ 5];
+  w1[2] = pws[gid].i[ 6];
+  w1[3] = pws[gid].i[ 7];
+
+  const u32 pw_len = pws[gid].pw_len;
+
+  /**
+   * shared
+   */
+
+  //LOCAL_AS RC4_KEY rc4_keys[64];
+  //LOCAL_AS RC4_KEY *rc4_key = &rc4_keys[lid];
+
+  u32 P = esalt_bufs[DIGESTS_OFFSET].P;
+
+  u32 id_buf[12];
+
+  id_buf[ 0] = esalt_bufs[DIGESTS_OFFSET].id_buf[0];
+  id_buf[ 1] = esalt_bufs[DIGESTS_OFFSET].id_buf[1];
+  id_buf[ 2] = esalt_bufs[DIGESTS_OFFSET].id_buf[2];
+  id_buf[ 3] = esalt_bufs[DIGESTS_OFFSET].id_buf[3];
+
+  id_buf[ 4] = esalt_bufs[DIGESTS_OFFSET].id_buf[4];
+  id_buf[ 5] = esalt_bufs[DIGESTS_OFFSET].id_buf[5];
+  id_buf[ 6] = esalt_bufs[DIGESTS_OFFSET].id_buf[6];
+  id_buf[ 7] = esalt_bufs[DIGESTS_OFFSET].id_buf[7];
+
+  id_buf[ 8] = 0;
+  id_buf[ 9] = 0;
+  id_buf[10] = 0;
+  id_buf[11] = 0;
+
+  u32 rc4data[2];
+
+  rc4data[0] = padding[0];
+  rc4data[1] = padding[1];
+
+  /**
+   * main init
+   */
+
+  u32 w0_t[4];
+  u32 w1_t[4];
+  u32 w2_t[4];
+  u32 w3_t[4];
+
+  // max length supported by pdf11 is 32
+
+  w0_t[0] = padding[0];
+  w0_t[1] = padding[1];
+  w0_t[2] = padding[2];
+  w0_t[3] = padding[3];
+  w1_t[0] = padding[4];
+  w1_t[1] = padding[5];
+  w1_t[2] = padding[6];
+  w1_t[3] = padding[7];
+  w2_t[0] = 0;
+  w2_t[1] = 0;
+  w2_t[2] = 0;
+  w2_t[3] = 0;
+  w3_t[0] = 0;
+  w3_t[1] = 0;
+  w3_t[2] = 0;
+  w3_t[3] = 0;
+
+  switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, pw_len);
+
+  // add password
+  // truncate at 32 is wanted, not a bug!
+  // add padding
+
+  w0_t[0] |= w0[0];
+  w0_t[1] |= w0[1];
+  w0_t[2] |= w0[2];
+  w0_t[3] |= w0[3];
+  w1_t[0] |= w1[0];
+  w1_t[1] |= w1[1];
+  w1_t[2] |= w1[2];
+  w1_t[3] |= w1[3];
+  w2_t[0] = 0x80;
+  w2_t[1] = 0;
+  w2_t[2] = 0;
+  w2_t[3] = 0;
+  w3_t[0] = 0;
+  w3_t[1] = 0;
+  w3_t[2] = 32 * 8;
+  w3_t[3] = 0;
+
+  u32 digest[4];
+
+  digest[0] = MD5M_A;
+  digest[1] = MD5M_B;
+  digest[2] = MD5M_C;
+  digest[3] = MD5M_D;
+
+  md5_transform (w0_t, w1_t, w2_t, w3_t, digest);
+
+  tmps[gid].digest[0] = digest[0];
+  tmps[gid].digest[1] = digest[1];
+  tmps[gid].digest[2] = digest[2];
+  tmps[gid].digest[3] = digest[3];
+
+  tmps[gid].out[0] = rc4data[0];
+  tmps[gid].out[1] = rc4data[1];
+  tmps[gid].out[2] = 0;
+  tmps[gid].out[3] = 0;
+}
+
+KERNEL_FQ void m25400_loop (KERN_ATTR_TMPS_ESALT (pdf14_tmp_t, pdf_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+
+  if (gid >= gid_max) return;
+
+  /**
+   * shared
+   */
+
+  LOCAL_VK RC4_KEY rc4_keys[64];
+
+  LOCAL_AS RC4_KEY *rc4_key = &rc4_keys[lid];
+
+  /**
+   * loop
+   */
+
+  u32 digest[4];
+
+  digest[0] = tmps[gid].digest[0];
+  digest[1] = tmps[gid].digest[1];
+  digest[2] = tmps[gid].digest[2];
+  digest[3] = tmps[gid].digest[3];
+
+  u32 out[4];
+
+  out[0] = tmps[gid].out[0];
+  out[1] = tmps[gid].out[1];
+  out[2] = tmps[gid].out[2];
+  out[3] = tmps[gid].out[3];
+
+  for (u32 i = 0, j = loop_pos; i < loop_cnt; i++, j++)
+  {
+    if (j < 50)
+    {
+      u32 w0_t[4];
+      u32 w1_t[4];
+      u32 w2_t[4];
+      u32 w3_t[4];
+
+      w0_t[0] = digest[0];
+      w0_t[1] = digest[1];
+      w0_t[2] = digest[2];
+      w0_t[3] = digest[3];
+      w1_t[0] = 0x80;
+      w1_t[1] = 0;
+      w1_t[2] = 0;
+      w1_t[3] = 0;
+      w2_t[0] = 0;
+      w2_t[1] = 0;
+      w2_t[2] = 0;
+      w2_t[3] = 0;
+      w3_t[0] = 0;
+      w3_t[1] = 0;
+      w3_t[2] = 16 * 8;
+      w3_t[3] = 0;
+
+      digest[0] = MD5M_A;
+      digest[1] = MD5M_B;
+      digest[2] = MD5M_C;
+      digest[3] = MD5M_D;
+
+      md5_transform (w0_t, w1_t, w2_t, w3_t, digest);
+    }
+    else
+    {
+      const u32 x = j - 50;
+
+      const u32 xv = x <<  0
+                   | x <<  8
+                   | x << 16
+                   | x << 24;
+
+      u32 tmp[4];
+
+      tmp[0] = digest[0] ^ xv;
+      tmp[1] = digest[1] ^ xv;
+      tmp[2] = digest[2] ^ xv;
+      tmp[3] = digest[3] ^ xv;
+
+      rc4_init_16 (rc4_key, tmp);
+
+      rc4_next_16 (rc4_key, 0, 0, out, out);
+    }
+  }
+
+  tmps[gid].digest[0] = digest[0];
+  tmps[gid].digest[1] = digest[1];
+  tmps[gid].digest[2] = digest[2];
+  tmps[gid].digest[3] = digest[3];
+
+  tmps[gid].out[0] = out[0];
+  tmps[gid].out[1] = out[1];
+  tmps[gid].out[2] = out[2];
+  tmps[gid].out[3] = out[3];
+}
+
+KERNEL_FQ void m25400_comp (KERN_ATTR_TMPS_ESALT (pdf14_tmp_t, pdf_t))
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+
+  if (gid >= gid_max) return;
+
+  const u64 lid = get_local_id (0);
+
+  /**
+   * digest
+   */
+
+  const u32 r0 = tmps[gid].out[0];
+  const u32 r1 = tmps[gid].out[1];
+  const u32 r2 = 0;
+  const u32 r3 = 0;
+
+  #define il_pos 0
+
+  #ifdef KERNEL_STATIC
+  #include COMPARE_M
+  #endif
+}
diff --git a/OpenCL/m25500-optimized.cl b/OpenCL/m25500-optimized.cl
new file mode 100644
index 000000000..dfc292a26
--- /dev/null
+++ b/OpenCL/m25500-optimized.cl
@@ -0,0 +1,455 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#define NEW_SIMD_CODE
+
+#ifdef KERNEL_STATIC
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+#include "inc_hash_sha256.cl"
+#include "inc_cipher_aes.cl"
+#include "inc_cipher_aes-gcm.cl"
+#endif
+
+#define COMPARE_S "inc_comp_single.cl"
+#define COMPARE_M "inc_comp_multi.cl"
+
+typedef struct pbkdf2_sha256_tmp
+{
+  u32  ipad[8];
+  u32  opad[8];
+
+  u32  dgst[32];
+  u32  out[32];
+
+} pbkdf2_sha256_tmp_t;
+
+typedef struct pbkdf2_sha256_aes_gcm
+{
+  u32 salt_buf[64];
+  u32 iv_buf[4];
+  u32 iv_len;
+  u32 ct_buf[16];
+  u32 ct_len;
+
+} pbkdf2_sha256_aes_gcm_t;
+
+DECLSPEC void hmac_sha256_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
+{
+  digest[0] = ipad[0];
+  digest[1] = ipad[1];
+  digest[2] = ipad[2];
+  digest[3] = ipad[3];
+  digest[4] = ipad[4];
+  digest[5] = ipad[5];
+  digest[6] = ipad[6];
+  digest[7] = ipad[7];
+
+  sha256_transform_vector (w0, w1, w2, w3, digest);
+
+  w0[0] = digest[0];
+  w0[1] = digest[1];
+  w0[2] = digest[2];
+  w0[3] = digest[3];
+  w1[0] = digest[4];
+  w1[1] = digest[5];
+  w1[2] = digest[6];
+  w1[3] = digest[7];
+  w2[0] = 0x80000000;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = (64 + 32) * 8;
+
+  digest[0] = opad[0];
+  digest[1] = opad[1];
+  digest[2] = opad[2];
+  digest[3] = opad[3];
+  digest[4] = opad[4];
+  digest[5] = opad[5];
+  digest[6] = opad[6];
+  digest[7] = opad[7];
+
+  sha256_transform_vector (w0, w1, w2, w3, digest);
+}
+
+KERNEL_FQ void m25500_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha256_tmp_t, pbkdf2_sha256_aes_gcm_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+
+  if (gid >= gid_max) return;
+
+  sha256_hmac_ctx_t sha256_hmac_ctx;
+
+  sha256_hmac_init_global_swap (&sha256_hmac_ctx, pws[gid].i, pws[gid].pw_len);
+
+  tmps[gid].ipad[0] = sha256_hmac_ctx.ipad.h[0];
+  tmps[gid].ipad[1] = sha256_hmac_ctx.ipad.h[1];
+  tmps[gid].ipad[2] = sha256_hmac_ctx.ipad.h[2];
+  tmps[gid].ipad[3] = sha256_hmac_ctx.ipad.h[3];
+  tmps[gid].ipad[4] = sha256_hmac_ctx.ipad.h[4];
+  tmps[gid].ipad[5] = sha256_hmac_ctx.ipad.h[5];
+  tmps[gid].ipad[6] = sha256_hmac_ctx.ipad.h[6];
+  tmps[gid].ipad[7] = sha256_hmac_ctx.ipad.h[7];
+
+  tmps[gid].opad[0] = sha256_hmac_ctx.opad.h[0];
+  tmps[gid].opad[1] = sha256_hmac_ctx.opad.h[1];
+  tmps[gid].opad[2] = sha256_hmac_ctx.opad.h[2];
+  tmps[gid].opad[3] = sha256_hmac_ctx.opad.h[3];
+  tmps[gid].opad[4] = sha256_hmac_ctx.opad.h[4];
+  tmps[gid].opad[5] = sha256_hmac_ctx.opad.h[5];
+  tmps[gid].opad[6] = sha256_hmac_ctx.opad.h[6];
+  tmps[gid].opad[7] = sha256_hmac_ctx.opad.h[7];
+
+  sha256_hmac_update_global_swap (&sha256_hmac_ctx, esalt_bufs[DIGESTS_OFFSET].salt_buf, salt_bufs[SALT_POS].salt_len);
+
+  for (u32 i = 0, j = 1; i < 8; i += 8, j += 1)
+  {
+    sha256_hmac_ctx_t sha256_hmac_ctx2 = sha256_hmac_ctx;
+
+    u32 w0[4];
+    u32 w1[4];
+    u32 w2[4];
+    u32 w3[4];
+
+    w0[0] = j;
+    w0[1] = 0;
+    w0[2] = 0;
+    w0[3] = 0;
+    w1[0] = 0;
+    w1[1] = 0;
+    w1[2] = 0;
+    w1[3] = 0;
+    w2[0] = 0;
+    w2[1] = 0;
+    w2[2] = 0;
+    w2[3] = 0;
+    w3[0] = 0;
+    w3[1] = 0;
+    w3[2] = 0;
+    w3[3] = 0;
+
+    sha256_hmac_update_64 (&sha256_hmac_ctx2, w0, w1, w2, w3, 4);
+
+    sha256_hmac_final (&sha256_hmac_ctx2);
+
+    tmps[gid].dgst[i + 0] = sha256_hmac_ctx2.opad.h[0];
+    tmps[gid].dgst[i + 1] = sha256_hmac_ctx2.opad.h[1];
+    tmps[gid].dgst[i + 2] = sha256_hmac_ctx2.opad.h[2];
+    tmps[gid].dgst[i + 3] = sha256_hmac_ctx2.opad.h[3];
+    tmps[gid].dgst[i + 4] = sha256_hmac_ctx2.opad.h[4];
+    tmps[gid].dgst[i + 5] = sha256_hmac_ctx2.opad.h[5];
+    tmps[gid].dgst[i + 6] = sha256_hmac_ctx2.opad.h[6];
+    tmps[gid].dgst[i + 7] = sha256_hmac_ctx2.opad.h[7];
+
+    tmps[gid].out[i + 0] = tmps[gid].dgst[i + 0];
+    tmps[gid].out[i + 1] = tmps[gid].dgst[i + 1];
+    tmps[gid].out[i + 2] = tmps[gid].dgst[i + 2];
+    tmps[gid].out[i + 3] = tmps[gid].dgst[i + 3];
+    tmps[gid].out[i + 4] = tmps[gid].dgst[i + 4];
+    tmps[gid].out[i + 5] = tmps[gid].dgst[i + 5];
+    tmps[gid].out[i + 6] = tmps[gid].dgst[i + 6];
+    tmps[gid].out[i + 7] = tmps[gid].dgst[i + 7];
+  }
+}
+
+KERNEL_FQ void m25500_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha256_tmp_t, pbkdf2_sha256_aes_gcm_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if ((gid * VECT_SIZE) >= gid_max) return;
+
+  u32x ipad[8];
+  u32x opad[8];
+
+  ipad[0] = packv (tmps, ipad, gid, 0);
+  ipad[1] = packv (tmps, ipad, gid, 1);
+  ipad[2] = packv (tmps, ipad, gid, 2);
+  ipad[3] = packv (tmps, ipad, gid, 3);
+  ipad[4] = packv (tmps, ipad, gid, 4);
+  ipad[5] = packv (tmps, ipad, gid, 5);
+  ipad[6] = packv (tmps, ipad, gid, 6);
+  ipad[7] = packv (tmps, ipad, gid, 7);
+
+  opad[0] = packv (tmps, opad, gid, 0);
+  opad[1] = packv (tmps, opad, gid, 1);
+  opad[2] = packv (tmps, opad, gid, 2);
+  opad[3] = packv (tmps, opad, gid, 3);
+  opad[4] = packv (tmps, opad, gid, 4);
+  opad[5] = packv (tmps, opad, gid, 5);
+  opad[6] = packv (tmps, opad, gid, 6);
+  opad[7] = packv (tmps, opad, gid, 7);
+
+  for (u32 i = 0; i < 8; i += 8)
+  {
+    u32x dgst[8];
+    u32x out[8];
+
+    dgst[0] = packv (tmps, dgst, gid, i + 0);
+    dgst[1] = packv (tmps, dgst, gid, i + 1);
+    dgst[2] = packv (tmps, dgst, gid, i + 2);
+    dgst[3] = packv (tmps, dgst, gid, i + 3);
+    dgst[4] = packv (tmps, dgst, gid, i + 4);
+    dgst[5] = packv (tmps, dgst, gid, i + 5);
+    dgst[6] = packv (tmps, dgst, gid, i + 6);
+    dgst[7] = packv (tmps, dgst, gid, i + 7);
+
+    out[0] = packv (tmps, out, gid, i + 0);
+    out[1] = packv (tmps, out, gid, i + 1);
+    out[2] = packv (tmps, out, gid, i + 2);
+    out[3] = packv (tmps, out, gid, i + 3);
+    out[4] = packv (tmps, out, gid, i + 4);
+    out[5] = packv (tmps, out, gid, i + 5);
+    out[6] = packv (tmps, out, gid, i + 6);
+    out[7] = packv (tmps, out, gid, i + 7);
+
+    for (u32 j = 0; j < loop_cnt; j++)
+    {
+      u32x w0[4];
+      u32x w1[4];
+      u32x w2[4];
+      u32x w3[4];
+
+      w0[0] = dgst[0];
+      w0[1] = dgst[1];
+      w0[2] = dgst[2];
+      w0[3] = dgst[3];
+      w1[0] = dgst[4];
+      w1[1] = dgst[5];
+      w1[2] = dgst[6];
+      w1[3] = dgst[7];
+      w2[0] = 0x80000000;
+      w2[1] = 0;
+      w2[2] = 0;
+      w2[3] = 0;
+      w3[0] = 0;
+      w3[1] = 0;
+      w3[2] = 0;
+      w3[3] = (64 + 32) * 8;
+
+      hmac_sha256_run_V (w0, w1, w2, w3, ipad, opad, dgst);
+
+      out[0] ^= dgst[0];
+      out[1] ^= dgst[1];
+      out[2] ^= dgst[2];
+      out[3] ^= dgst[3];
+      out[4] ^= dgst[4];
+      out[5] ^= dgst[5];
+      out[6] ^= dgst[6];
+      out[7] ^= dgst[7];
+    }
+
+    unpackv (tmps, dgst, gid, i + 0, dgst[0]);
+    unpackv (tmps, dgst, gid, i + 1, dgst[1]);
+    unpackv (tmps, dgst, gid, i + 2, dgst[2]);
+    unpackv (tmps, dgst, gid, i + 3, dgst[3]);
+    unpackv (tmps, dgst, gid, i + 4, dgst[4]);
+    unpackv (tmps, dgst, gid, i + 5, dgst[5]);
+    unpackv (tmps, dgst, gid, i + 6, dgst[6]);
+    unpackv (tmps, dgst, gid, i + 7, dgst[7]);
+
+    unpackv (tmps, out, gid, i + 0, out[0]);
+    unpackv (tmps, out, gid, i + 1, out[1]);
+    unpackv (tmps, out, gid, i + 2, out[2]);
+    unpackv (tmps, out, gid, i + 3, out[3]);
+    unpackv (tmps, out, gid, i + 4, out[4]);
+    unpackv (tmps, out, gid, i + 5, out[5]);
+    unpackv (tmps, out, gid, i + 6, out[6]);
+    unpackv (tmps, out, gid, i + 7, out[7]);
+  }
+}
+
+KERNEL_FQ void m25500_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha256_tmp_t, pbkdf2_sha256_aes_gcm_t))
+{
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * aes shared
+   */
+
+  #ifdef REAL_SHM
+
+  LOCAL_VK u32 s_te0[256];
+  LOCAL_VK u32 s_te1[256];
+  LOCAL_VK u32 s_te2[256];
+  LOCAL_VK u32 s_te3[256];
+  LOCAL_VK u32 s_te4[256];
+
+  for (u32 i = lid; i < 256; i += lsz)
+  {
+    s_te0[i] = te0[i];
+    s_te1[i] = te1[i];
+    s_te2[i] = te2[i];
+    s_te3[i] = te3[i];
+    s_te4[i] = te4[i];
+  }
+
+  SYNC_THREADS ();
+
+  #else
+
+  CONSTANT_AS u32a *s_te0 = te0;
+  CONSTANT_AS u32a *s_te1 = te1;
+  CONSTANT_AS u32a *s_te2 = te2;
+  CONSTANT_AS u32a *s_te3 = te3;
+  CONSTANT_AS u32a *s_te4 = te4;
+
+  #endif
+
+  if (gid >= gid_max) return;
+
+  // keys
+
+  u32 ukey[8];
+
+  ukey[0] = tmps[gid].out[0];
+  ukey[1] = tmps[gid].out[1];
+  ukey[2] = tmps[gid].out[2];
+  ukey[3] = tmps[gid].out[3];
+  ukey[4] = tmps[gid].out[4];
+  ukey[5] = tmps[gid].out[5];
+  ukey[6] = tmps[gid].out[6];
+  ukey[7] = tmps[gid].out[7];
+
+  u32 key[60] = { 0 };
+
+  u32 subKey[4] = { 0 };
+
+  AES256_set_encrypt_key (key, ukey, s_te0, s_te1, s_te2, s_te3);
+
+  AES256_encrypt (key, subKey, subKey, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+  // iv
+
+  const u32 iv[4] = {
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[0],
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[1],
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[2],
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[3]
+  };
+
+  u32 J0[4] = {
+    iv[0],
+    iv[1],
+    iv[2],
+    0x00000001
+  };
+
+  // ct
+
+  u32 enc[14] = { 0 };
+
+  enc[ 0] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 0];
+  enc[ 1] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 1];
+  enc[ 2] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 2];
+  enc[ 3] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 3];
+  enc[ 4] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 4];
+  enc[ 5] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 5];
+  enc[ 6] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 6];
+  enc[ 7] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 7];
+  enc[ 8] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 8];
+  enc[ 9] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 9];
+  enc[10] = esalt_bufs[DIGESTS_OFFSET].ct_buf[10];
+  enc[11] = esalt_bufs[DIGESTS_OFFSET].ct_buf[11];
+  enc[12] = esalt_bufs[DIGESTS_OFFSET].ct_buf[12];
+  enc[13] = esalt_bufs[DIGESTS_OFFSET].ct_buf[13];
+
+  u32 enc_len = esalt_bufs[DIGESTS_OFFSET].ct_len;
+
+  u32 S[4] = { 0 };
+
+  u32 t[4] = { 0 };
+
+  S[0] ^= enc[0];
+  S[1] ^= enc[1];
+  S[2] ^= enc[2];
+  S[3] ^= enc[3];
+
+  AES_GCM_gf_mult (S, subKey, t);
+
+  S[0] = t[0] ^ enc[4];
+  S[1] = t[1] ^ enc[5];
+  S[2] = t[2] ^ enc[6];
+  S[3] = t[3] ^ enc[7];
+
+  AES_GCM_gf_mult (S, subKey, t);
+
+  S[0] = t[0] ^ enc[8];
+  S[1] = t[1] ^ enc[9];
+  S[2] = t[2] ^ enc[10];
+  S[3] = t[3] ^ enc[11];
+
+  AES_GCM_gf_mult (S, subKey, t);
+
+  S[0] = t[0];
+  S[1] = t[1];
+  S[2] = t[2];
+  S[3] = t[3];
+
+  t[0] = enc[12];
+  t[1] = enc[13];
+  t[2] = 0;
+  t[3] = 0;
+
+  S[0] ^= t[0];
+  S[1] ^= t[1];
+  S[2] ^= t[2];
+  S[3] ^= t[3];
+
+  AES_GCM_gf_mult (S, subKey, t);
+
+  S[0] = t[0];
+  S[1] = t[1];
+  S[2] = t[2];
+  S[3] = t[3];
+
+  u32 len_buf[4] = { 0 };
+
+  len_buf[0] = 0;
+  len_buf[3] = enc_len * 8;
+
+  S[0] ^= len_buf[0];
+  S[1] ^= len_buf[1];
+  S[2] ^= len_buf[2];
+  S[3] ^= len_buf[3];
+
+  AES_GCM_gf_mult (S, subKey, t);
+
+  S[0] = t[0];
+  S[1] = t[1];
+  S[2] = t[2];
+  S[3] = t[3];
+
+  J0[3] = 0x00000001;
+
+  u32 T[4] = { 0 };
+
+  AES256_encrypt (key, J0, T, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+  /* compare tag */
+
+  const u32 r0 = T[0] ^ S[0];
+  const u32 r1 = T[1] ^ S[1];
+  const u32 r2 = T[2] ^ S[2];
+  const u32 r3 = T[3] ^ S[3];
+
+  #define il_pos 0
+
+  #ifdef KERNEL_STATIC
+  #include COMPARE_M
+  #endif
+}
diff --git a/OpenCL/m25500-pure.cl b/OpenCL/m25500-pure.cl
new file mode 100644
index 000000000..56dddb096
--- /dev/null
+++ b/OpenCL/m25500-pure.cl
@@ -0,0 +1,405 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#define NEW_SIMD_CODE
+
+#ifdef KERNEL_STATIC
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+#include "inc_hash_sha256.cl"
+#include "inc_cipher_aes.cl"
+#include "inc_cipher_aes-gcm.cl"
+#endif
+
+#define COMPARE_S "inc_comp_single.cl"
+#define COMPARE_M "inc_comp_multi.cl"
+
+typedef struct pbkdf2_sha256_tmp
+{
+  u32  ipad[8];
+  u32  opad[8];
+
+  u32  dgst[32];
+  u32  out[32];
+
+} pbkdf2_sha256_tmp_t;
+
+typedef struct pbkdf2_sha256_aes_gcm
+{
+  u32 salt_buf[64];
+  u32 iv_buf[4];
+  u32 iv_len;
+  u32 ct_buf[16];
+  u32 ct_len;
+
+} pbkdf2_sha256_aes_gcm_t;
+
+DECLSPEC void hmac_sha256_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest)
+{
+  digest[0] = ipad[0];
+  digest[1] = ipad[1];
+  digest[2] = ipad[2];
+  digest[3] = ipad[3];
+  digest[4] = ipad[4];
+  digest[5] = ipad[5];
+  digest[6] = ipad[6];
+  digest[7] = ipad[7];
+
+  sha256_transform_vector (w0, w1, w2, w3, digest);
+
+  w0[0] = digest[0];
+  w0[1] = digest[1];
+  w0[2] = digest[2];
+  w0[3] = digest[3];
+  w1[0] = digest[4];
+  w1[1] = digest[5];
+  w1[2] = digest[6];
+  w1[3] = digest[7];
+  w2[0] = 0x80000000;
+  w2[1] = 0;
+  w2[2] = 0;
+  w2[3] = 0;
+  w3[0] = 0;
+  w3[1] = 0;
+  w3[2] = 0;
+  w3[3] = (64 + 32) * 8;
+
+  digest[0] = opad[0];
+  digest[1] = opad[1];
+  digest[2] = opad[2];
+  digest[3] = opad[3];
+  digest[4] = opad[4];
+  digest[5] = opad[5];
+  digest[6] = opad[6];
+  digest[7] = opad[7];
+
+  sha256_transform_vector (w0, w1, w2, w3, digest);
+}
+
+KERNEL_FQ void m25500_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha256_tmp_t, pbkdf2_sha256_aes_gcm_t))
+{
+  /**
+   * base
+   */
+
+  const u64 gid = get_global_id (0);
+
+  if (gid >= gid_max) return;
+
+  sha256_hmac_ctx_t sha256_hmac_ctx;
+
+  sha256_hmac_init_global_swap (&sha256_hmac_ctx, pws[gid].i, pws[gid].pw_len);
+
+  tmps[gid].ipad[0] = sha256_hmac_ctx.ipad.h[0];
+  tmps[gid].ipad[1] = sha256_hmac_ctx.ipad.h[1];
+  tmps[gid].ipad[2] = sha256_hmac_ctx.ipad.h[2];
+  tmps[gid].ipad[3] = sha256_hmac_ctx.ipad.h[3];
+  tmps[gid].ipad[4] = sha256_hmac_ctx.ipad.h[4];
+  tmps[gid].ipad[5] = sha256_hmac_ctx.ipad.h[5];
+  tmps[gid].ipad[6] = sha256_hmac_ctx.ipad.h[6];
+  tmps[gid].ipad[7] = sha256_hmac_ctx.ipad.h[7];
+
+  tmps[gid].opad[0] = sha256_hmac_ctx.opad.h[0];
+  tmps[gid].opad[1] = sha256_hmac_ctx.opad.h[1];
+  tmps[gid].opad[2] = sha256_hmac_ctx.opad.h[2];
+  tmps[gid].opad[3] = sha256_hmac_ctx.opad.h[3];
+  tmps[gid].opad[4] = sha256_hmac_ctx.opad.h[4];
+  tmps[gid].opad[5] = sha256_hmac_ctx.opad.h[5];
+  tmps[gid].opad[6] = sha256_hmac_ctx.opad.h[6];
+  tmps[gid].opad[7] = sha256_hmac_ctx.opad.h[7];
+
+  sha256_hmac_update_global_swap (&sha256_hmac_ctx, esalt_bufs[DIGESTS_OFFSET].salt_buf, salt_bufs[SALT_POS].salt_len);
+
+  for (u32 i = 0, j = 1; i < 8; i += 8, j += 1)
+  {
+    sha256_hmac_ctx_t sha256_hmac_ctx2 = sha256_hmac_ctx;
+
+    u32 w0[4];
+    u32 w1[4];
+    u32 w2[4];
+    u32 w3[4];
+
+    w0[0] = j;
+    w0[1] = 0;
+    w0[2] = 0;
+    w0[3] = 0;
+    w1[0] = 0;
+    w1[1] = 0;
+    w1[2] = 0;
+    w1[3] = 0;
+    w2[0] = 0;
+    w2[1] = 0;
+    w2[2] = 0;
+    w2[3] = 0;
+    w3[0] = 0;
+    w3[1] = 0;
+    w3[2] = 0;
+    w3[3] = 0;
+
+    sha256_hmac_update_64 (&sha256_hmac_ctx2, w0, w1, w2, w3, 4);
+
+    sha256_hmac_final (&sha256_hmac_ctx2);
+
+    tmps[gid].dgst[i + 0] = sha256_hmac_ctx2.opad.h[0];
+    tmps[gid].dgst[i + 1] = sha256_hmac_ctx2.opad.h[1];
+    tmps[gid].dgst[i + 2] = sha256_hmac_ctx2.opad.h[2];
+    tmps[gid].dgst[i + 3] = sha256_hmac_ctx2.opad.h[3];
+    tmps[gid].dgst[i + 4] = sha256_hmac_ctx2.opad.h[4];
+    tmps[gid].dgst[i + 5] = sha256_hmac_ctx2.opad.h[5];
+    tmps[gid].dgst[i + 6] = sha256_hmac_ctx2.opad.h[6];
+    tmps[gid].dgst[i + 7] = sha256_hmac_ctx2.opad.h[7];
+
+    tmps[gid].out[i + 0] = tmps[gid].dgst[i + 0];
+    tmps[gid].out[i + 1] = tmps[gid].dgst[i + 1];
+    tmps[gid].out[i + 2] = tmps[gid].dgst[i + 2];
+    tmps[gid].out[i + 3] = tmps[gid].dgst[i + 3];
+    tmps[gid].out[i + 4] = tmps[gid].dgst[i + 4];
+    tmps[gid].out[i + 5] = tmps[gid].dgst[i + 5];
+    tmps[gid].out[i + 6] = tmps[gid].dgst[i + 6];
+    tmps[gid].out[i + 7] = tmps[gid].dgst[i + 7];
+  }
+}
+
+KERNEL_FQ void m25500_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha256_tmp_t, pbkdf2_sha256_aes_gcm_t))
+{
+  const u64 gid = get_global_id (0);
+
+  if ((gid * VECT_SIZE) >= gid_max) return;
+
+  u32x ipad[8];
+  u32x opad[8];
+
+  ipad[0] = packv (tmps, ipad, gid, 0);
+  ipad[1] = packv (tmps, ipad, gid, 1);
+  ipad[2] = packv (tmps, ipad, gid, 2);
+  ipad[3] = packv (tmps, ipad, gid, 3);
+  ipad[4] = packv (tmps, ipad, gid, 4);
+  ipad[5] = packv (tmps, ipad, gid, 5);
+  ipad[6] = packv (tmps, ipad, gid, 6);
+  ipad[7] = packv (tmps, ipad, gid, 7);
+
+  opad[0] = packv (tmps, opad, gid, 0);
+  opad[1] = packv (tmps, opad, gid, 1);
+  opad[2] = packv (tmps, opad, gid, 2);
+  opad[3] = packv (tmps, opad, gid, 3);
+  opad[4] = packv (tmps, opad, gid, 4);
+  opad[5] = packv (tmps, opad, gid, 5);
+  opad[6] = packv (tmps, opad, gid, 6);
+  opad[7] = packv (tmps, opad, gid, 7);
+
+  for (u32 i = 0; i < 8; i += 8)
+  {
+    u32x dgst[8];
+    u32x out[8];
+
+    dgst[0] = packv (tmps, dgst, gid, i + 0);
+    dgst[1] = packv (tmps, dgst, gid, i + 1);
+    dgst[2] = packv (tmps, dgst, gid, i + 2);
+    dgst[3] = packv (tmps, dgst, gid, i + 3);
+    dgst[4] = packv (tmps, dgst, gid, i + 4);
+    dgst[5] = packv (tmps, dgst, gid, i + 5);
+    dgst[6] = packv (tmps, dgst, gid, i + 6);
+    dgst[7] = packv (tmps, dgst, gid, i + 7);
+
+    out[0] = packv (tmps, out, gid, i + 0);
+    out[1] = packv (tmps, out, gid, i + 1);
+    out[2] = packv (tmps, out, gid, i + 2);
+    out[3] = packv (tmps, out, gid, i + 3);
+    out[4] = packv (tmps, out, gid, i + 4);
+    out[5] = packv (tmps, out, gid, i + 5);
+    out[6] = packv (tmps, out, gid, i + 6);
+    out[7] = packv (tmps, out, gid, i + 7);
+
+    for (u32 j = 0; j < loop_cnt; j++)
+    {
+      u32x w0[4];
+      u32x w1[4];
+      u32x w2[4];
+      u32x w3[4];
+
+      w0[0] = dgst[0];
+      w0[1] = dgst[1];
+      w0[2] = dgst[2];
+      w0[3] = dgst[3];
+      w1[0] = dgst[4];
+      w1[1] = dgst[5];
+      w1[2] = dgst[6];
+      w1[3] = dgst[7];
+      w2[0] = 0x80000000;
+      w2[1] = 0;
+      w2[2] = 0;
+      w2[3] = 0;
+      w3[0] = 0;
+      w3[1] = 0;
+      w3[2] = 0;
+      w3[3] = (64 + 32) * 8;
+
+      hmac_sha256_run_V (w0, w1, w2, w3, ipad, opad, dgst);
+
+      out[0] ^= dgst[0];
+      out[1] ^= dgst[1];
+      out[2] ^= dgst[2];
+      out[3] ^= dgst[3];
+      out[4] ^= dgst[4];
+      out[5] ^= dgst[5];
+      out[6] ^= dgst[6];
+      out[7] ^= dgst[7];
+    }
+
+    unpackv (tmps, dgst, gid, i + 0, dgst[0]);
+    unpackv (tmps, dgst, gid, i + 1, dgst[1]);
+    unpackv (tmps, dgst, gid, i + 2, dgst[2]);
+    unpackv (tmps, dgst, gid, i + 3, dgst[3]);
+    unpackv (tmps, dgst, gid, i + 4, dgst[4]);
+    unpackv (tmps, dgst, gid, i + 5, dgst[5]);
+    unpackv (tmps, dgst, gid, i + 6, dgst[6]);
+    unpackv (tmps, dgst, gid, i + 7, dgst[7]);
+
+    unpackv (tmps, out, gid, i + 0, out[0]);
+    unpackv (tmps, out, gid, i + 1, out[1]);
+    unpackv (tmps, out, gid, i + 2, out[2]);
+    unpackv (tmps, out, gid, i + 3, out[3]);
+    unpackv (tmps, out, gid, i + 4, out[4]);
+    unpackv (tmps, out, gid, i + 5, out[5]);
+    unpackv (tmps, out, gid, i + 6, out[6]);
+    unpackv (tmps, out, gid, i + 7, out[7]);
+  }
+}
+
+KERNEL_FQ void m25500_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha256_tmp_t, pbkdf2_sha256_aes_gcm_t))
+{
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * aes shared
+   */
+
+  #ifdef REAL_SHM
+
+  LOCAL_VK u32 s_te0[256];
+  LOCAL_VK u32 s_te1[256];
+  LOCAL_VK u32 s_te2[256];
+  LOCAL_VK u32 s_te3[256];
+  LOCAL_VK u32 s_te4[256];
+
+  for (u32 i = lid; i < 256; i += lsz)
+  {
+    s_te0[i] = te0[i];
+    s_te1[i] = te1[i];
+    s_te2[i] = te2[i];
+    s_te3[i] = te3[i];
+    s_te4[i] = te4[i];
+  }
+
+  SYNC_THREADS ();
+
+  #else
+
+  CONSTANT_AS u32a *s_te0 = te0;
+  CONSTANT_AS u32a *s_te1 = te1;
+  CONSTANT_AS u32a *s_te2 = te2;
+  CONSTANT_AS u32a *s_te3 = te3;
+  CONSTANT_AS u32a *s_te4 = te4;
+
+  #endif
+
+  if (gid >= gid_max) return;
+
+  // keys
+
+  u32 ukey[8];
+
+  ukey[0] = tmps[gid].out[0];
+  ukey[1] = tmps[gid].out[1];
+  ukey[2] = tmps[gid].out[2];
+  ukey[3] = tmps[gid].out[3];
+  ukey[4] = tmps[gid].out[4];
+  ukey[5] = tmps[gid].out[5];
+  ukey[6] = tmps[gid].out[6];
+  ukey[7] = tmps[gid].out[7];
+
+  u32 key_len = 32 * 8;
+
+  u32 key[60] = { 0 };
+  u32 subKey[4] = { 0 };
+
+  AES_GCM_Init (ukey, key_len, key, subKey, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+  // iv
+
+  const u32 iv[4] = {
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[0],
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[1],
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[2],
+    esalt_bufs[DIGESTS_OFFSET].iv_buf[3]
+  };
+
+  const u32 iv_len = esalt_bufs[DIGESTS_OFFSET].iv_len;
+
+  u32 J0[4] = { 0 };
+
+  AES_GCM_Prepare_J0 (iv, iv_len, subKey, J0);
+
+  // ct
+
+  /*
+  u32 enc[14] = { 0 };
+
+  enc[ 0] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 0];
+  enc[ 1] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 1];
+  enc[ 2] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 2];
+  enc[ 3] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 3];
+  enc[ 4] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 4];
+  enc[ 5] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 5];
+  enc[ 6] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 6];
+  enc[ 7] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 7];
+  enc[ 8] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 8];
+  enc[ 9] = esalt_bufs[DIGESTS_OFFSET].ct_buf[ 9];
+  enc[10] = esalt_bufs[DIGESTS_OFFSET].ct_buf[10];
+  enc[11] = esalt_bufs[DIGESTS_OFFSET].ct_buf[11];
+  enc[12] = esalt_bufs[DIGESTS_OFFSET].ct_buf[12];
+  enc[13] = esalt_bufs[DIGESTS_OFFSET].ct_buf[13];
+
+  u32 enc_len = esalt_bufs[DIGESTS_OFFSET].ct_len;
+  */
+
+  /*
+  // decrypt buffer is not usefull here, skip
+  u32 dec[14] = { 0 };
+
+  AES_GCM_GCTR (key, J0, enc, enc_len, dec, s_te0, s_te1, s_te2, s_te3, s_te4);
+  */
+
+  u32 T[4] = { 0 };
+  u32 S[4] = { 0 };
+
+  u32 S_len   = 16;
+  u32 aad_buf[4] = { 0 };
+  u32 aad_len = 0;
+
+  //AES_GCM_GHASH (subKey, aad_buf, aad_len, enc, enc_len, S);
+
+  AES_GCM_GHASH_GLOBAL (subKey, aad_buf, aad_len, esalt_bufs[DIGESTS_OFFSET].ct_buf, esalt_bufs[DIGESTS_OFFSET].ct_len, S);
+
+  AES_GCM_GCTR (key, J0, S, S_len, T, s_te0, s_te1, s_te2, s_te3, s_te4);
+
+  /* compare tag */
+
+  const u32 r0 = T[0];
+  const u32 r1 = T[1];
+  const u32 r2 = T[2];
+  const u32 r3 = T[3];
+
+  #define il_pos 0
+
+  #ifdef KERNEL_STATIC
+  #include COMPARE_M
+  #endif
+}
diff --git a/docs/changes.txt b/docs/changes.txt
index baae7c6fd..9f92e8d95 100644
--- a/docs/changes.txt
+++ b/docs/changes.txt
@@ -10,12 +10,16 @@
 - Added hash-mode: BestCrypt v3 Volume Encryption
 - Added hash-mode: Bitwarden
 - Added hash-mode: Dahua Authentication MD5
+- Added hash-mode: MongoDB ServerKey SCRAM-SHA-1
+- Added hash-mode: MongoDB ServerKey SCRAM-SHA-256
 - Added hash-mode: MS Office 2016 - SheetProtection
+- Added hash-mode: PDF 1.4 - 1.6 (Acrobat 5 - 8) - edit password
 - Added hash-mode: PKCS#8 Private Keys
 - Added hash-mode: RAR3-p (Compressed)
 - Added hash-mode: RAR3-p (Uncompressed)
 - Added hash-mode: RSA/DSA/EC/OPENSSH Private Keys
 - Added hash-mode: SQLCipher
+- Added hash-mode: Stargazer Stellar Wallet XLM
 - Added hash-mode: Stuffit5
 - Added hash-mode: Umbraco HMAC-SHA1
 - Added hash-mode: sha1(sha1($pass).$salt)
@@ -24,6 +28,7 @@
 ## Features
 ##
 
+- Added support for true UTF8 to UTF16 conversion in kernel crypto library
 - Added option --hash-info to show generic information for each hash-mode
 - Removed option --example-hashes, now is an alias of --hash-info
 
@@ -38,6 +43,7 @@
 - Fixed rare case of misalignment of the status prompt when other user warnings are shown within the hashcat output
 - Fixed password reassembling for cracked hashes on host for slow hashes in optimized mode that are longer than 32 characters
 - Fixed incorrect maximum password length support for -m 400 in optimized mode (reduced from 55 to 39)
+- Fixed invalid handling of outfile folder entries for -m 22000
 
 ##
 ## Improvements
@@ -47,6 +53,7 @@
 - CUDA Backend: Give detailed warning if either the NVIDIA CUDA or the NVIDIA RTC library cannot be initialized
 - CUDA Backend: Do not warn about missing CUDA SDK installation if --backend-ignore-cuda is used
 - CUDA Backend: Use blocking events to avoid 100% CPU core usage (per GPU)
+- OpenCL Runtime: Workaround JiT compiler deadlock on NVIDIA driver >= 465.89
 - RAR3 Kernels: Improved loop code, improving performance by 23%
 - Startup time: Improved the startup time by avoiding some time intensive operations for skipped devices
 
@@ -59,7 +66,8 @@
 - Hash-Mode 11600 (7-Zip): Improved memory handling (alloc and free) for the hook function
 - Hash-Mode 13200 (AxCrypt): Changed the name to AxCrypt 1 to avoid confusion
 - Hash-Mode 13300 (AxCrypt in-memory SHA1): Changed the name to AxCrypt 1 in-memory SHA1
-- OpenCL Runtime: Switched default OpenCL device type on macOS from GPU to CPU. Use -D 2 to enable GPU devices.
+- Kernel Crypto Library: Removed unnecessary utf16 conversion functions which would apply on HMAC data portion
+- OpenCL Runtime: Switched default OpenCL device type on macOS from GPU to CPU. Use -D 2 to enable GPU devices
 - Unit tests: Added Python 3 support for all of the Python code in our test framework
 - Unit tests: Fixed the packaging of test (-p) feature
 
diff --git a/docs/readme.txt b/docs/readme.txt
index c55e60559..52e01db48 100644
--- a/docs/readme.txt
+++ b/docs/readme.txt
@@ -162,8 +162,10 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or
 - Skype
 - Telegram Desktop App Passcode (PBKDF2-HMAC-SHA1)
 - Telegram Mobile App Passcode (SHA256)
-- PostgreSQL CRAM (MD5)
+- MongoDB ServerKey SCRAM-SHA-1
+- MongoDB ServerKey SCRAM-SHA-256
 - MySQL CRAM (SHA1)
+- PostgreSQL CRAM (MD5)
 - XMPP SCRAM
 - RACF
 - AIX {smd5}
@@ -260,6 +262,7 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or
 - PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1
 - PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2
 - PDF 1.4 - 1.6 (Acrobat 5 - 8)
+- PDF 1.4 - 1.6 (Acrobat 5 - 8) - edit password
 - PDF 1.7 Level 3 (Acrobat 9)
 - PDF 1.7 Level 8 (Acrobat 10 - 11)
 - Apple iWork
@@ -292,6 +295,7 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or
 - Blockchain, My Wallet
 - Blockchain, My Wallet, V2
 - Blockchain, My Wallet, Second Password (SHA256)
+- Stargazer Stellar Wallet XLM
 - Ethereum Pre-Sale Wallet, PBKDF2-HMAC-SHA256
 - Ethereum Wallet, PBKDF2-HMAC-SHA256
 - Ethereum Wallet, SCRYPT
diff --git a/include/backend.h b/include/backend.h
index 517e18bba..e9b7a9d4f 100644
--- a/include/backend.h
+++ b/include/backend.h
@@ -80,6 +80,7 @@ int hc_cuLinkDestroy             (hashcat_ctx_t *hashcat_ctx, CUlinkState state)
 int hc_cuLinkComplete            (hashcat_ctx_t *hashcat_ctx, CUlinkState state, void **cubinOut, size_t *sizeOut);
 
 int hc_clBuildProgram            (hashcat_ctx_t *hashcat_ctx, cl_program program, cl_uint num_devices, const cl_device_id *device_list, const char *options, void (CL_CALLBACK *pfn_notify) (cl_program program, void *user_data), void *user_data);
+int hc_clCompileProgram          (hashcat_ctx_t *hashcat_ctx, cl_program program, cl_uint num_devices, const cl_device_id *device_list, const char *options, cl_uint num_input_headers, const cl_program *input_headers, const char **header_include_names, void (CL_CALLBACK *pfn_notify) (cl_program program, void *user_data), void *user_data);
 int hc_clCreateBuffer            (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_mem_flags flags, size_t size, void *host_ptr, cl_mem *mem);
 int hc_clCreateCommandQueue      (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_command_queue *command_queue);
 int hc_clCreateContext           (hashcat_ctx_t *hashcat_ctx, const cl_context_properties *properties, cl_uint num_devices, const cl_device_id *devices, void (CL_CALLBACK *pfn_notify) (const char *errinfo, const void *private_info, size_t cb, void *user_data), void *user_data, cl_context *context);
@@ -103,6 +104,7 @@ int hc_clGetPlatformIDs          (hashcat_ctx_t *hashcat_ctx, cl_uint num_entrie
 int hc_clGetPlatformInfo         (hashcat_ctx_t *hashcat_ctx, cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret);
 int hc_clGetProgramBuildInfo     (hashcat_ctx_t *hashcat_ctx, cl_program program, cl_device_id device, cl_program_build_info param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret);
 int hc_clGetProgramInfo          (hashcat_ctx_t *hashcat_ctx, cl_program program, cl_program_info param_name, size_t param_value_size, void *param_value, size_t * param_value_size_ret);
+int hc_clLinkProgram             (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint num_devices, const cl_device_id *device_list, const char *options, cl_uint num_input_programs, const cl_program *input_programs, void (CL_CALLBACK *pfn_notify) (cl_program program, void *user_data), void *user_data, cl_program *program);
 int hc_clReleaseCommandQueue     (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue);
 int hc_clReleaseContext          (hashcat_ctx_t *hashcat_ctx, cl_context context);
 int hc_clReleaseEvent            (hashcat_ctx_t *hashcat_ctx, cl_event event);
diff --git a/include/ext_OpenCL.h b/include/ext_OpenCL.h
index 0fc0d01b9..54f3b4182 100644
--- a/include/ext_OpenCL.h
+++ b/include/ext_OpenCL.h
@@ -38,6 +38,7 @@ typedef union
 #define CL_PLATFORMS_MAX 16
 
 typedef cl_int           (CL_API_CALL *OCL_CLBUILDPROGRAM)            (cl_program, cl_uint, const cl_device_id *, const char *, void (CL_CALLBACK *)(cl_program, void *), void *);
+typedef cl_int           (CL_API_CALL *OCL_CLCOMPILEPROGRAM)          (cl_program, cl_uint, const cl_device_id *, const char *, cl_uint, const cl_program *, const char **, void (CL_CALLBACK *)(cl_program, void *), void *);
 typedef cl_mem           (CL_API_CALL *OCL_CLCREATEBUFFER)            (cl_context, cl_mem_flags, size_t, void *, cl_int *);
 typedef cl_command_queue (CL_API_CALL *OCL_CLCREATECOMMANDQUEUE)      (cl_context, cl_device_id, cl_command_queue_properties, cl_int *);
 typedef cl_context       (CL_API_CALL *OCL_CLCREATECONTEXT)           (const cl_context_properties *, cl_uint, const cl_device_id *, void (CL_CALLBACK *)(const char *, const void *, size_t, void *), void *, cl_int *);
@@ -61,6 +62,7 @@ typedef cl_int           (CL_API_CALL *OCL_CLGETPLATFORMIDS)          (cl_uint,
 typedef cl_int           (CL_API_CALL *OCL_CLGETPLATFORMINFO)         (cl_platform_id, cl_platform_info, size_t, void *, size_t *);
 typedef cl_int           (CL_API_CALL *OCL_CLGETPROGRAMBUILDINFO)     (cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *);
 typedef cl_int           (CL_API_CALL *OCL_CLGETPROGRAMINFO)          (cl_program, cl_program_info, size_t, void *, size_t *);
+typedef cl_program       (CL_API_CALL *OCL_CLLINKPROGRAM)             (cl_context, cl_uint, const cl_device_id *, const char *, cl_uint, const cl_program *, void (CL_CALLBACK *) (cl_program, void *), void *, cl_int *);
 typedef cl_int           (CL_API_CALL *OCL_CLRELEASECOMMANDQUEUE)     (cl_command_queue);
 typedef cl_int           (CL_API_CALL *OCL_CLRELEASECONTEXT)          (cl_context);
 typedef cl_int           (CL_API_CALL *OCL_CLRELEASEEVENT)            (cl_event);
@@ -75,6 +77,7 @@ typedef struct hc_opencl_lib
   hc_dynlib_t lib;
 
   OCL_CLBUILDPROGRAM            clBuildProgram;
+  OCL_CLCOMPILEPROGRAM          clCompileProgram;
   OCL_CLCREATEBUFFER            clCreateBuffer;
   OCL_CLCREATECOMMANDQUEUE      clCreateCommandQueue;
   OCL_CLCREATECONTEXT           clCreateContext;
@@ -98,6 +101,7 @@ typedef struct hc_opencl_lib
   OCL_CLGETPLATFORMINFO         clGetPlatformInfo;
   OCL_CLGETPROGRAMBUILDINFO     clGetProgramBuildInfo;
   OCL_CLGETPROGRAMINFO          clGetProgramInfo;
+  OCL_CLLINKPROGRAM             clLinkProgram;
   OCL_CLRELEASECOMMANDQUEUE     clReleaseCommandQueue;
   OCL_CLRELEASECONTEXT          clReleaseContext;
   OCL_CLRELEASEEVENT            clReleaseEvent;
diff --git a/include/ext_lzma.h b/include/ext_lzma.h
index a346a8e22..194067ba7 100644
--- a/include/ext_lzma.h
+++ b/include/ext_lzma.h
@@ -4,6 +4,7 @@
  */
 
 #ifndef _EXT_LZMA_H
+#define _EXT_LZMA_H
 
 #include <LzmaDec.h>
 #include <Lzma2Dec.h>
diff --git a/include/folder.h b/include/folder.h
index 75f214b1a..34b4618bf 100644
--- a/include/folder.h
+++ b/include/folder.h
@@ -3,6 +3,9 @@
  * License.....: MIT
  */
 
+#ifndef _FOLDER_H
+#define _FOLDER_H
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -34,3 +37,5 @@ int  folder_config_init    (hashcat_ctx_t *hashcat_ctx, MAYBE_UNUSED const char
 void folder_config_destroy (hashcat_ctx_t *hashcat_ctx);
 
 int hc_mkdir (const char *name, MAYBE_UNUSED const int mode);
+
+#endif // _FOLDER_H
diff --git a/include/types.h b/include/types.h
index 3f1a1cb9f..466c985f5 100644
--- a/include/types.h
+++ b/include/types.h
@@ -423,6 +423,8 @@ typedef enum opts_type
   OPTS_TYPE_AUX3              = (1ULL << 37),
   OPTS_TYPE_AUX4              = (1ULL << 38),
   OPTS_TYPE_BINARY_HASHFILE   = (1ULL << 39),
+  OPTS_TYPE_BINARY_HASHFILE_OPTIONAL
+                              = (1ULL << 40), // this allows us to not enforce the use of a binary file. requires OPTS_TYPE_BINARY_HASHFILE set to be effective.
   OPTS_TYPE_PT_ADD06          = (1ULL << 41),
   OPTS_TYPE_KEYBOARD_MAPPING  = (1ULL << 42),
   OPTS_TYPE_DEEP_COMP_KERNEL  = (1ULL << 43), // if we have to iterate through each hash inside the comp kernel, for example if each hash has to be decrypted separately
@@ -542,6 +544,8 @@ typedef enum parser_rc
   PARSER_BLOCK_SIZE           = -39,
   PARSER_CIPHER               = -40,
   PARSER_FILE_SIZE            = -41,
+  PARSER_IV_LENGTH            = -42,
+  PARSER_CT_LENGTH            = -43,
   PARSER_HAVE_ERRNO           = -100,
   PARSER_UNKNOWN_ERROR        = -255
 
@@ -2613,8 +2617,6 @@ typedef struct token
 
 } token_t;
 
-#endif // _TYPES_H
-
 /**
  * hash category is relevant in usage.c (--help screen)
  */
@@ -2648,3 +2650,5 @@ typedef enum hash_category
 // hash specific
 
 typedef aes_ctx AES_KEY;
+
+#endif // _TYPES_H
diff --git a/src/backend.c b/src/backend.c
index 6eeaa4c23..bc5ce0fe1 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -2183,6 +2183,7 @@ int ocl_init (hashcat_ctx_t *hashcat_ctx)
   if (ocl->lib == NULL) return -1;
 
   HC_LOAD_FUNC (ocl, clBuildProgram,            OCL_CLBUILDPROGRAM,             OpenCL, 1);
+  HC_LOAD_FUNC (ocl, clCompileProgram,          OCL_CLCOMPILEPROGRAM,           OpenCL, 1);
   HC_LOAD_FUNC (ocl, clCreateBuffer,            OCL_CLCREATEBUFFER,             OpenCL, 1);
   HC_LOAD_FUNC (ocl, clCreateCommandQueue,      OCL_CLCREATECOMMANDQUEUE,       OpenCL, 1);
   HC_LOAD_FUNC (ocl, clCreateContext,           OCL_CLCREATECONTEXT,            OpenCL, 1);
@@ -2205,6 +2206,7 @@ int ocl_init (hashcat_ctx_t *hashcat_ctx)
   HC_LOAD_FUNC (ocl, clGetPlatformInfo,         OCL_CLGETPLATFORMINFO,          OpenCL, 1);
   HC_LOAD_FUNC (ocl, clGetProgramBuildInfo,     OCL_CLGETPROGRAMBUILDINFO,      OpenCL, 1);
   HC_LOAD_FUNC (ocl, clGetProgramInfo,          OCL_CLGETPROGRAMINFO,           OpenCL, 1);
+  HC_LOAD_FUNC (ocl, clLinkProgram,             OCL_CLLINKPROGRAM,              OpenCL, 1);
   HC_LOAD_FUNC (ocl, clReleaseCommandQueue,     OCL_CLRELEASECOMMANDQUEUE,      OpenCL, 1);
   HC_LOAD_FUNC (ocl, clReleaseContext,          OCL_CLRELEASECONTEXT,           OpenCL, 1);
   HC_LOAD_FUNC (ocl, clReleaseKernel,           OCL_CLRELEASEKERNEL,            OpenCL, 1);
@@ -2571,6 +2573,44 @@ int hc_clBuildProgram (hashcat_ctx_t *hashcat_ctx, cl_program program, cl_uint n
   return 0;
 }
 
+int hc_clCompileProgram (hashcat_ctx_t *hashcat_ctx, cl_program program, cl_uint num_devices, const cl_device_id *device_list, const char *options, cl_uint num_input_headers, const cl_program *input_headers, const char **header_include_names, void (CL_CALLBACK *pfn_notify) (cl_program program, void *user_data), void *user_data)
+{
+  backend_ctx_t *backend_ctx = hashcat_ctx->backend_ctx;
+
+  OCL_PTR *ocl = (OCL_PTR *) backend_ctx->ocl;
+
+  const cl_int CL_err = ocl->clCompileProgram (program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data);
+
+  if (CL_err != CL_SUCCESS)
+  {
+    event_log_error (hashcat_ctx, "clCompileProgram(): %s", val2cstr_cl (CL_err));
+
+    return -1;
+  }
+
+  return 0;
+}
+
+int hc_clLinkProgram (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint num_devices, const cl_device_id *device_list, const char *options, cl_uint num_input_programs, const cl_program *input_programs, void (CL_CALLBACK *pfn_notify) (cl_program program, void *user_data), void *user_data, cl_program *program)
+{
+  backend_ctx_t *backend_ctx = hashcat_ctx->backend_ctx;
+
+  OCL_PTR *ocl = (OCL_PTR *) backend_ctx->ocl;
+
+  cl_int CL_err;
+
+  *program = ocl->clLinkProgram (context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, &CL_err);
+
+  if (CL_err != CL_SUCCESS)
+  {
+    event_log_error (hashcat_ctx, "clLinkProgram(): %s", val2cstr_cl (CL_err));
+
+    return -1;
+  }
+
+  return 0;
+}
+
 int hc_clCreateKernel (hashcat_ctx_t *hashcat_ctx, cl_program program, const char *kernel_name, cl_kernel *kernel)
 {
   backend_ctx_t *backend_ctx = hashcat_ctx->backend_ctx;
@@ -5482,7 +5522,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       CUdevice cuda_device;
 
-      if (hc_cuDeviceGet (hashcat_ctx, &cuda_device, cuda_devices_idx) == -1) return -1;
+      if (hc_cuDeviceGet (hashcat_ctx, &cuda_device, cuda_devices_idx) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->cuda_device = cuda_device;
 
@@ -5498,7 +5542,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       char *device_name = (char *) hcmalloc (HCBUFSIZ_TINY);
 
-      if (hc_cuDeviceGetName (hashcat_ctx, device_name, HCBUFSIZ_TINY, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetName (hashcat_ctx, device_name, HCBUFSIZ_TINY, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->device_name = device_name;
 
@@ -5510,7 +5558,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int device_processors = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_processors, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_processors, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->device_processors = device_processors;
 
@@ -5518,7 +5570,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       size_t bytes = 0;
 
-      if (hc_cuDeviceTotalMem (hashcat_ctx, &bytes, cuda_device) == -1) return -1;
+      if (hc_cuDeviceTotalMem (hashcat_ctx, &bytes, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->device_global_mem = (u64) bytes;
 
@@ -5530,7 +5586,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int cuda_warp_size = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &cuda_warp_size, CU_DEVICE_ATTRIBUTE_WARP_SIZE, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &cuda_warp_size, CU_DEVICE_ATTRIBUTE_WARP_SIZE, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->cuda_warp_size = cuda_warp_size;
 
@@ -5539,9 +5599,17 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
       int sm_major = 0;
       int sm_minor = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &sm_major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &sm_major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &sm_minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &sm_minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->sm_major = sm_major;
       device_param->sm_minor = sm_minor;
@@ -5550,7 +5618,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int device_maxworkgroup_size = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_maxworkgroup_size, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_maxworkgroup_size, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->device_maxworkgroup_size = device_maxworkgroup_size;
 
@@ -5558,7 +5630,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int device_maxclock_frequency = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_maxclock_frequency, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_maxclock_frequency, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->device_maxclock_frequency = device_maxclock_frequency / 1000;
 
@@ -5568,11 +5644,23 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
       int pci_bus_id_nv     = 0;
       int pci_slot_id_nv    = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &pci_domain_id_nv, CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &pci_domain_id_nv, CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &pci_bus_id_nv, CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &pci_bus_id_nv, CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &pci_slot_id_nv, CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &pci_slot_id_nv, CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->pcie_domain   = (u8) (pci_domain_id_nv);
       device_param->pcie_bus      = (u8) (pci_bus_id_nv);
@@ -5583,7 +5671,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int kernel_exec_timeout = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &kernel_exec_timeout, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &kernel_exec_timeout, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->kernel_exec_timeout = kernel_exec_timeout;
 
@@ -5591,7 +5683,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int max_shared_memory_per_block = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &max_shared_memory_per_block, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &max_shared_memory_per_block, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       if (max_shared_memory_per_block < 32768)
       {
@@ -5606,7 +5702,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       int device_max_constant_buffer_size = 0;
 
-      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_max_constant_buffer_size, CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, cuda_device) == -1) return -1;
+      if (hc_cuDeviceGetAttribute (hashcat_ctx, &device_max_constant_buffer_size, CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       if (device_max_constant_buffer_size < 65536)
       {
@@ -5684,11 +5784,7 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
           }
         }
 
-        /**
-         * activate device
-         */
-
-        cuda_devices_active++;
+        // activate device moved below, at end
       }
 
       // instruction set
@@ -5713,18 +5809,40 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       CUcontext cuda_context;
 
-      if (hc_cuCtxCreate (hashcat_ctx, &cuda_context, CU_CTX_SCHED_BLOCKING_SYNC, device_param->cuda_device) == -1) return -1;
+      if (hc_cuCtxCreate (hashcat_ctx, &cuda_context, CU_CTX_SCHED_BLOCKING_SYNC, device_param->cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
-      if (hc_cuCtxSetCurrent (hashcat_ctx, cuda_context) == -1) return -1;
+      if (hc_cuCtxSetCurrent (hashcat_ctx, cuda_context) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       size_t free  = 0;
       size_t total = 0;
 
-      if (hc_cuMemGetInfo (hashcat_ctx, &free, &total) == -1) return -1;
+      if (hc_cuMemGetInfo (hashcat_ctx, &free, &total) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       device_param->device_available_mem = (u64) free;
 
-      if (hc_cuCtxDestroy (hashcat_ctx, cuda_context) == -1) return -1;
+      if (hc_cuCtxDestroy (hashcat_ctx, cuda_context) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
+
+      /**
+       * activate device
+       */
+
+      if (device_param->skipped == false) cuda_devices_active++;
     }
   }
 
@@ -5810,7 +5928,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_device_type opencl_device_type;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_TYPE, sizeof (opencl_device_type), &opencl_device_type, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_TYPE, sizeof (opencl_device_type), &opencl_device_type, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         opencl_device_type &= ~CL_DEVICE_TYPE_DEFAULT;
 
@@ -5818,11 +5940,19 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         // device_name
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NAME, 0, NULL, &param_value_size) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NAME, 0, NULL, &param_value_size) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         char *device_name = (char *) hcmalloc (param_value_size);
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NAME, param_value_size, device_name, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NAME, param_value_size, device_name, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_name = device_name;
 
@@ -5832,11 +5962,19 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         // device_vendor
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         char *opencl_device_vendor = (char *) hcmalloc (param_value_size);
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VENDOR, param_value_size, opencl_device_vendor, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VENDOR, param_value_size, opencl_device_vendor, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->opencl_device_vendor = opencl_device_vendor;
 
@@ -5899,21 +6037,37 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         // device_version
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VERSION, 0, NULL, &param_value_size) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VERSION, 0, NULL, &param_value_size) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         char *opencl_device_version = (char *) hcmalloc (param_value_size);
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VERSION, param_value_size, opencl_device_version, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_VERSION, param_value_size, opencl_device_version, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->opencl_device_version = opencl_device_version;
 
         // opencl_device_c_version
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         char *opencl_device_c_version = (char *) hcmalloc (param_value_size);
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, opencl_device_c_version, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, opencl_device_c_version, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->opencl_device_c_version = opencl_device_c_version;
 
@@ -5921,7 +6075,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_uint device_processors = 0;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_processors = device_processors;
 
@@ -5929,7 +6087,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_ulong device_global_mem = 0;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_global_mem = device_global_mem;
 
@@ -5939,7 +6101,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_ulong device_maxmem_alloc = 0;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_maxmem_alloc = device_maxmem_alloc;
 
@@ -5951,7 +6117,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         size_t device_maxworkgroup_size = 0;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_maxworkgroup_size = device_maxworkgroup_size;
 
@@ -5959,7 +6129,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_uint device_maxclock_frequency = 0;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_maxclock_frequency = device_maxclock_frequency;
 
@@ -5967,7 +6141,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_bool device_endian_little = CL_FALSE;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if (device_endian_little == CL_FALSE)
         {
@@ -5980,7 +6158,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_bool device_available = CL_FALSE;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if (device_available == CL_FALSE)
         {
@@ -5993,7 +6175,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_bool device_compiler_available = CL_FALSE;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if (device_compiler_available == CL_FALSE)
         {
@@ -6006,7 +6192,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_device_exec_capabilities device_execution_capabilities;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
         {
@@ -6019,11 +6209,19 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         size_t device_extensions_size;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         char *device_extensions = (char *) hcmalloc (device_extensions_size + 1);
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if (strstr (device_extensions, "base_atomics") == 0)
         {
@@ -6045,7 +6243,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_device_local_mem_type device_local_mem_type;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_LOCAL_MEM_TYPE, sizeof (device_local_mem_type), &device_local_mem_type, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_LOCAL_MEM_TYPE, sizeof (device_local_mem_type), &device_local_mem_type, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->device_local_mem_type = device_local_mem_type;
 
@@ -6053,7 +6255,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_ulong device_max_constant_buffer_size;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof (device_max_constant_buffer_size), &device_max_constant_buffer_size, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof (device_max_constant_buffer_size), &device_max_constant_buffer_size, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if (device_local_mem_type == CL_LOCAL)
         {
@@ -6069,7 +6275,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         cl_ulong device_local_mem_size = 0;
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         if (device_local_mem_type == CL_LOCAL)
         {
@@ -6228,11 +6438,19 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
         // driver_version
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DRIVER_VERSION, 0, NULL, &param_value_size) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DRIVER_VERSION, 0, NULL, &param_value_size) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         char *opencl_driver_version = (char *) hcmalloc (param_value_size);
 
-        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DRIVER_VERSION, param_value_size, opencl_driver_version, NULL) == -1) return -1;
+        if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DRIVER_VERSION, param_value_size, opencl_driver_version, NULL) == -1)
+        {
+          device_param->skipped = true;
+          continue;
+        }
 
         device_param->opencl_driver_version = opencl_driver_version;
 
@@ -6265,7 +6483,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
           {
             cl_device_topology_amd amdtopo;
 
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_TOPOLOGY_AMD, sizeof (amdtopo), &amdtopo, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_TOPOLOGY_AMD, sizeof (amdtopo), &amdtopo, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
 
             device_param->pcie_domain   = 0; // no attribute to query
             device_param->pcie_bus      = amdtopo.pcie.bus;
@@ -6278,9 +6500,17 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
             cl_uint pci_bus_id_nv;  // is cl_uint the right type for them??
             cl_uint pci_slot_id_nv;
 
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_PCI_BUS_ID_NV, sizeof (pci_bus_id_nv), &pci_bus_id_nv, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_PCI_BUS_ID_NV, sizeof (pci_bus_id_nv), &pci_bus_id_nv, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
 
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_PCI_SLOT_ID_NV, sizeof (pci_slot_id_nv), &pci_slot_id_nv, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_PCI_SLOT_ID_NV, sizeof (pci_slot_id_nv), &pci_slot_id_nv, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
 
             device_param->pcie_domain   = 0; // no attribute to query
             device_param->pcie_bus      = (u8) (pci_bus_id_nv);
@@ -6290,16 +6520,28 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
             int sm_minor = 0;
             int sm_major = 0;
 
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
 
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
 
             device_param->sm_minor = sm_minor;
             device_param->sm_major = sm_major;
 
             cl_uint kernel_exec_timeout = 0;
 
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
 
             device_param->kernel_exec_timeout = kernel_exec_timeout;
 
@@ -6416,7 +6658,8 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
                   event_log_warning (hashcat_ctx, "You can use --force to override this, but do not report related errors.");
                   event_log_warning (hashcat_ctx, NULL);
 
-                  return -1;
+                  device_param->skipped = true;
+                  continue;
                 }
               }
             }
@@ -6454,7 +6697,8 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
                   event_log_warning (hashcat_ctx, "You can use --force to override this, but do not report related errors.");
                   event_log_warning (hashcat_ctx, NULL);
 
-                  return -1;
+                  device_param->skipped = true;
+                  continue;
                 }
               }
 
@@ -6503,7 +6747,8 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
                   event_log_warning (hashcat_ctx, "You can use --force to override this, but do not report related errors.");
                   event_log_warning (hashcat_ctx, NULL);
 
-                  return -1;
+                  device_param->skipped = true;
+                  continue;
                 }
 
                 if (device_param->sm_major < 5)
@@ -6670,7 +6915,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
       CL_rc = hc_clCreateContext (hashcat_ctx, properties, 1, &device_param->opencl_device, NULL, NULL, &context);
       */
 
-      if (hc_clCreateContext (hashcat_ctx, NULL, 1, &device_param->opencl_device, NULL, NULL, &context) == -1) return -1;
+      if (hc_clCreateContext (hashcat_ctx, NULL, 1, &device_param->opencl_device, NULL, NULL, &context) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       /**
        * create command-queue
@@ -6678,7 +6927,11 @@ int backend_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
 
       cl_command_queue command_queue;
 
-      if (hc_clCreateCommandQueue (hashcat_ctx, context, device_param->opencl_device, 0, &command_queue) == -1) return -1;
+      if (hc_clCreateCommandQueue (hashcat_ctx, context, device_param->opencl_device, 0, &command_queue) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       // instruction set
 
@@ -7494,17 +7747,17 @@ static bool load_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_p
 
     if (device_param->is_opencl == true)
     {
-      if (hc_clCreateProgramWithSource (hashcat_ctx, device_param->opencl_context, 1, (const char **) kernel_sources, NULL, opencl_program) == -1) return false;
+      size_t build_log_size = 0;
 
-      const int CL_rc = hc_clBuildProgram (hashcat_ctx, *opencl_program, 1, &device_param->opencl_device, build_options_buf, NULL, NULL);
+      int CL_rc;
 
-      //if (CL_rc == -1) return -1;
+      cl_program p1 = NULL;
 
-      size_t build_log_size = 0;
+      if (hc_clCreateProgramWithSource (hashcat_ctx, device_param->opencl_context, 1, (const char **) kernel_sources, NULL, &p1) == -1) return false;
 
-      hc_clGetProgramBuildInfo (hashcat_ctx, *opencl_program, device_param->opencl_device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
+      CL_rc = hc_clCompileProgram (hashcat_ctx, p1, 1, &device_param->opencl_device, build_options_buf, 0, NULL, NULL, NULL, NULL);
 
-      //if (CL_rc == -1) return -1;
+      hc_clGetProgramBuildInfo (hashcat_ctx, p1, device_param->opencl_device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
 
       #if defined (DEBUG)
       if ((build_log_size > 1) || (CL_rc == -1))
@@ -7514,7 +7767,7 @@ static bool load_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_p
       {
         char *build_log = (char *) hcmalloc (build_log_size + 1);
 
-        const int rc_clGetProgramBuildInfo = hc_clGetProgramBuildInfo (hashcat_ctx, *opencl_program, device_param->opencl_device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
+        const int rc_clGetProgramBuildInfo = hc_clGetProgramBuildInfo (hashcat_ctx, p1, device_param->opencl_device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
 
         if (rc_clGetProgramBuildInfo == -1) return false;
 
@@ -7525,6 +7778,21 @@ static bool load_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_p
 
       if (CL_rc == -1) return false;
 
+      cl_program t2[1];
+
+      t2[0] = p1;
+
+      cl_program fin;
+
+      if (hc_clLinkProgram (hashcat_ctx, device_param->opencl_context, 1, &device_param->opencl_device, NULL, 1, t2, NULL, NULL, &fin) == -1) return false;
+
+      // it seems errors caused by clLinkProgram() do not go into CL_PROGRAM_BUILD
+      // I couldn't find any information on the web explaining how else to retrieve the error messages from the linker
+
+      *opencl_program = fin;
+
+      hc_clReleaseProgram (hashcat_ctx, p1);
+
       if (cache_disable == false)
       {
         size_t binary_size;
@@ -7700,7 +7968,11 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
           if (device_param->is_opencl == true)
           {
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
           }
         }
         else
@@ -7714,7 +7986,11 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
           if (device_param->is_opencl == true)
           {
-            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,  sizeof (vector_width), &vector_width, NULL) == -1) return -1;
+            if (hc_clGetDeviceInfo (hashcat_ctx, device_param->opencl_device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT,  sizeof (vector_width), &vector_width, NULL) == -1)
+            {
+              device_param->skipped = true;
+              continue;
+            }
           }
         }
       }
@@ -7895,7 +8171,11 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
     if (device_param->is_cuda == true)
     {
-      if (hc_cuCtxCreate (hashcat_ctx, &device_param->cuda_context, CU_CTX_SCHED_BLOCKING_SYNC, device_param->cuda_device) == -1) return -1;
+      if (hc_cuCtxCreate (hashcat_ctx, &device_param->cuda_context, CU_CTX_SCHED_BLOCKING_SYNC, device_param->cuda_device) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
     }
 
     if (device_param->is_opencl == true)
@@ -7910,7 +8190,11 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       CL_rc = hc_clCreateContext (hashcat_ctx, properties, 1, &device_param->opencl_device, NULL, NULL, &device_param->opencl_context);
       */
 
-      if (hc_clCreateContext (hashcat_ctx, NULL, 1, &device_param->opencl_device, NULL, NULL, &device_param->opencl_context) == -1) return -1;
+      if (hc_clCreateContext (hashcat_ctx, NULL, 1, &device_param->opencl_device, NULL, NULL, &device_param->opencl_context) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
       /**
        * create command-queue
@@ -7919,7 +8203,11 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       // not supported with NV
       // device_param->opencl_command_queue = hc_clCreateCommandQueueWithProperties (hashcat_ctx, device_param->opencl_device, NULL);
 
-      if (hc_clCreateCommandQueue (hashcat_ctx, device_param->opencl_context, device_param->opencl_device, CL_QUEUE_PROFILING_ENABLE, &device_param->opencl_command_queue) == -1) return -1;
+      if (hc_clCreateCommandQueue (hashcat_ctx, device_param->opencl_context, device_param->opencl_device, CL_QUEUE_PROFILING_ENABLE, &device_param->opencl_command_queue) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
     }
 
     /**
@@ -7928,7 +8216,11 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
     if (device_param->is_cuda == true)
     {
-      if (hc_cuStreamCreate (hashcat_ctx, &device_param->cuda_stream, CU_STREAM_DEFAULT) == -1) return -1;
+      if (hc_cuStreamCreate (hashcat_ctx, &device_param->cuda_stream, CU_STREAM_DEFAULT) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
     }
 
     /**
@@ -7937,9 +8229,17 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
 
     if (device_param->is_cuda == true)
     {
-      if (hc_cuEventCreate (hashcat_ctx, &device_param->cuda_event1, CU_EVENT_BLOCKING_SYNC) == -1) return -1;
+      if (hc_cuEventCreate (hashcat_ctx, &device_param->cuda_event1, CU_EVENT_BLOCKING_SYNC) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
 
-      if (hc_cuEventCreate (hashcat_ctx, &device_param->cuda_event2, CU_EVENT_BLOCKING_SYNC) == -1) return -1;
+      if (hc_cuEventCreate (hashcat_ctx, &device_param->cuda_event2, CU_EVENT_BLOCKING_SYNC) == -1)
+      {
+        device_param->skipped = true;
+        continue;
+      }
     }
 
     /**
@@ -8000,7 +8300,8 @@ int backend_session_begin (hashcat_ctx_t *hashcat_ctx)
       {
         event_log_error (hashcat_ctx, "Invalid extra buffer size.");
 
-        return -1;
+        device_param->skipped = true;
+        continue;
       }
 
       device_param->extra_buffer_size = extra_buffer_size;
diff --git a/src/filehandling.c b/src/filehandling.c
index b9fe2c6cc..43256943e 100644
--- a/src/filehandling.c
+++ b/src/filehandling.c
@@ -74,7 +74,7 @@ bool hc_fopen (HCFILE *fp, const char *path, char *mode)
 
     if (read (fd_tmp, check, sizeof (check)) > 0)
     {
-      if (check[0] == 0x1f && check[1] == 0x8b && check[2] == 0x08 && check[3] == 0x08) fp->is_gzip = true;
+      if (check[0] == 0x1f && check[1] == 0x8b && check[2] == 0x08) fp->is_gzip = true;
       if (check[0] == 0x50 && check[1] == 0x4b && check[2] == 0x03 && check[3] == 0x04) fp->is_zip = true;
     }
 
diff --git a/src/hashes.c b/src/hashes.c
index 653df4e39..e3935aae4 100644
--- a/src/hashes.c
+++ b/src/hashes.c
@@ -633,18 +633,33 @@ int hashes_init_filename (hashcat_ctx_t *hashcat_ctx)
 
   if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
   {
-    hashes->hashlist_mode = HL_MODE_FILE_BINARY;
-
-    if ((user_options->benchmark == false) && (user_options->keyspace == false))
+    if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE_OPTIONAL)
     {
-      if (hc_path_read (user_options_extra->hc_hash) == false)
+      if ((user_options->benchmark == false) && (user_options->keyspace == false))
       {
-        event_log_error (hashcat_ctx, "%s: %s", user_options_extra->hc_hash, strerror (errno));
+        hashes->hashlist_mode = (hc_path_exist (user_options_extra->hc_hash) == true) ? HL_MODE_FILE_PLAIN : HL_MODE_ARG;
 
-        return -1;
+        if (hashes->hashlist_mode == HL_MODE_FILE_PLAIN)
+        {
+          hashes->hashfile = user_options_extra->hc_hash;
+        }
       }
+    }
+    else
+    {
+      hashes->hashlist_mode = HL_MODE_FILE_BINARY;
 
-      hashes->hashfile = user_options_extra->hc_hash;
+      if ((user_options->benchmark == false) && (user_options->keyspace == false))
+      {
+        if (hc_path_read (user_options_extra->hc_hash) == false)
+        {
+          event_log_error (hashcat_ctx, "%s: %s", user_options_extra->hc_hash, strerror (errno));
+
+          return -1;
+        }
+
+        hashes->hashfile = user_options_extra->hc_hash;
+      }
     }
   }
   else
@@ -1172,7 +1187,17 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
 
               compress_terminal_line_length (tmp_line_buf, 38, 32);
 
-              event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
+              if (user_options->machine_readable == true) {
+                event_log_warning(hashcat_ctx, "%s:%u:%s:%s", hashes->hashfile,
+                                  line_num, tmp_line_buf,
+                                  strparser(parser_status));
+
+              } else {
+                event_log_warning(hashcat_ctx,
+                                  "Hashfile '%s' on line %u (%s): %s",
+                                  hashes->hashfile, line_num, tmp_line_buf,
+                                  strparser(parser_status));
+              }
 
               hcfree (tmp_line_buf);
 
@@ -1196,7 +1221,17 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
 
               compress_terminal_line_length (tmp_line_buf, 38, 32);
 
-              event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
+              if (user_options->machine_readable == true) {
+                event_log_warning(hashcat_ctx, "%s:%u:%s:%s", hashes->hashfile,
+                                  line_num, tmp_line_buf,
+                                  strparser(parser_status));
+
+              } else {
+                event_log_warning(hashcat_ctx,
+                                  "Hashfile '%s' on line %u (%s): %s",
+                                  hashes->hashfile, line_num, tmp_line_buf,
+                                  strparser(parser_status));
+              }
 
               hcfree (tmp_line_buf);
 
@@ -1222,7 +1257,17 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
 
               compress_terminal_line_length (tmp_line_buf, 38, 32);
 
-              event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
+              if (user_options->machine_readable == true) {
+                event_log_warning(hashcat_ctx, "%s:%u:%s:%s", hashes->hashfile,
+                                  line_num, tmp_line_buf,
+                                  strparser(parser_status));
+
+              } else {
+                event_log_warning(hashcat_ctx,
+                                  "Hashfile '%s' on line %u (%s): %s",
+                                  hashes->hashfile, line_num, tmp_line_buf,
+                                  strparser(parser_status));
+              }
 
               hcfree (tmp_line_buf);
 
@@ -1249,7 +1294,17 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
 
             compress_terminal_line_length (tmp_line_buf, 38, 32);
 
-            event_log_warning (hashcat_ctx, "Hashfile '%s' on line %u (%s): %s", hashes->hashfile, line_num, tmp_line_buf, strparser (parser_status));
+            if (user_options->machine_readable == true) {
+              event_log_warning(hashcat_ctx, "%s:%u:%s:%s", hashes->hashfile,
+                                line_num, tmp_line_buf,
+                                strparser(parser_status));
+
+            } else {
+              event_log_warning(hashcat_ctx,
+                                "Hashfile '%s' on line %u (%s): %s",
+                                hashes->hashfile, line_num, tmp_line_buf,
+                                strparser(parser_status));
+            }
 
             hcfree (tmp_line_buf);
 
@@ -1858,30 +1913,37 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
   {
     if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
     {
-      char *tmpfile_bin;
+      if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE_OPTIONAL)
+      {
+        parser_status = module_ctx->module_hash_decode (hashconfig, hash.digest, hash.salt, hash.esalt, hash.hook_salt, hash.hash_info, hashconfig->st_hash, strlen (hashconfig->st_hash));
+      }
+      else
+      {
+        char *tmpfile_bin;
 
-      hc_asprintf (&tmpfile_bin, "%s/selftest.hash", folder_config->session_dir);
+        hc_asprintf (&tmpfile_bin, "%s/selftest.hash", folder_config->session_dir);
 
-      HCFILE fp;
+        HCFILE fp;
 
-      hc_fopen (&fp, tmpfile_bin, "wb");
+        hc_fopen (&fp, tmpfile_bin, "wb");
 
-      const size_t st_hash_len = strlen (hashconfig->st_hash);
+        const size_t st_hash_len = strlen (hashconfig->st_hash);
 
-      for (size_t i = 0; i < st_hash_len; i += 2)
-      {
-        const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + i);
+        for (size_t i = 0; i < st_hash_len; i += 2)
+        {
+          const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + i);
 
-        hc_fputc (c, &fp);
-      }
+          hc_fputc (c, &fp);
+        }
 
-      hc_fclose (&fp);
+        hc_fclose (&fp);
 
-      parser_status = module_ctx->module_hash_decode (hashconfig, hash.digest, hash.salt, hash.esalt, hash.hook_salt, hash.hash_info, tmpfile_bin, strlen (tmpfile_bin));
+        parser_status = module_ctx->module_hash_decode (hashconfig, hash.digest, hash.salt, hash.esalt, hash.hook_salt, hash.hash_info, tmpfile_bin, strlen (tmpfile_bin));
 
-      unlink (tmpfile_bin);
+        unlink (tmpfile_bin);
 
-      hcfree (tmpfile_bin);
+        hcfree (tmpfile_bin);
+      }
     }
     else
     {
diff --git a/src/interface.c b/src/interface.c
index 7128dbd61..c49f30610 100644
--- a/src/interface.c
+++ b/src/interface.c
@@ -342,7 +342,7 @@ int hashconfig_init (hashcat_ctx_t *hashcat_ctx)
           if (user_options->quiet == false)
           {
             event_log_warning (hashcat_ctx, "Kernel %s:", source_file);
-            event_log_warning (hashcat_ctx, "Optimized kernel requested but not needed - falling back to pure kernel");
+            event_log_warning (hashcat_ctx, "Optimized kernel requested but not available or not required - falling back to pure kernel");
             event_log_warning (hashcat_ctx, NULL);
           }
         }
diff --git a/src/modules/module_22000.c b/src/modules/module_22000.c
index 0a6114e8e..996f6eda5 100644
--- a/src/modules/module_22000.c
+++ b/src/modules/module_22000.c
@@ -35,6 +35,7 @@ static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
                                   | OPTS_TYPE_AUX3
                                   | OPTS_TYPE_AUX4
                                   | OPTS_TYPE_BINARY_HASHFILE
+                                  | OPTS_TYPE_BINARY_HASHFILE_OPTIONAL
                                   | OPTS_TYPE_DEEP_COMP_KERNEL
                                   | OPTS_TYPE_COPY_TMPS;
 static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
diff --git a/src/modules/module_22001.c b/src/modules/module_22001.c
index 0eded3201..5b8737c3d 100644
--- a/src/modules/module_22001.c
+++ b/src/modules/module_22001.c
@@ -35,6 +35,7 @@ static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
                                   | OPTS_TYPE_AUX3
                                   | OPTS_TYPE_AUX4
                                   | OPTS_TYPE_BINARY_HASHFILE
+                                  | OPTS_TYPE_BINARY_HASHFILE_OPTIONAL
                                   | OPTS_TYPE_DEEP_COMP_KERNEL
                                   | OPTS_TYPE_COPY_TMPS
                                   | OPTS_TYPE_POTFILE_NOPASS;
diff --git a/src/modules/module_24100.c b/src/modules/module_24100.c
new file mode 100644
index 000000000..cd9b4d9c9
--- /dev/null
+++ b/src/modules/module_24100.c
@@ -0,0 +1,350 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#include "common.h"
+#include "types.h"
+#include "modules.h"
+#include "bitops.h"
+#include "convert.h"
+#include "shared.h"
+
+static const u32   ATTACK_EXEC    = ATTACK_EXEC_OUTSIDE_KERNEL;
+static const u32   DGST_POS0      = 0;
+static const u32   DGST_POS1      = 1;
+static const u32   DGST_POS2      = 2;
+static const u32   DGST_POS3      = 3;
+static const u32   DGST_SIZE      = DGST_SIZE_4_5;
+static const u32   HASH_CATEGORY  = HASH_CATEGORY_DATABASE_SERVER;
+static const char *HASH_NAME      = "MongoDB ServerKey SCRAM-SHA-1";
+static const u64   KERN_TYPE      = 24100;
+static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
+                                  | OPTI_TYPE_SLOW_HASH_SIMD_LOOP;
+static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
+                                  | OPTS_TYPE_ST_BASE64;
+static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const char *ST_PASS        = "hashcat";
+static const char *ST_HASH        = "$mongodb-scram$*0*dXNlcg==*10000*4p+f1tKpK18hQqrVr0UGOw==*Jv9lrpUQ2bVg2ZkXvRm2rppsqNw=";
+
+u32         module_attack_exec    (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC;     }
+u32         module_dgst_pos0      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0;       }
+u32         module_dgst_pos1      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1;       }
+u32         module_dgst_pos2      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2;       }
+u32         module_dgst_pos3      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3;       }
+u32         module_dgst_size      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE;       }
+u32         module_hash_category  (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY;   }
+const char *module_hash_name      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME;       }
+u64         module_kern_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE;       }
+u32         module_opti_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE;       }
+u64         module_opts_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE;       }
+u32         module_salt_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE;       }
+const char *module_st_hash        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH;         }
+const char *module_st_pass        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS;         }
+
+typedef struct mongodb_sha1_tmp
+{
+  u32  ipad[5];
+  u32  opad[5];
+
+  u32  dgst[5];
+  u32  out[5];
+
+} mongodb_sha1_tmp_t;
+
+typedef struct mongodb_sha1
+{
+  u32 salt[16];
+  u32 user[16];
+
+  u32 user_len;
+
+} mongodb_sha1_t;
+
+static const char *SIGNATURE_MONGODB_SHA1 = "$mongodb-scram$";
+
+u64 module_esalt_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 esalt_size = (const u64) sizeof (mongodb_sha1_t);
+
+  return esalt_size;
+}
+
+u64 module_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 tmp_size = (const u64) sizeof (mongodb_sha1_tmp_t);
+
+  return tmp_size;
+}
+
+u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  // this overrides the reductions of PW_MAX in case optimized kernel is selected
+  // IOW, even in optimized kernel mode it support length 256
+
+  const u32 pw_max = PW_MAX;
+
+  return pw_max;
+}
+
+int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  mongodb_sha1_t *mongodb_sha1 = (mongodb_sha1_t *) esalt_buf;
+
+  token_t token;
+
+  token.token_cnt  = 6;
+
+  token.signatures_cnt    = 1;
+  token.signatures_buf[0] = SIGNATURE_MONGODB_SHA1;
+
+  token.sep[0]     = '*';
+  token.len_min[0] = 15;
+  token.len_max[0] = 15;
+  token.attr[0]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_SIGNATURE;
+
+  token.sep[1]     = '*';
+  token.len_min[1] = 1;
+  token.len_max[1] = 1;
+  token.attr[1]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.sep[2]     = '*';
+  token.len_min[2] = 0;
+  token.len_max[2] = 76; // BASE64 encoded user (57 / 3 * 4)
+  token.attr[2]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  token.sep[3]     = '*';
+  token.len_min[3] = 1;
+  token.len_max[3] = 7;
+  token.attr[3]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.sep[4]     = '*';
+  token.len_min[4] = 24;
+  token.len_max[4] = 24;
+  token.attr[4]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  token.len[5]     = 28;
+  token.attr[5]    = TOKEN_ATTR_FIXED_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
+
+  if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
+
+  // version
+
+  const u8 *version_pos = token.buf[1];
+
+  if (version_pos[0] != '0') return (PARSER_SIGNATURE_UNMATCHED);
+
+  // user
+
+  const u8 *user_pos = token.buf[2];
+  const u32 user_len = token.len[2];
+
+  u8 tmp_buf[100] = { 0 };
+
+  int tmp_len = base64_decode (base64_to_int, user_pos, user_len, tmp_buf);
+
+  if (tmp_len > 57) return (PARSER_SALT_LENGTH);
+
+  memcpy ((char *) mongodb_sha1->user, tmp_buf, tmp_len);
+
+  memcpy ((char *) mongodb_sha1->user + tmp_len, ":mongo:", 7);
+
+  mongodb_sha1->user_len = tmp_len + 7;
+
+  // iter
+
+  const u8 *iter_pos = token.buf[3];
+
+  const u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
+
+  if (iter < 1) return (PARSER_SALT_ITERATION);
+
+  salt->salt_iter = iter - 1;
+
+  // salt
+
+  const u8 *salt_pos = token.buf[4];
+  const int salt_len = token.len[4];
+
+  memset (tmp_buf, 0, sizeof (tmp_buf));
+
+  tmp_len = base64_decode (base64_to_int, salt_pos, salt_len, tmp_buf);
+
+  if (tmp_len != 16) return (PARSER_SALT_LENGTH);
+
+  memcpy (mongodb_sha1->salt, tmp_buf, tmp_len);
+
+  mongodb_sha1->salt[0] = byte_swap_32 (mongodb_sha1->salt[0]);
+  mongodb_sha1->salt[1] = byte_swap_32 (mongodb_sha1->salt[1]);
+  mongodb_sha1->salt[2] = byte_swap_32 (mongodb_sha1->salt[2]);
+  mongodb_sha1->salt[3] = byte_swap_32 (mongodb_sha1->salt[3]);
+
+  salt->salt_len = tmp_len;
+
+  salt->salt_buf[0] = mongodb_sha1->salt[0];
+  salt->salt_buf[1] = mongodb_sha1->salt[1];
+  salt->salt_buf[2] = mongodb_sha1->salt[2];
+  salt->salt_buf[3] = mongodb_sha1->salt[3];
+
+  // hash
+
+  const u8 *hash_pos = token.buf[5];
+  const int hash_len = token.len[5];
+
+  memset (tmp_buf, 0, sizeof (tmp_buf));
+
+  tmp_len = base64_decode (base64_to_int, hash_pos, hash_len, tmp_buf);
+
+  if (tmp_len != 20) return (PARSER_HASH_LENGTH);
+
+  memcpy (digest, tmp_buf, 20);
+
+  digest[0] = byte_swap_32 (digest[0]);
+  digest[1] = byte_swap_32 (digest[1]);
+  digest[2] = byte_swap_32 (digest[2]);
+  digest[3] = byte_swap_32 (digest[3]);
+  digest[4] = byte_swap_32 (digest[4]);
+
+  return (PARSER_OK);
+}
+
+int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  mongodb_sha1_t *mongodb_sha1 = (mongodb_sha1_t *) esalt_buf;
+
+  // salt
+
+  u32 salt_buf[8] = { 0 }; // make the buffer large enough for base64_encode ()
+
+  salt_buf[0] = byte_swap_32 (mongodb_sha1->salt[0]);
+  salt_buf[1] = byte_swap_32 (mongodb_sha1->salt[1]);
+  salt_buf[2] = byte_swap_32 (mongodb_sha1->salt[2]);
+  salt_buf[3] = byte_swap_32 (mongodb_sha1->salt[3]);
+
+  u8 salt_base64[32] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) salt_buf, 16, salt_base64);
+
+  // digest
+
+  u32 hash[8] = { 0 }; // make the buffer large enough for base64_encode ()
+
+  hash[0] = byte_swap_32 (digest[0]);
+  hash[1] = byte_swap_32 (digest[1]);
+  hash[2] = byte_swap_32 (digest[2]);
+  hash[3] = byte_swap_32 (digest[3]);
+  hash[4] = byte_swap_32 (digest[4]);
+
+  u8 dgst_base64[32] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) hash, 20, dgst_base64);
+
+  // user
+
+  u32 user_len = mongodb_sha1->user_len - 7;
+
+  u8 user[100] = { 0 }; // actually: 64 - 7 (:mongo:)
+
+  memcpy (user, (char *) mongodb_sha1->user, user_len);
+
+  u8 user_base64[100] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) user, user_len, user_base64);
+
+  const int line_len = snprintf (line_buf, line_size, "%s*0*%s*%u*%s*%s",
+      SIGNATURE_MONGODB_SHA1,
+      user_base64,
+      salt->salt_iter + 1,
+      salt_base64,
+      dgst_base64);
+
+  return line_len;
+}
+
+void module_init (module_ctx_t *module_ctx)
+{
+  module_ctx->module_context_size             = MODULE_CONTEXT_SIZE_CURRENT;
+  module_ctx->module_interface_version        = MODULE_INTERFACE_VERSION_CURRENT;
+
+  module_ctx->module_attack_exec              = module_attack_exec;
+  module_ctx->module_benchmark_esalt          = MODULE_DEFAULT;
+  module_ctx->module_benchmark_hook_salt      = MODULE_DEFAULT;
+  module_ctx->module_benchmark_mask           = MODULE_DEFAULT;
+  module_ctx->module_benchmark_salt           = MODULE_DEFAULT;
+  module_ctx->module_build_plain_postprocess  = MODULE_DEFAULT;
+  module_ctx->module_deep_comp_kernel         = MODULE_DEFAULT;
+  module_ctx->module_dgst_pos0                = module_dgst_pos0;
+  module_ctx->module_dgst_pos1                = module_dgst_pos1;
+  module_ctx->module_dgst_pos2                = module_dgst_pos2;
+  module_ctx->module_dgst_pos3                = module_dgst_pos3;
+  module_ctx->module_dgst_size                = module_dgst_size;
+  module_ctx->module_dictstat_disable         = MODULE_DEFAULT;
+  module_ctx->module_esalt_size               = module_esalt_size;
+  module_ctx->module_extra_buffer_size        = MODULE_DEFAULT;
+  module_ctx->module_extra_tmp_size           = MODULE_DEFAULT;
+  module_ctx->module_forced_outfile_format    = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_count        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_parse        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_save         = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_zero_hash    = MODULE_DEFAULT;
+  module_ctx->module_hash_decode              = module_hash_decode;
+  module_ctx->module_hash_encode_status       = MODULE_DEFAULT;
+  module_ctx->module_hash_encode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_encode              = module_hash_encode;
+  module_ctx->module_hash_init_selftest       = MODULE_DEFAULT;
+  module_ctx->module_hash_mode                = MODULE_DEFAULT;
+  module_ctx->module_hash_category            = module_hash_category;
+  module_ctx->module_hash_name                = module_hash_name;
+  module_ctx->module_hashes_count_min         = MODULE_DEFAULT;
+  module_ctx->module_hashes_count_max         = MODULE_DEFAULT;
+  module_ctx->module_hlfmt_disable            = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_size    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_init    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_term    = MODULE_DEFAULT;
+  module_ctx->module_hook12                   = MODULE_DEFAULT;
+  module_ctx->module_hook23                   = MODULE_DEFAULT;
+  module_ctx->module_hook_salt_size           = MODULE_DEFAULT;
+  module_ctx->module_hook_size                = MODULE_DEFAULT;
+  module_ctx->module_jit_build_options        = MODULE_DEFAULT;
+  module_ctx->module_jit_cache_disable        = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_max       = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_min       = MODULE_DEFAULT;
+  module_ctx->module_kern_type                = module_kern_type;
+  module_ctx->module_kern_type_dynamic        = MODULE_DEFAULT;
+  module_ctx->module_opti_type                = module_opti_type;
+  module_ctx->module_opts_type                = module_opts_type;
+  module_ctx->module_outfile_check_disable    = MODULE_DEFAULT;
+  module_ctx->module_outfile_check_nocomp     = MODULE_DEFAULT;
+  module_ctx->module_potfile_custom_check     = MODULE_DEFAULT;
+  module_ctx->module_potfile_disable          = MODULE_DEFAULT;
+  module_ctx->module_potfile_keep_all_hashes  = MODULE_DEFAULT;
+  module_ctx->module_pwdump_column            = MODULE_DEFAULT;
+  module_ctx->module_pw_max                   = module_pw_max;
+  module_ctx->module_pw_min                   = MODULE_DEFAULT;
+  module_ctx->module_salt_max                 = MODULE_DEFAULT;
+  module_ctx->module_salt_min                 = MODULE_DEFAULT;
+  module_ctx->module_salt_type                = module_salt_type;
+  module_ctx->module_separator                = MODULE_DEFAULT;
+  module_ctx->module_st_hash                  = module_st_hash;
+  module_ctx->module_st_pass                  = module_st_pass;
+  module_ctx->module_tmp_size                 = module_tmp_size;
+  module_ctx->module_unstable_warning         = MODULE_DEFAULT;
+  module_ctx->module_warmup_disable           = MODULE_DEFAULT;
+}
diff --git a/src/modules/module_24200.c b/src/modules/module_24200.c
new file mode 100644
index 000000000..b1da70c9a
--- /dev/null
+++ b/src/modules/module_24200.c
@@ -0,0 +1,384 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#include "common.h"
+#include "types.h"
+#include "modules.h"
+#include "bitops.h"
+#include "convert.h"
+#include "shared.h"
+
+static const u32   ATTACK_EXEC    = ATTACK_EXEC_OUTSIDE_KERNEL;
+static const u32   DGST_POS0      = 0;
+static const u32   DGST_POS1      = 1;
+static const u32   DGST_POS2      = 2;
+static const u32   DGST_POS3      = 3;
+static const u32   DGST_SIZE      = DGST_SIZE_4_8;
+static const u32   HASH_CATEGORY  = HASH_CATEGORY_DATABASE_SERVER;
+static const char *HASH_NAME      = "MongoDB ServerKey SCRAM-SHA-256";
+static const u64   KERN_TYPE      = 24200;
+static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
+                                  | OPTI_TYPE_SLOW_HASH_SIMD_LOOP;
+static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
+                                  | OPTS_TYPE_ST_BASE64;
+static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const char *ST_PASS        = "hashcat";
+static const char *ST_HASH        = "$mongodb-scram$*1*dXNlcg==*15000*qYaA1K1ZZSSpWfY+yqShlcTn0XVcrNipxiYCLQ==*QWVry9aTS/JW+y5CWCBr8lcEH9Kr/D4je60ncooPer8=";
+
+u32         module_attack_exec    (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC;     }
+u32         module_dgst_pos0      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0;       }
+u32         module_dgst_pos1      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1;       }
+u32         module_dgst_pos2      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2;       }
+u32         module_dgst_pos3      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3;       }
+u32         module_dgst_size      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE;       }
+u32         module_hash_category  (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY;   }
+const char *module_hash_name      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME;       }
+u64         module_kern_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE;       }
+u32         module_opti_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE;       }
+u64         module_opts_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE;       }
+u32         module_salt_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE;       }
+const char *module_st_hash        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH;         }
+const char *module_st_pass        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS;         }
+
+typedef struct mongodb_sha256_tmp
+{
+  u32  ipad[8];
+  u32  opad[8];
+
+  u32  dgst[8];
+  u32  out[8];
+
+} mongodb_sha256_tmp_t;
+
+typedef struct mongodb_sha256
+{
+  u32 salt[16];
+  u32 user[16];
+
+  u32 user_len;
+
+} mongodb_sha256_t;
+
+static const char *SIGNATURE_MONGODB_SHA256 = "$mongodb-scram$";
+
+char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param)
+{
+  char *jit_build_options = NULL;
+
+  // Extra treatment for Apple systems
+  if (device_param->opencl_platform_vendor_id == VENDOR_ID_APPLE)
+  {
+    return jit_build_options;
+  }
+
+  // NVIDIA GPU
+  if (device_param->opencl_device_vendor_id == VENDOR_ID_NV)
+  {
+    hc_asprintf (&jit_build_options, "-D _unroll");
+  }
+
+  // ROCM
+  if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) && (device_param->has_vperm == true))
+  {
+    hc_asprintf (&jit_build_options, "-D _unroll");
+  }
+
+  return jit_build_options;
+}
+
+u64 module_esalt_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 esalt_size = (const u64) sizeof (mongodb_sha256_t);
+
+  return esalt_size;
+}
+
+u64 module_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 tmp_size = (const u64) sizeof (mongodb_sha256_tmp_t);
+
+  return tmp_size;
+}
+
+u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  // this overrides the reductions of PW_MAX in case optimized kernel is selected
+  // IOW, even in optimized kernel mode it support length 256
+
+  const u32 pw_max = PW_MAX;
+
+  return pw_max;
+}
+
+int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  mongodb_sha256_t *mongodb_sha256 = (mongodb_sha256_t *) esalt_buf;
+
+  token_t token;
+
+  token.token_cnt  = 6;
+
+  token.signatures_cnt    = 1;
+  token.signatures_buf[0] = SIGNATURE_MONGODB_SHA256;
+
+  token.sep[0]     = '*';
+  token.len_min[0] = 15;
+  token.len_max[0] = 15;
+  token.attr[0]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_SIGNATURE;
+
+  token.sep[1]     = '*';
+  token.len_min[1] = 1;
+  token.len_max[1] = 1;
+  token.attr[1]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.sep[2]     = '*';
+  token.len_min[2] = 0;
+  token.len_max[2] = 88; // BASE64 encoded user (64 / 3 * 4)
+  token.attr[2]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  token.sep[3]     = '*';
+  token.len_min[3] = 1;
+  token.len_max[3] = 7;
+  token.attr[3]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.sep[4]     = '*';
+  token.len_min[4] = 40;
+  token.len_max[4] = 40;
+  token.attr[4]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  token.len[5]     = 44;
+  token.attr[5]    = TOKEN_ATTR_FIXED_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
+
+  if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
+
+  // version
+
+  const u8 *version_pos = token.buf[1];
+
+  if (version_pos[0] != '1') return (PARSER_SIGNATURE_UNMATCHED);
+
+  // user
+
+  const u8 *user_pos = token.buf[2];
+  const u32 user_len = token.len[2];
+
+  u8 tmp_buf[100] = { 0 };
+
+  int tmp_len = base64_decode (base64_to_int, user_pos, user_len, tmp_buf);
+
+  if (tmp_len > 64) return (PARSER_SALT_LENGTH);
+
+  memcpy ((char *) mongodb_sha256->user, tmp_buf, tmp_len);
+
+  mongodb_sha256->user_len = tmp_len;
+
+  // iter
+
+  const u8 *iter_pos = token.buf[3];
+
+  const u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
+
+  if (iter < 1) return (PARSER_SALT_ITERATION);
+
+  salt->salt_iter = iter - 1;
+
+  // salt
+
+  const u8 *salt_pos = token.buf[4];
+  const int salt_len = token.len[4];
+
+  tmp_len = base64_decode (base64_to_int, salt_pos, salt_len, tmp_buf);
+
+  if (tmp_len != 28) return (PARSER_SALT_LENGTH);
+
+  memcpy (mongodb_sha256->salt, tmp_buf, tmp_len);
+
+  mongodb_sha256->salt[0] = byte_swap_32 (mongodb_sha256->salt[0]);
+  mongodb_sha256->salt[1] = byte_swap_32 (mongodb_sha256->salt[1]);
+  mongodb_sha256->salt[2] = byte_swap_32 (mongodb_sha256->salt[2]);
+  mongodb_sha256->salt[3] = byte_swap_32 (mongodb_sha256->salt[3]);
+  mongodb_sha256->salt[4] = byte_swap_32 (mongodb_sha256->salt[4]);
+  mongodb_sha256->salt[5] = byte_swap_32 (mongodb_sha256->salt[5]);
+  mongodb_sha256->salt[6] = byte_swap_32 (mongodb_sha256->salt[6]);
+
+  salt->salt_len = tmp_len;
+
+  salt->salt_buf[0] = mongodb_sha256->salt[0];
+  salt->salt_buf[1] = mongodb_sha256->salt[1];
+  salt->salt_buf[2] = mongodb_sha256->salt[2];
+  salt->salt_buf[3] = mongodb_sha256->salt[3];
+  salt->salt_buf[4] = mongodb_sha256->salt[4];
+  salt->salt_buf[5] = mongodb_sha256->salt[5];
+  salt->salt_buf[6] = mongodb_sha256->salt[6];
+
+  // hash
+
+  const u8 *hash_pos = token.buf[5];
+  const int hash_len = token.len[5];
+
+  memset (tmp_buf, 0, sizeof (tmp_buf));
+
+  tmp_len = base64_decode (base64_to_int, hash_pos, hash_len, tmp_buf);
+
+  if (tmp_len != 32) return (PARSER_HASH_LENGTH);
+
+  memcpy (digest, tmp_buf, 32);
+
+  digest[0] = byte_swap_32 (digest[0]);
+  digest[1] = byte_swap_32 (digest[1]);
+  digest[2] = byte_swap_32 (digest[2]);
+  digest[3] = byte_swap_32 (digest[3]);
+  digest[4] = byte_swap_32 (digest[4]);
+  digest[5] = byte_swap_32 (digest[5]);
+  digest[6] = byte_swap_32 (digest[6]);
+  digest[7] = byte_swap_32 (digest[7]);
+
+  return (PARSER_OK);
+}
+
+int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  mongodb_sha256_t *mongodb_sha256 = (mongodb_sha256_t *) esalt_buf;
+
+  // salt
+
+  u32 salt_buf[8] = { 0 }; // make the buffer large enough for base64_encode ()
+
+  salt_buf[0] = byte_swap_32 (mongodb_sha256->salt[0]);
+  salt_buf[1] = byte_swap_32 (mongodb_sha256->salt[1]);
+  salt_buf[2] = byte_swap_32 (mongodb_sha256->salt[2]);
+  salt_buf[3] = byte_swap_32 (mongodb_sha256->salt[3]);
+  salt_buf[4] = byte_swap_32 (mongodb_sha256->salt[4]);
+  salt_buf[5] = byte_swap_32 (mongodb_sha256->salt[5]);
+  salt_buf[6] = byte_swap_32 (mongodb_sha256->salt[6]);
+
+  u8 salt_base64[64] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) salt_buf, 28, salt_base64);
+
+  // digest
+
+  u32 hash[8] = { 0 }; // make the buffer large enough for base64_encode ()
+
+  hash[0] = byte_swap_32 (digest[0]);
+  hash[1] = byte_swap_32 (digest[1]);
+  hash[2] = byte_swap_32 (digest[2]);
+  hash[3] = byte_swap_32 (digest[3]);
+  hash[4] = byte_swap_32 (digest[4]);
+  hash[5] = byte_swap_32 (digest[5]);
+  hash[6] = byte_swap_32 (digest[6]);
+  hash[7] = byte_swap_32 (digest[7]);
+
+  u8 dgst_base64[64] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) hash, 32, dgst_base64);
+
+  // user
+
+  u8 user[100] = { 0 };
+
+  memcpy (user, (char *) mongodb_sha256->user, 64);
+
+  u8 user_base64[100] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) user, mongodb_sha256->user_len, user_base64);
+
+  const int line_len = snprintf (line_buf, line_size, "%s*1*%s*%u*%s*%s",
+      SIGNATURE_MONGODB_SHA256,
+      user_base64,
+      salt->salt_iter + 1,
+      salt_base64,
+      dgst_base64);
+
+  return line_len;
+}
+
+void module_init (module_ctx_t *module_ctx)
+{
+  module_ctx->module_context_size             = MODULE_CONTEXT_SIZE_CURRENT;
+  module_ctx->module_interface_version        = MODULE_INTERFACE_VERSION_CURRENT;
+
+  module_ctx->module_attack_exec              = module_attack_exec;
+  module_ctx->module_benchmark_esalt          = MODULE_DEFAULT;
+  module_ctx->module_benchmark_hook_salt      = MODULE_DEFAULT;
+  module_ctx->module_benchmark_mask           = MODULE_DEFAULT;
+  module_ctx->module_benchmark_salt           = MODULE_DEFAULT;
+  module_ctx->module_build_plain_postprocess  = MODULE_DEFAULT;
+  module_ctx->module_deep_comp_kernel         = MODULE_DEFAULT;
+  module_ctx->module_dgst_pos0                = module_dgst_pos0;
+  module_ctx->module_dgst_pos1                = module_dgst_pos1;
+  module_ctx->module_dgst_pos2                = module_dgst_pos2;
+  module_ctx->module_dgst_pos3                = module_dgst_pos3;
+  module_ctx->module_dgst_size                = module_dgst_size;
+  module_ctx->module_dictstat_disable         = MODULE_DEFAULT;
+  module_ctx->module_esalt_size               = module_esalt_size;
+  module_ctx->module_extra_buffer_size        = MODULE_DEFAULT;
+  module_ctx->module_extra_tmp_size           = MODULE_DEFAULT;
+  module_ctx->module_forced_outfile_format    = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_count        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_parse        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_save         = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_zero_hash    = MODULE_DEFAULT;
+  module_ctx->module_hash_decode              = module_hash_decode;
+  module_ctx->module_hash_encode_status       = MODULE_DEFAULT;
+  module_ctx->module_hash_encode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_encode              = module_hash_encode;
+  module_ctx->module_hash_init_selftest       = MODULE_DEFAULT;
+  module_ctx->module_hash_mode                = MODULE_DEFAULT;
+  module_ctx->module_hash_category            = module_hash_category;
+  module_ctx->module_hash_name                = module_hash_name;
+  module_ctx->module_hashes_count_min         = MODULE_DEFAULT;
+  module_ctx->module_hashes_count_max         = MODULE_DEFAULT;
+  module_ctx->module_hlfmt_disable            = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_size    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_init    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_term    = MODULE_DEFAULT;
+  module_ctx->module_hook12                   = MODULE_DEFAULT;
+  module_ctx->module_hook23                   = MODULE_DEFAULT;
+  module_ctx->module_hook_salt_size           = MODULE_DEFAULT;
+  module_ctx->module_hook_size                = MODULE_DEFAULT;
+  module_ctx->module_jit_build_options        = module_jit_build_options;
+  module_ctx->module_jit_cache_disable        = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_max       = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_min       = MODULE_DEFAULT;
+  module_ctx->module_kern_type                = module_kern_type;
+  module_ctx->module_kern_type_dynamic        = MODULE_DEFAULT;
+  module_ctx->module_opti_type                = module_opti_type;
+  module_ctx->module_opts_type                = module_opts_type;
+  module_ctx->module_outfile_check_disable    = MODULE_DEFAULT;
+  module_ctx->module_outfile_check_nocomp     = MODULE_DEFAULT;
+  module_ctx->module_potfile_custom_check     = MODULE_DEFAULT;
+  module_ctx->module_potfile_disable          = MODULE_DEFAULT;
+  module_ctx->module_potfile_keep_all_hashes  = MODULE_DEFAULT;
+  module_ctx->module_pwdump_column            = MODULE_DEFAULT;
+  module_ctx->module_pw_max                   = module_pw_max;
+  module_ctx->module_pw_min                   = MODULE_DEFAULT;
+  module_ctx->module_salt_max                 = MODULE_DEFAULT;
+  module_ctx->module_salt_min                 = MODULE_DEFAULT;
+  module_ctx->module_salt_type                = module_salt_type;
+  module_ctx->module_separator                = MODULE_DEFAULT;
+  module_ctx->module_st_hash                  = module_st_hash;
+  module_ctx->module_st_pass                  = module_st_pass;
+  module_ctx->module_tmp_size                 = module_tmp_size;
+  module_ctx->module_unstable_warning         = MODULE_DEFAULT;
+  module_ctx->module_warmup_disable           = MODULE_DEFAULT;
+}
diff --git a/src/modules/module_25400.c b/src/modules/module_25400.c
new file mode 100644
index 000000000..f5af76dde
--- /dev/null
+++ b/src/modules/module_25400.c
@@ -0,0 +1,534 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+// TODO use user password as input for md5 of o_digest if no owner password is set
+// TODO dynamically add user password including padding to the RC4 input for the computation of the pdf o-value
+
+#include "common.h"
+#include "types.h"
+#include "modules.h"
+#include "bitops.h"
+#include "convert.h"
+#include "shared.h"
+#include "emu_inc_hash_md5.h"
+
+static const u32   ATTACK_EXEC    = ATTACK_EXEC_OUTSIDE_KERNEL;
+static const u32   DGST_POS0      = 0;
+static const u32   DGST_POS1      = 1;
+static const u32   DGST_POS2      = 2;
+static const u32   DGST_POS3      = 3;
+static const u32   DGST_SIZE      = DGST_SIZE_4_4;
+static const u32   HASH_CATEGORY  = HASH_CATEGORY_DOCUMENTS;
+static const char *HASH_NAME      = "PDF 1.4 - 1.6 (Acrobat 5 - 8) - edit password";
+static const u64   KERN_TYPE      = 25400;
+static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
+                                  | OPTI_TYPE_NOT_ITERATED;
+static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE;
+static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const char *ST_PASS        = "hashcat";
+static const char *ST_HASH        = "$pdf$2*3*128*-3904*1*16*631ed33746e50fba5caf56bcc39e09c6*32*5f9d0e4f0b39835dace0d306c40cd6b700000000000000000000000000000000*32*842103b0a0dc886db9223b94afe2d7cd63389079b61986a4fcf70095ad630c24";
+
+u32         module_attack_exec    (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC;     }
+u32         module_dgst_pos0      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0;       }
+u32         module_dgst_pos1      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1;       }
+u32         module_dgst_pos2      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2;       }
+u32         module_dgst_pos3      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3;       }
+u32         module_dgst_size      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE;       }
+u32         module_hash_category  (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY;   }
+const char *module_hash_name      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME;       }
+u64         module_kern_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE;       }
+u32         module_opti_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE;       }
+u64         module_opts_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE;       }
+u32         module_salt_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE;       }
+const char *module_st_hash        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH;         }
+const char *module_st_pass        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS;         }
+
+typedef struct pdf
+{
+  int  V;
+  int  R;
+  int  P;
+
+  int  enc_md;
+
+  u32  id_buf[8];
+  u32  u_buf[32];
+  u32  o_buf[32];
+
+  int  id_len;
+  int  o_len;
+  int  u_len;
+
+  u32  rc4key[2];
+  u32  rc4data[2];
+
+} pdf_t;
+
+typedef struct pdf14_tmp
+{
+  u32 digest[4];
+  u32 out[4];
+
+} pdf14_tmp_t;
+
+static const char *SIGNATURE_PDF = "$pdf$";
+
+static void md5_complete_no_limit (u32 digest[4], const u32 *plain, const u32 plain_len)
+{
+  // plain = u32 tmp_md5_buf[64] so this is compatible
+
+  md5_ctx_t md5_ctx;
+
+  md5_init (&md5_ctx);
+  md5_update (&md5_ctx, plain, plain_len);
+  md5_final (&md5_ctx);
+
+  digest[0] = md5_ctx.h[0];
+  digest[1] = md5_ctx.h[1];
+  digest[2] = md5_ctx.h[2];
+  digest[3] = md5_ctx.h[3];
+}
+
+char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param)
+{
+  char *jit_build_options = NULL;
+
+  // Extra treatment for Apple systems
+  if (device_param->opencl_platform_vendor_id == VENDOR_ID_APPLE)
+  {
+    return jit_build_options;
+  }
+
+  // Intel CPU
+  if ((device_param->opencl_device_vendor_id == VENDOR_ID_INTEL_SDK) && (device_param->opencl_device_type & CL_DEVICE_TYPE_CPU))
+  {
+    hc_asprintf (&jit_build_options, "-D _unroll");
+  }
+
+  // ROCM
+  if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) && (device_param->has_vperm == true))
+  {
+    hc_asprintf (&jit_build_options, "-D _unroll");
+  }
+
+  return jit_build_options;
+}
+
+u64 module_esalt_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 esalt_size = (const u64) sizeof (pdf_t);
+
+  return esalt_size;
+}
+
+u64 module_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 tmp_size = (const u64) sizeof (pdf14_tmp_t);
+
+  return tmp_size;
+}
+
+u32 module_kernel_threads_min (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u32 kernel_threads_min = 64; // RC4
+
+  return kernel_threads_min;
+}
+
+u32 module_kernel_threads_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u32 kernel_threads_max = 64; // RC4
+
+  return kernel_threads_max;
+}
+
+u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u32 pw_max = 32; // https://www.pdflib.com/knowledge-base/pdf-password-security/encryption/
+
+  return pw_max;
+}
+
+int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  pdf_t *pdf = (pdf_t *) esalt_buf;
+
+  token_t token;
+
+  token.token_cnt  = 12;
+
+  token.signatures_cnt    = 1;
+  token.signatures_buf[0] = SIGNATURE_PDF;
+
+  token.len[0]     = 5;
+  token.attr[0]    = TOKEN_ATTR_FIXED_LENGTH
+                   | TOKEN_ATTR_VERIFY_SIGNATURE;
+
+  token.len_min[1] = 1;
+  token.len_max[1] = 1;
+  token.sep[1]     = '*';
+  token.attr[1]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[2] = 1;
+  token.len_max[2] = 1;
+  token.sep[2]     = '*';
+  token.attr[2]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[3] = 3;
+  token.len_max[3] = 3;
+  token.sep[3]     = '*';
+  token.attr[3]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[4] = 1;
+  token.len_max[4] = 6;
+  token.sep[4]     = '*';
+  token.attr[4]    = TOKEN_ATTR_VERIFY_LENGTH;
+
+  token.len_min[5] = 1;
+  token.len_max[5] = 1;
+  token.sep[5]     = '*';
+  token.attr[5]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[6] = 2;
+  token.len_max[6] = 2;
+  token.sep[6]     = '*';
+  token.attr[6]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[7] = 32;
+  token.len_max[7] = 64;
+  token.sep[7]     = '*';
+  token.attr[7]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_HEX;
+
+  token.len_min[8] = 2;
+  token.len_max[8] = 2;
+  token.sep[8]     = '*';
+  token.attr[8]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[9] = 64;
+  token.len_max[9] = 64;
+  token.sep[9]     = '*';
+  token.attr[9]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_HEX;
+
+  token.len_min[10] = 2;
+  token.len_max[10] = 2;
+  token.sep[10]     = '*';
+  token.attr[10]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_DIGIT;
+
+  token.len_min[11] = 64;
+  token.len_max[11] = 64;
+  token.sep[11]     = '*';
+  token.attr[11]    = TOKEN_ATTR_VERIFY_LENGTH
+                    | TOKEN_ATTR_VERIFY_HEX;
+
+  const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
+
+  if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
+
+  const u8 *V_pos      = token.buf[1];
+  const u8 *R_pos      = token.buf[2];
+  const u8 *bits_pos   = token.buf[3];
+  const u8 *P_pos      = token.buf[4];
+  const u8 *enc_md_pos = token.buf[5];
+  const u8 *id_len_pos = token.buf[6];
+  const u8 *id_buf_pos = token.buf[7];
+  const u8 *u_len_pos  = token.buf[8];
+  const u8 *u_buf_pos  = token.buf[9];  // user hash
+  const u8 *o_len_pos  = token.buf[10];
+  const u8 *o_buf_pos  = token.buf[11]; // owner hash
+
+  // validate data
+
+  const int V = strtol ((const char *) V_pos, NULL, 10);
+  const int R = strtol ((const char *) R_pos, NULL, 10);
+  const int P = strtol ((const char *) P_pos, NULL, 10);
+
+  int vr_ok = 0;
+
+  if ((V == 2) && (R == 3)) vr_ok = 1;
+  if ((V == 4) && (R == 4)) vr_ok = 1;
+
+  if (vr_ok == 0) return (PARSER_SALT_VALUE);
+
+  const int id_len = strtol ((const char *) id_len_pos, NULL, 10);
+  const int u_len  = strtol ((const char *) u_len_pos,  NULL, 10);
+  const int o_len  = strtol ((const char *) o_len_pos,  NULL, 10);
+
+  if ((id_len != 16) && (id_len != 32)) return (PARSER_SALT_VALUE);
+
+  if (u_len != 32) return (PARSER_SALT_VALUE);
+  if (o_len != 32) return (PARSER_SALT_VALUE);
+
+  const int bits = strtol ((const char *) bits_pos, NULL, 10);
+
+  if (bits != 128) return (PARSER_SALT_VALUE);
+
+  int enc_md = 1;
+
+  if (R >= 4)
+  {
+    enc_md = strtol ((const char *) enc_md_pos, NULL, 10);
+  }
+
+  // copy data to esalt
+
+  pdf->V = V;
+  pdf->R = R;
+  pdf->P = P;
+
+  pdf->enc_md = enc_md;
+
+  pdf->id_buf[0] = hex_to_u32 (id_buf_pos +  0);
+  pdf->id_buf[1] = hex_to_u32 (id_buf_pos +  8);
+  pdf->id_buf[2] = hex_to_u32 (id_buf_pos + 16);
+  pdf->id_buf[3] = hex_to_u32 (id_buf_pos + 24);
+
+  if (id_len == 32)
+  {
+    pdf->id_buf[4] = hex_to_u32 (id_buf_pos + 32);
+    pdf->id_buf[5] = hex_to_u32 (id_buf_pos + 40);
+    pdf->id_buf[6] = hex_to_u32 (id_buf_pos + 48);
+    pdf->id_buf[7] = hex_to_u32 (id_buf_pos + 56);
+  }
+
+  pdf->id_len = id_len;
+
+  pdf->u_buf[0]  = hex_to_u32 (u_buf_pos +  0);
+  pdf->u_buf[1]  = hex_to_u32 (u_buf_pos +  8);
+  pdf->u_buf[2]  = hex_to_u32 (u_buf_pos + 16);
+  pdf->u_buf[3]  = hex_to_u32 (u_buf_pos + 24);
+  pdf->u_buf[4]  = hex_to_u32 (u_buf_pos + 32);
+  pdf->u_buf[5]  = hex_to_u32 (u_buf_pos + 40);
+  pdf->u_buf[6]  = hex_to_u32 (u_buf_pos + 48);
+  pdf->u_buf[7]  = hex_to_u32 (u_buf_pos + 56);
+  pdf->u_len     = u_len;
+
+  pdf->o_buf[0]  = hex_to_u32 (o_buf_pos +  0);
+  pdf->o_buf[1]  = hex_to_u32 (o_buf_pos +  8);
+  pdf->o_buf[2]  = hex_to_u32 (o_buf_pos + 16);
+  pdf->o_buf[3]  = hex_to_u32 (o_buf_pos + 24);
+  pdf->o_buf[4]  = hex_to_u32 (o_buf_pos + 32);
+  pdf->o_buf[5]  = hex_to_u32 (o_buf_pos + 40);
+  pdf->o_buf[6]  = hex_to_u32 (o_buf_pos + 48);
+  pdf->o_buf[7]  = hex_to_u32 (o_buf_pos + 56);
+  pdf->o_len     = o_len;
+
+  // precompute rc4 data for later use
+
+  u32 padding[8] =
+  {
+    0x5e4ebf28,
+    0x418a754e,
+    0x564e0064,
+    0x0801faff,
+    0xb6002e2e,
+    0x803e68d0,
+    0xfea90c2f,
+    0x7a695364
+  };
+
+  // md5
+
+  u32 salt_pc_block[32] = { 0 };
+
+  u8 *salt_pc_ptr = (u8 *) salt_pc_block;
+
+  memcpy (salt_pc_ptr, padding, 32);
+  memcpy (salt_pc_ptr + 32, pdf->id_buf, pdf->id_len);
+
+  u32 salt_pc_digest[4] = { 0 };
+
+  md5_complete_no_limit (salt_pc_digest, salt_pc_block, 32 + pdf->id_len);
+
+  pdf->rc4data[0] = salt_pc_digest[0];
+  pdf->rc4data[1] = salt_pc_digest[1];
+
+  // we use ID for salt, maybe needs to change, we will see...
+
+  salt->salt_buf[0] = pdf->id_buf[0];
+  salt->salt_buf[1] = pdf->id_buf[1];
+  salt->salt_buf[2] = pdf->id_buf[2];
+  salt->salt_buf[3] = pdf->id_buf[3];
+  salt->salt_buf[4] = pdf->o_buf[0]; // switched u_buf with o_buf vs m10500
+  salt->salt_buf[5] = pdf->o_buf[1];
+  salt->salt_buf[6] = pdf->u_buf[0];
+  salt->salt_buf[7] = pdf->u_buf[1];
+  salt->salt_len    = pdf->id_len + 16;
+
+  salt->salt_iter   = (50 + 20);
+
+  digest[0] = pdf->o_buf[0]; // o_buf instead of u_buf vs m10500
+  digest[1] = pdf->o_buf[1];
+  digest[2] = 0;
+  digest[3] = 0;
+
+  return (PARSER_OK);
+}
+
+int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size)
+{
+  const pdf_t *pdf = (const pdf_t *) esalt_buf;
+
+  int line_len = 0;
+
+  if (pdf->id_len == 32)
+  {
+    line_len = snprintf (line_buf, line_size, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
+      pdf->V,
+      pdf->R,
+      128,
+      pdf->P,
+      pdf->enc_md,
+      pdf->id_len,
+      byte_swap_32 (pdf->id_buf[0]),
+      byte_swap_32 (pdf->id_buf[1]),
+      byte_swap_32 (pdf->id_buf[2]),
+      byte_swap_32 (pdf->id_buf[3]),
+      byte_swap_32 (pdf->id_buf[4]),
+      byte_swap_32 (pdf->id_buf[5]),
+      byte_swap_32 (pdf->id_buf[6]),
+      byte_swap_32 (pdf->id_buf[7]),
+      pdf->u_len,
+      byte_swap_32 (pdf->u_buf[0]),
+      byte_swap_32 (pdf->u_buf[1]),
+      byte_swap_32 (pdf->u_buf[2]),
+      byte_swap_32 (pdf->u_buf[3]),
+      byte_swap_32 (pdf->u_buf[4]),
+      byte_swap_32 (pdf->u_buf[5]),
+      byte_swap_32 (pdf->u_buf[6]),
+      byte_swap_32 (pdf->u_buf[7]),
+      pdf->o_len,
+      byte_swap_32 (pdf->o_buf[0]),
+      byte_swap_32 (pdf->o_buf[1]),
+      byte_swap_32 (pdf->o_buf[2]),
+      byte_swap_32 (pdf->o_buf[3]),
+      byte_swap_32 (pdf->o_buf[4]),
+      byte_swap_32 (pdf->o_buf[5]),
+      byte_swap_32 (pdf->o_buf[6]),
+      byte_swap_32 (pdf->o_buf[7])
+    );
+  }
+  else
+  {
+    line_len = snprintf (line_buf, line_size, "$pdf$%d*%d*%d*%d*%d*%d*%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x*%d*%08x%08x%08x%08x%08x%08x%08x%08x",
+      pdf->V,
+      pdf->R,
+      128,
+      pdf->P,
+      pdf->enc_md,
+      pdf->id_len,
+      byte_swap_32 (pdf->id_buf[0]),
+      byte_swap_32 (pdf->id_buf[1]),
+      byte_swap_32 (pdf->id_buf[2]),
+      byte_swap_32 (pdf->id_buf[3]),
+      pdf->u_len,
+      byte_swap_32 (pdf->u_buf[0]),
+      byte_swap_32 (pdf->u_buf[1]),
+      byte_swap_32 (pdf->u_buf[2]),
+      byte_swap_32 (pdf->u_buf[3]),
+      byte_swap_32 (pdf->u_buf[4]),
+      byte_swap_32 (pdf->u_buf[5]),
+      byte_swap_32 (pdf->u_buf[6]),
+      byte_swap_32 (pdf->u_buf[7]),
+      pdf->o_len,
+      byte_swap_32 (pdf->o_buf[0]),
+      byte_swap_32 (pdf->o_buf[1]),
+      byte_swap_32 (pdf->o_buf[2]),
+      byte_swap_32 (pdf->o_buf[3]),
+      byte_swap_32 (pdf->o_buf[4]),
+      byte_swap_32 (pdf->o_buf[5]),
+      byte_swap_32 (pdf->o_buf[6]),
+      byte_swap_32 (pdf->o_buf[7])
+    );
+  }
+
+  return line_len;
+}
+
+void module_init (module_ctx_t *module_ctx)
+{
+  module_ctx->module_context_size             = MODULE_CONTEXT_SIZE_CURRENT;
+  module_ctx->module_interface_version        = MODULE_INTERFACE_VERSION_CURRENT;
+
+  module_ctx->module_attack_exec              = module_attack_exec;
+  module_ctx->module_benchmark_esalt          = MODULE_DEFAULT;
+  module_ctx->module_benchmark_hook_salt      = MODULE_DEFAULT;
+  module_ctx->module_benchmark_mask           = MODULE_DEFAULT;
+  module_ctx->module_benchmark_salt           = MODULE_DEFAULT;
+  module_ctx->module_build_plain_postprocess  = MODULE_DEFAULT;
+  module_ctx->module_deep_comp_kernel         = MODULE_DEFAULT;
+  module_ctx->module_dgst_pos0                = module_dgst_pos0;
+  module_ctx->module_dgst_pos1                = module_dgst_pos1;
+  module_ctx->module_dgst_pos2                = module_dgst_pos2;
+  module_ctx->module_dgst_pos3                = module_dgst_pos3;
+  module_ctx->module_dgst_size                = module_dgst_size;
+  module_ctx->module_dictstat_disable         = MODULE_DEFAULT;
+  module_ctx->module_esalt_size               = module_esalt_size;
+  module_ctx->module_extra_buffer_size        = MODULE_DEFAULT;
+  module_ctx->module_extra_tmp_size           = MODULE_DEFAULT;
+  module_ctx->module_forced_outfile_format    = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_count        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_parse        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_save         = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_zero_hash    = MODULE_DEFAULT;
+  module_ctx->module_hash_decode              = module_hash_decode;
+  module_ctx->module_hash_encode_status       = MODULE_DEFAULT;
+  module_ctx->module_hash_encode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_encode              = module_hash_encode;
+  module_ctx->module_hash_init_selftest       = MODULE_DEFAULT;
+  module_ctx->module_hash_mode                = MODULE_DEFAULT;
+  module_ctx->module_hash_category            = module_hash_category;
+  module_ctx->module_hash_name                = module_hash_name;
+  module_ctx->module_hashes_count_min         = MODULE_DEFAULT;
+  module_ctx->module_hashes_count_max         = MODULE_DEFAULT;
+  module_ctx->module_hlfmt_disable            = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_size    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_init    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_term    = MODULE_DEFAULT;
+  module_ctx->module_hook12                   = MODULE_DEFAULT;
+  module_ctx->module_hook23                   = MODULE_DEFAULT;
+  module_ctx->module_hook_salt_size           = MODULE_DEFAULT;
+  module_ctx->module_hook_size                = MODULE_DEFAULT;
+  module_ctx->module_jit_build_options        = module_jit_build_options;
+  module_ctx->module_jit_cache_disable        = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_max       = module_kernel_threads_max;
+  module_ctx->module_kernel_threads_min       = module_kernel_threads_min;
+  module_ctx->module_kern_type                = module_kern_type;
+  module_ctx->module_kern_type_dynamic        = MODULE_DEFAULT;
+  module_ctx->module_opti_type                = module_opti_type;
+  module_ctx->module_opts_type                = module_opts_type;
+  module_ctx->module_outfile_check_disable    = MODULE_DEFAULT;
+  module_ctx->module_outfile_check_nocomp     = MODULE_DEFAULT;
+  module_ctx->module_potfile_custom_check     = MODULE_DEFAULT;
+  module_ctx->module_potfile_disable          = MODULE_DEFAULT;
+  module_ctx->module_potfile_keep_all_hashes  = MODULE_DEFAULT;
+  module_ctx->module_pwdump_column            = MODULE_DEFAULT;
+  module_ctx->module_pw_max                   = module_pw_max;
+  module_ctx->module_pw_min                   = MODULE_DEFAULT;
+  module_ctx->module_salt_max                 = MODULE_DEFAULT;
+  module_ctx->module_salt_min                 = MODULE_DEFAULT;
+  module_ctx->module_salt_type                = module_salt_type;
+  module_ctx->module_separator                = MODULE_DEFAULT;
+  module_ctx->module_st_hash                  = module_st_hash;
+  module_ctx->module_st_pass                  = module_st_pass;
+  module_ctx->module_tmp_size                 = module_tmp_size;
+  module_ctx->module_unstable_warning         = MODULE_DEFAULT;
+  module_ctx->module_warmup_disable           = MODULE_DEFAULT;
+}
diff --git a/src/modules/module_25500.c b/src/modules/module_25500.c
new file mode 100644
index 000000000..5201ef5ed
--- /dev/null
+++ b/src/modules/module_25500.c
@@ -0,0 +1,366 @@
+/**
+ * Author......: See docs/credits.txt
+ * License.....: MIT
+ */
+
+#include "common.h"
+#include "types.h"
+#include "modules.h"
+#include "bitops.h"
+#include "convert.h"
+#include "shared.h"
+#include "memory.h"
+
+static const u32   ATTACK_EXEC    = ATTACK_EXEC_OUTSIDE_KERNEL;
+static const u32   DGST_POS0      = 0;
+static const u32   DGST_POS1      = 1;
+static const u32   DGST_POS2      = 2;
+static const u32   DGST_POS3      = 3;
+static const u32   DGST_SIZE      = DGST_SIZE_4_4;
+static const u32   HASH_CATEGORY  = HASH_CATEGORY_PASSWORD_MANAGER;
+static const char *HASH_NAME      = "Stargazer Stellar Wallet XLM";
+static const u64   KERN_TYPE      = 25500;
+static const u32   OPTI_TYPE      = OPTI_TYPE_ZERO_BYTE
+                                  | OPTI_TYPE_SLOW_HASH_SIMD_LOOP;
+static const u64   OPTS_TYPE      = OPTS_TYPE_PT_GENERATE_LE
+                                  | OPTS_TYPE_ST_BASE64
+                                  | OPTS_TYPE_HASH_COPY;
+static const u32   SALT_TYPE      = SALT_TYPE_EMBEDDED;
+static const char *ST_PASS        = "lacoin";
+static const char *ST_HASH        = "$stellar$ZCtl/+vWiLL358Jz+xnP5A==$GgmFU37DSX4evSMU$CoMGXWHqDmLwxRAgORqjK/MyFEMAkMbqvDEDMjn4veVwpHab9m6Egcwp70qEJsRhjkHjCMWj9zX40tu9UK5QACuB8gD1r9Cu";
+
+u32         module_attack_exec    (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC;     }
+u32         module_dgst_pos0      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0;       }
+u32         module_dgst_pos1      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1;       }
+u32         module_dgst_pos2      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2;       }
+u32         module_dgst_pos3      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3;       }
+u32         module_dgst_size      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE;       }
+u32         module_hash_category  (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY;   }
+const char *module_hash_name      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME;       }
+u64         module_kern_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE;       }
+u32         module_opti_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE;       }
+u64         module_opts_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE;       }
+u32         module_salt_type      (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE;       }
+const char *module_st_hash        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH;         }
+const char *module_st_pass        (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS;         }
+
+typedef struct pbkdf2_sha256_tmp
+{
+  u32  ipad[8];
+  u32  opad[8];
+
+  u32  dgst[32];
+  u32  out[32];
+
+} pbkdf2_sha256_tmp_t;
+
+typedef struct pbkdf2_sha256_aes_gcm
+{
+  u32 salt_buf[64];
+  u32 iv_buf[4];
+  u32 iv_len;
+  u32 ct_buf[16];
+  u32 ct_len;
+
+} pbkdf2_sha256_aes_gcm_t;
+
+static const char *SIGNATURE_STARGAZER_STELLAR_WALLET_XLM = "$stellar$";
+
+char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const hc_device_param_t *device_param)
+{
+  char *jit_build_options = NULL;
+
+  // Extra treatment for Apple systems
+  if (device_param->opencl_platform_vendor_id == VENDOR_ID_APPLE)
+  {
+    return jit_build_options;
+  }
+
+  // ROCM
+  if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) && (device_param->has_vperm == true))
+  {
+    hc_asprintf (&jit_build_options, "-D _unroll");
+  }
+
+  return jit_build_options;
+}
+
+u64 module_esalt_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 esalt_size = (const u64) sizeof (pbkdf2_sha256_aes_gcm_t);
+
+  return esalt_size;
+}
+
+u64 module_tmp_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  const u64 tmp_size = (const u64) sizeof (pbkdf2_sha256_tmp_t);
+
+  return tmp_size;
+}
+
+u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra)
+{
+  // this overrides the reductions of PW_MAX in case optimized kernel is selected
+  // IOW, even in optimized kernel mode it support length 256
+
+  const u32 pw_max = PW_MAX;
+
+  return pw_max;
+}
+
+int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
+{
+  u32 *digest = (u32 *) digest_buf;
+
+  pbkdf2_sha256_aes_gcm_t *stellar = (pbkdf2_sha256_aes_gcm_t *) esalt_buf;
+
+  token_t token;
+
+  token.token_cnt  = 4;
+
+  token.signatures_cnt    = 1;
+  token.signatures_buf[0] = SIGNATURE_STARGAZER_STELLAR_WALLET_XLM;
+
+  token.len[0]     = 9;
+  token.attr[0]    = TOKEN_ATTR_FIXED_LENGTH
+                   | TOKEN_ATTR_VERIFY_SIGNATURE;
+
+  token.sep[1]     = '$';
+  token.len_min[1] = 24;
+  token.len_max[1] = 24;
+  token.attr[1]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  token.sep[2]     = '$';
+  token.len_min[2] = 16;
+  token.len_max[2] = 16;
+  token.attr[2]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  token.sep[3]     = '$';
+  token.len_min[3] = 96;
+  token.len_max[3] = 96;
+  token.attr[3]    = TOKEN_ATTR_VERIFY_LENGTH
+                   | TOKEN_ATTR_VERIFY_BASE64A;
+
+  const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
+
+  if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
+
+  u8 tmp_buf[512];
+
+  size_t tmp_len = 0;
+
+  // iter
+
+  salt->salt_iter = 4096 - 1;
+
+  // salt
+
+  const u8 *salt_pos = token.buf[1];
+  const int salt_len = token.len[1];
+
+  memset (tmp_buf, 0, sizeof (tmp_buf));
+
+  tmp_len = base64_decode (base64_to_int, salt_pos, salt_len, tmp_buf);
+
+  if (tmp_len != 16) return (PARSER_SALT_LENGTH);
+
+  memcpy (salt->salt_buf, tmp_buf, tmp_len);
+
+  salt->salt_len = tmp_len;
+
+  stellar->salt_buf[0] = salt->salt_buf[0];
+  stellar->salt_buf[1] = salt->salt_buf[1];
+  stellar->salt_buf[2] = salt->salt_buf[2];
+  stellar->salt_buf[3] = salt->salt_buf[3];
+
+  // iv
+
+  const u8 *iv_pos = token.buf[2];
+  const int iv_len = token.len[2];
+
+  memset (tmp_buf, 0, sizeof (tmp_buf));
+
+  tmp_len = base64_decode (base64_to_int, iv_pos, iv_len, tmp_buf);
+
+  if (tmp_len != 12) return (PARSER_IV_LENGTH);
+
+  memcpy ((u8 *)stellar->iv_buf, tmp_buf, tmp_len);
+
+  stellar->iv_buf[0] = byte_swap_32 (stellar->iv_buf[0]);
+  stellar->iv_buf[1] = byte_swap_32 (stellar->iv_buf[1]);
+  stellar->iv_buf[2] = byte_swap_32 (stellar->iv_buf[2]);
+  stellar->iv_buf[3] = 0x000001;
+
+  stellar->iv_len = tmp_len;
+
+  // ciphertext
+
+  const u8 *ct_pos = token.buf[3];
+  const int ct_len = token.len[3];
+
+  memset (tmp_buf, 0, sizeof (tmp_buf));
+
+  tmp_len = base64_decode (base64_to_int, ct_pos, ct_len, tmp_buf);
+
+  if (tmp_len != 72) return (PARSER_CT_LENGTH);
+
+  memcpy ((u8 *)stellar->ct_buf, tmp_buf, tmp_len - 16);
+
+  for (u32 i = 0; i < 14; i++)
+  {
+    stellar->ct_buf[i] = byte_swap_32 (stellar->ct_buf[i]);
+  }
+
+  stellar->ct_buf[14] = 0;
+  stellar->ct_buf[15] = 0;
+
+  stellar->ct_len = tmp_len - 16;
+
+  // tag
+
+  u32 tag_buf[4];
+
+  memset (tag_buf, 0, sizeof (tag_buf));
+
+  memcpy ((u8 *)tag_buf, tmp_buf+stellar->ct_len, 16);
+
+  digest[0] = byte_swap_32 (tag_buf[0]);
+  digest[1] = byte_swap_32 (tag_buf[1]);
+  digest[2] = byte_swap_32 (tag_buf[2]);
+  digest[3] = byte_swap_32 (tag_buf[3]);
+
+  return (PARSER_OK);
+}
+
+int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size)
+{
+  const u32 *digest = (const u32 *) digest_buf;
+
+  pbkdf2_sha256_aes_gcm_t *stellar = (pbkdf2_sha256_aes_gcm_t *) esalt_buf;
+
+  // salt
+
+  #define SALT_LEN_BASE64 ((16 * 8) / 6) + 3
+  #define IV_LEN_BASE64   ((12 * 8) / 6) + 3
+  #define CT_LEN_BASE64   ((72 * 8) / 6) + 3
+
+  u8 salt_buf[SALT_LEN_BASE64] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) salt->salt_buf, (const int) salt->salt_len, salt_buf);
+
+  // iv
+
+  u32 tmp_iv_buf[3] = { 0 };
+
+  tmp_iv_buf[0] = byte_swap_32 (stellar->iv_buf[0]);
+  tmp_iv_buf[1] = byte_swap_32 (stellar->iv_buf[1]);
+  tmp_iv_buf[2] = byte_swap_32 (stellar->iv_buf[2]);
+
+  u8 iv_buf[IV_LEN_BASE64] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) tmp_iv_buf, (const int) stellar->iv_len, iv_buf);
+
+  // ct
+
+  u32 tmp_buf[18] = { 0 };
+
+  for (int i = 0; i < 14; i++) tmp_buf[i] = byte_swap_32 (stellar->ct_buf[i]);
+
+  tmp_buf[14] = byte_swap_32 (digest[0]);
+  tmp_buf[15] = byte_swap_32 (digest[1]);
+  tmp_buf[16] = byte_swap_32 (digest[2]);
+  tmp_buf[17] = byte_swap_32 (digest[3]);
+
+  u8 ct_buf[CT_LEN_BASE64] = { 0 };
+
+  base64_encode (int_to_base64, (const u8 *) tmp_buf, (const int) stellar->ct_len+16, ct_buf);
+
+  u8 *out_buf = (u8 *) line_buf;
+
+  int out_len = snprintf ((char *) out_buf, line_size, "%s%s$%s$%s",
+    SIGNATURE_STARGAZER_STELLAR_WALLET_XLM,
+    salt_buf,
+    iv_buf,
+    ct_buf);
+
+  return out_len;
+}
+
+void module_init (module_ctx_t *module_ctx)
+{
+  module_ctx->module_context_size             = MODULE_CONTEXT_SIZE_CURRENT;
+  module_ctx->module_interface_version        = MODULE_INTERFACE_VERSION_CURRENT;
+
+  module_ctx->module_attack_exec              = module_attack_exec;
+  module_ctx->module_benchmark_esalt          = MODULE_DEFAULT;
+  module_ctx->module_benchmark_hook_salt      = MODULE_DEFAULT;
+  module_ctx->module_benchmark_mask           = MODULE_DEFAULT;
+  module_ctx->module_benchmark_salt           = MODULE_DEFAULT;
+  module_ctx->module_build_plain_postprocess  = MODULE_DEFAULT;
+  module_ctx->module_deep_comp_kernel         = MODULE_DEFAULT;
+  module_ctx->module_dgst_pos0                = module_dgst_pos0;
+  module_ctx->module_dgst_pos1                = module_dgst_pos1;
+  module_ctx->module_dgst_pos2                = module_dgst_pos2;
+  module_ctx->module_dgst_pos3                = module_dgst_pos3;
+  module_ctx->module_dgst_size                = module_dgst_size;
+  module_ctx->module_dictstat_disable         = MODULE_DEFAULT;
+  module_ctx->module_esalt_size               = module_esalt_size;
+  module_ctx->module_extra_buffer_size        = MODULE_DEFAULT;
+  module_ctx->module_extra_tmp_size           = MODULE_DEFAULT;
+  module_ctx->module_forced_outfile_format    = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_count        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_parse        = MODULE_DEFAULT;
+  module_ctx->module_hash_binary_save         = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_decode_zero_hash    = MODULE_DEFAULT;
+  module_ctx->module_hash_decode              = module_hash_decode;
+  module_ctx->module_hash_encode_status       = MODULE_DEFAULT;
+  module_ctx->module_hash_encode_potfile      = MODULE_DEFAULT;
+  module_ctx->module_hash_encode              = module_hash_encode;
+  module_ctx->module_hash_init_selftest       = MODULE_DEFAULT;
+  module_ctx->module_hash_mode                = MODULE_DEFAULT;
+  module_ctx->module_hash_category            = module_hash_category;
+  module_ctx->module_hash_name                = module_hash_name;
+  module_ctx->module_hashes_count_min         = MODULE_DEFAULT;
+  module_ctx->module_hashes_count_max         = MODULE_DEFAULT;
+  module_ctx->module_hlfmt_disable            = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_size    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_init    = MODULE_DEFAULT;
+  module_ctx->module_hook_extra_param_term    = MODULE_DEFAULT;
+  module_ctx->module_hook12                   = MODULE_DEFAULT;
+  module_ctx->module_hook23                   = MODULE_DEFAULT;
+  module_ctx->module_hook_salt_size           = MODULE_DEFAULT;
+  module_ctx->module_hook_size                = MODULE_DEFAULT;
+  module_ctx->module_jit_build_options        = module_jit_build_options;
+  module_ctx->module_jit_cache_disable        = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_accel_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_max         = MODULE_DEFAULT;
+  module_ctx->module_kernel_loops_min         = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_max       = MODULE_DEFAULT;
+  module_ctx->module_kernel_threads_min       = MODULE_DEFAULT;
+  module_ctx->module_kern_type                = module_kern_type;
+  module_ctx->module_kern_type_dynamic        = MODULE_DEFAULT;
+  module_ctx->module_opti_type                = module_opti_type;
+  module_ctx->module_opts_type                = module_opts_type;
+  module_ctx->module_outfile_check_disable    = MODULE_DEFAULT;
+  module_ctx->module_outfile_check_nocomp     = MODULE_DEFAULT;
+  module_ctx->module_potfile_custom_check     = MODULE_DEFAULT;
+  module_ctx->module_potfile_disable          = MODULE_DEFAULT;
+  module_ctx->module_potfile_keep_all_hashes  = MODULE_DEFAULT;
+  module_ctx->module_pwdump_column            = MODULE_DEFAULT;
+  module_ctx->module_pw_max                   = module_pw_max;
+  module_ctx->module_pw_min                   = MODULE_DEFAULT;
+  module_ctx->module_salt_max                 = MODULE_DEFAULT;
+  module_ctx->module_salt_min                 = MODULE_DEFAULT;
+  module_ctx->module_salt_type                = module_salt_type;
+  module_ctx->module_separator                = MODULE_DEFAULT;
+  module_ctx->module_st_hash                  = module_st_hash;
+  module_ctx->module_st_pass                  = module_st_pass;
+  module_ctx->module_tmp_size                 = module_tmp_size;
+  module_ctx->module_unstable_warning         = MODULE_DEFAULT;
+  module_ctx->module_warmup_disable           = MODULE_DEFAULT;
+}
diff --git a/src/outfile_check.c b/src/outfile_check.c
index 12c7cd757..c7c670c47 100644
--- a/src/outfile_check.c
+++ b/src/outfile_check.c
@@ -224,22 +224,7 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
             memset (hash_buf.hook_salt, 0, hashconfig->hook_salt_size);
           }
 
-          int parser_status = PARSER_HASH_LENGTH;
-
-          if (module_ctx->module_hash_decode_potfile != MODULE_DEFAULT)
-          {
-            void *tmps = hcmalloc (hashconfig->tmp_size);
-
-            parser_status = module_ctx->module_hash_decode_potfile (hashconfig, hash_buf.digest, hash_buf.salt, hash_buf.esalt, hash_buf.hook_salt, hash_buf.hash_info, line_buf, line_hash_len, tmps);
-
-            hcfree (tmps);
-          }
-          else
-          {
-            // "normal" case: hash in the outfile is the same as the hash in the original hash file
-
-            parser_status = module_ctx->module_hash_decode (hashconfig, hash_buf.digest, hash_buf.salt, hash_buf.esalt, hash_buf.hook_salt, hash_buf.hash_info, line_buf, line_hash_len);
-          }
+          int parser_status = module_ctx->module_hash_decode (hashconfig, hash_buf.digest, hash_buf.salt, hash_buf.esalt, hash_buf.hook_salt, hash_buf.hash_info, line_buf, line_hash_len);
 
           if (parser_status != PARSER_OK) continue;
 
diff --git a/src/shared.c b/src/shared.c
index 3bfda6aec..0150ea917 100644
--- a/src/shared.c
+++ b/src/shared.c
@@ -57,6 +57,8 @@ static const char *PA_038 = "Invalid key size";
 static const char *PA_039 = "Invalid block size";
 static const char *PA_040 = "Invalid or unsupported cipher";
 static const char *PA_041 = "Invalid filesize";
+static const char *PA_042 = "IV length exception";
+static const char *PA_043 = "CT length exception";
 static const char *PA_255 = "Unknown error";
 
 static const char *OPTI_STR_OPTIMIZED_KERNEL     = "Optimized-Kernel";
@@ -1032,6 +1034,8 @@ const char *strparser (const u32 parser_status)
     case PARSER_BLOCK_SIZE:           return PA_039;
     case PARSER_CIPHER:               return PA_040;
     case PARSER_FILE_SIZE:            return PA_041;
+    case PARSER_IV_LENGTH:            return PA_042;
+    case PARSER_CT_LENGTH:            return PA_043;
   }
 
   return PA_255;
diff --git a/src/status.c b/src/status.c
index 4234e5d60..a9f56190a 100644
--- a/src/status.c
+++ b/src/status.c
@@ -330,7 +330,17 @@ char *status_get_hash_target (const hashcat_ctx_t *hashcat_ctx)
 
     if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
     {
-      return hcstrdup (hashes->hashfile);
+      if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE_OPTIONAL)
+      {
+        if (hashes->hashfile)
+        {
+          return hcstrdup (hashes->hashfile);
+        }
+      }
+      else
+      {
+        return hcstrdup (hashes->hashfile);
+      }
     }
 
     char *tmp_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
diff --git a/tools/test.sh b/tools/test.sh
index ef3d2dd55..3692e02b4 100755
--- a/tools/test.sh
+++ b/tools/test.sh
@@ -655,15 +655,20 @@ function attack_1()
     cnt=0
 
     min=1
+    max=8
 
     if   [ "${hash_type}" -eq 14000 ]; then
       min=0
+      max=5
     elif [ "${hash_type}" -eq 14100 ]; then
       min=0
+      max=5
     elif [ "${hash_type}" -eq 14900 ]; then
       min=0
+      max=5
     elif [ "${hash_type}" -eq 15400 ]; then
       min=0
+      max=5
     fi
 
     echo "> Testing hash type $hash_type with attack mode 1, markov ${MARKOV}, single hash, Device-Type ${TYPE}, vector-width ${VECTOR}." >> "${OUTD}/logfull.txt" 2>> "${OUTD}/logfull.txt"
@@ -688,7 +693,9 @@ function attack_1()
 
         line_nr=1
 
-        if [ "${i}" -gt 1 ]; then
+        if [ "$min" -eq 0 ]; then
+          line_nr=$i
+        elif [ "${i}" -gt 1 ]; then
           line_nr=$((i - 1))
         fi
 
@@ -778,6 +785,8 @@ function attack_1()
 
       fi
 
+      if [ $i -eq ${max} ]; then break; fi
+
       i=$((i + 1))
 
     done 9< "${OUTD}/${hash_type}_hashes.txt"
diff --git a/tools/test_modules/m24100.pm b/tools/test_modules/m24100.pm
new file mode 100644
index 000000000..5b469f27f
--- /dev/null
+++ b/tools/test_modules/m24100.pm
@@ -0,0 +1,88 @@
+#!/usr/bin/env perl
+
+##
+## Author......: See docs/credits.txt
+## License.....: MIT
+##
+
+use strict;
+use warnings;
+
+use MIME::Base64 qw (decode_base64 encode_base64);
+use Digest::MD5  qw (md5_hex);
+use Digest::SHA1 qw (sha1);
+use Digest::HMAC qw (hmac);
+use Crypt::PBKDF2;
+
+sub module_constraints { [[0, 256], [16, 16], [-1, -1], [-1, -1], [-1, -1]] }
+
+my $ITERATIONS = 10000;
+my $MD5_SALT   = ":mongo:";
+my $HMAC_SALT  = "Server Key";
+
+sub module_generate_hash
+{
+  my $word = shift;
+  my $salt = shift;
+  my $iter = shift // $ITERATIONS;
+  my $user = shift // random_string (random_number (0, 57));
+
+  my $pbkdf = Crypt::PBKDF2->new
+  (
+    hash_class => 'HMACSHA1',
+    iterations => $iter,
+    output_len => 20
+  );
+
+  my $md5_dgst = md5_hex ($user . $MD5_SALT . $word);
+
+  my $pbkdf2_dgst = $pbkdf->PBKDF2 ($salt, $md5_dgst);
+
+  my $hash_buf = hmac ($HMAC_SALT, $pbkdf2_dgst, \&sha1);
+
+  my $hash = sprintf ('$mongodb-scram$*0*%s*%i*%s*%s', encode_base64 ($user, ""), $iter, encode_base64 ($salt, ""), encode_base64 ($hash_buf, ""));
+
+  return $hash;
+}
+
+sub module_verify_hash
+{
+  my $line = shift;
+
+  my $idx = index ($line, ':');
+
+  return unless $idx >= 0;
+
+  my $hash = substr ($line, 0, $idx);
+  my $word = substr ($line, $idx + 1);
+
+  return unless substr ($hash, 0, 17) eq '$mongodb-scram$*0';
+
+  my (undef, undef, $user, $iter, $salt) = split ('\*', $hash);
+
+  return unless defined ($user);
+  return unless defined ($iter);
+  return unless defined ($salt);
+
+  return unless ($user =~ m/^[A-Za-z0-9+\/=]{0,76}$/);
+
+  $user = decode_base64 ($user);
+
+  return unless (length ($user) <= 57);
+
+  return unless ($iter =~ m/^[1-9][0-9]{0,7}$/);
+
+  $iter = int ($iter);
+
+  return unless ($salt =~ m/^[A-Za-z0-9+\/=]{24}$/);
+
+  $salt = decode_base64 ($salt);
+
+  my $word_packed = pack_if_HEX_notation ($word);
+
+  my $new_hash = module_generate_hash ($word_packed, $salt, $iter, $user);
+
+  return ($new_hash, $word);
+}
+
+1;
diff --git a/tools/test_modules/m24200.pm b/tools/test_modules/m24200.pm
new file mode 100644
index 000000000..74b4bc4ab
--- /dev/null
+++ b/tools/test_modules/m24200.pm
@@ -0,0 +1,84 @@
+#!/usr/bin/env perl
+
+##
+## Author......: See docs/credits.txt
+## License.....: MIT
+##
+
+use strict;
+use warnings;
+
+use MIME::Base64 qw (decode_base64 encode_base64);
+use Digest::SHA  qw (sha256);
+use Digest::HMAC qw (hmac);
+use Crypt::PBKDF2;
+
+sub module_constraints { [[0, 256], [28, 28], [-1, -1], [-1, -1], [-1, -1]] }
+
+my $ITERATIONS = 15000;
+my $HMAC_SALT  = "Server Key";
+
+sub module_generate_hash
+{
+  my $word = shift;
+  my $salt = shift;
+  my $iter = shift // $ITERATIONS;
+  my $user = shift // random_string (random_number (0, 64));
+
+  my $pbkdf = Crypt::PBKDF2->new
+  (
+    hasher     => Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA2', 256),
+    iterations => $iter,
+    output_len => 32
+  );
+
+  my $pbkdf2_dgst = $pbkdf->PBKDF2 ($salt, $word);
+
+  my $hash_buf = hmac ($HMAC_SALT, $pbkdf2_dgst, \&sha256);
+
+  my $hash = sprintf ('$mongodb-scram$*1*%s*%i*%s*%s', encode_base64 ($user, ""), $iter, encode_base64 ($salt, ""), encode_base64 ($hash_buf, ""));
+
+  return $hash;
+}
+
+sub module_verify_hash
+{
+  my $line = shift;
+
+  my $idx = index ($line, ':');
+
+  return unless $idx >= 0;
+
+  my $hash = substr ($line, 0, $idx);
+  my $word = substr ($line, $idx + 1);
+
+  return unless substr ($hash, 0, 17) eq '$mongodb-scram$*1';
+
+  my (undef, undef, $user, $iter, $salt) = split ('\*', $hash);
+
+  return unless defined ($user);
+  return unless defined ($iter);
+  return unless defined ($salt);
+
+  return unless ($user =~ m/^[A-Za-z0-9+\/=]{0,88}$/);
+
+  $user = decode_base64 ($user);
+
+  return unless (length ($user) <= 64);
+
+  return unless ($iter =~ m/^[1-9][0-9]{0,7}$/);
+
+  $iter = int ($iter);
+
+  return unless ($salt =~ m/^[A-Za-z0-9+\/=]{40}$/);
+
+  $salt = decode_base64 ($salt);
+
+  my $word_packed = pack_if_HEX_notation ($word);
+
+  my $new_hash = module_generate_hash ($word_packed, $salt, $iter, $user);
+
+  return ($new_hash, $word);
+}
+
+1;
diff --git a/tools/test_modules/m25400.pm b/tools/test_modules/m25400.pm
new file mode 100644
index 000000000..4eb3da227
--- /dev/null
+++ b/tools/test_modules/m25400.pm
@@ -0,0 +1,277 @@
+#!/usr/bin/env perl
+
+##
+## Author......: See docs/credits.txt
+## License.....: MIT
+##
+
+# based off m10500 but added the owner password part ($o) to be able to test the edit password
+# two TODOs still (now only works if no user password is set):
+# 1. TODO use user password as input for md5 of o_digest if no owner password is set
+# 2. TODO dynamically add user password including padding to the RC4 input for the computation of the pdf o-value
+
+# easy test shortcut for debugging
+# a=$(echo 1 | tools/test.pl passthrough 10500 | tail -n1); echo $a; echo 1 | ./hashcat --potfile-disable --runtime 400 --hwmon-disable -O -D 2 --backend-vector-width 4 -a 0 -m 10500 $a
+
+use strict;
+use warnings;
+
+use Crypt::RC4;
+use Digest::MD5 qw (md5);
+
+my $PDF_PADDING =
+[
+  0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e, 0x56,
+  0xff, 0xfa, 0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
+  0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a
+];
+
+sub module_constraints { [[0, 15], [32, 32], [-1, -1], [-1, -1], [-1, -1]] }
+
+sub pdf_compute_encryption_key_user
+{
+  my $word  = shift;
+  my $padding   = shift;
+  my $id        = shift;
+  my $u         = shift;
+  my $o         = shift;
+  my $P         = shift;
+  my $V         = shift;
+  my $R         = shift;
+  my $enc       = shift;
+
+  ## start
+
+  my $data;
+
+  $data .= $word;
+
+  $data .= substr ($padding, 0, 32 - length $word);
+
+  $data .= pack ("H*", $o);
+  $data .= pack ("I",  $P);
+  $data .= pack ("H*", $id);
+
+  if ($R >= 4)
+  {
+    if (!$enc)
+    {
+      $data .= pack ("I", -1);
+    }
+  }
+
+  my $res = md5 ($data);
+
+  if ($R >= 3)
+  {
+    for (my $i = 0; $i < 50; $i++)
+    {
+      $res = md5 ($res);
+    }
+  }
+
+  return $res;
+}
+
+
+sub pdf_compute_encryption_key_owner
+{
+  my $word  = shift;
+  my $padding   = shift;
+  my $id        = shift;
+  my $u         = shift;
+  my $o         = shift;
+  my $P         = shift;
+  my $V         = shift;
+  my $R         = shift;
+  my $enc       = shift;
+
+  # TODO use user password as input for md5 of o_digest if no owner password is set
+  my $data;
+  $data .= $word;
+  $data .= substr ($padding, 0, 32 - length $word);
+  my $o_digest = md5 ($data);
+
+  if ($R >= 3)
+  {
+    for (my $i = 0; $i < 50; $i++)
+    {
+      $o_digest = md5 ($o_digest);
+    }
+  }
+
+  #printf("\$o_digest = %s\n", unpack ("H*", $o_digest));
+
+
+  my $o_key;
+  if ($R == 2)
+  {
+    $o_key = substr($o_digest, 0, 8);  # rc4 key is always 5 for revision 2, but for 3 or greather is dependent on the value of the encryption dictionaries length entry
+  }
+  else
+  {
+	$o_key = substr($o_digest, 0, 16); #length is always 128 bits or 16 bytes
+  }
+  #printf("\$o_key = %s\n", unpack ("H*", $o_key));
+
+  return $o_key;
+}
+
+sub module_generate_hash
+{
+  my $word = shift;
+  my $id   = shift;
+  my $u    = shift;
+  my $o    = shift;
+  my $P    = shift;
+  my $V    = shift;
+  my $R    = shift;
+  my $enc  = shift;
+
+  if (defined $u == 0)
+  {
+    $u = "0" x 64;
+  }
+
+  my $u_save = $u;
+
+  if (defined $o == 0)
+  {
+    $o = "0" x 64;
+  }
+
+  my $o_save = $u;
+
+  if (defined $R == 0)
+  {
+    $R = random_number (3, 4);
+  }
+
+  if (defined $V == 0)
+  {
+    $V = ($R == 3) ? 2 : 4;
+  }
+
+  if (defined $P == 0)
+  {
+    $P = ($R == 3) ? -4 : -1028;
+  }
+
+  if (defined $enc == 0)
+  {
+    $enc = ($R == 3) ? 1 : random_number (0, 1);
+  }
+
+  my $padding;
+
+  for (my $i = 0; $i < 32; $i++)
+  {
+    $padding .= pack ("C", $PDF_PADDING->[$i]);
+  }
+
+
+  ################ USER PASSWORD #################
+  my $res = pdf_compute_encryption_key_user($word, $padding, $id, $u, $o, $P, $V, $R, $enc);
+
+  my $digest = md5 ($padding . pack ("H*", $id));
+
+  my $m = Crypt::RC4->new ($res);
+  $u = $m->RC4 ($digest);
+
+  my @ress = split "", $res;
+
+  #do xor of rc4 19 times
+  for (my $x = 1; $x <= 19; $x++)
+  {
+    my @xor;
+
+    for (my $i = 0; $i < 16; $i++)
+    {
+      $xor[$i] = chr (ord ($ress[$i]) ^ $x);
+    }
+
+    my $s = join ("", @xor);
+
+    my $m2 = Crypt::RC4->new ($s);
+
+    $u = $m2->RC4 ($u);
+  }
+
+
+  ################ OWNER PASSWORD #################
+  my $o_key = pdf_compute_encryption_key_owner($word, $padding, $id, $u, $o, $P, $V, $R, $enc);
+  my $n = Crypt::RC4->new ($o_key);
+  $o = $n->RC4(substr ($padding, 0, 32 - length "")); # TODO dynamically add user password including padding to the RC4 input for the computation of the pdf o-value
+
+  #printf("padding_empty_str = %s\n", unpack ("H*", substr ($padding, 0, 32 - length "")));
+
+  my @ress2 = split "", $o_key;
+
+  if ($R >= 3)
+  {
+    #do xor of rc4 19 times
+    for (my $x = 1; $x <= 19; $x++)
+    {
+      my @xor;
+
+      for (my $i = 0; $i < 16; $i++)
+      {
+        $xor[$i] = chr (ord ($ress2[$i]) ^ $x);
+      }
+
+      my $s = join ("", @xor);
+
+      my $n2 = Crypt::RC4->new ($s);
+
+      $o = $n2->RC4 ($o);
+    }
+  }
+
+  #printf("\$u = %s\n", unpack ("H*", $u));
+
+  $u .= substr (pack ("H*", $u_save), 16, 16);
+
+  #printf("\$o = %s\n", unpack ("H*", $o));
+  #printf("\$u = %s\n", unpack ("H*", $u));
+
+  my $hash = sprintf ('$pdf$%d*%d*128*%d*%d*16*%s*32*%s*32*%s', $V, $R, $P, $enc, $id, unpack ("H*", $u), unpack ("H*", $o));
+
+  return $hash;
+}
+
+sub module_verify_hash
+{
+  my $line = shift;
+
+  my ($hash_in, $word) = split ":", $line;
+
+  return unless defined $hash_in;
+  return unless defined $word;
+
+  my @data = split /\*/, $hash_in;
+
+  return unless scalar @data == 11;
+
+  my $V        = shift @data; $V = substr ($V, 5, 1);
+  my $R        = shift @data;
+  return unless (shift @data eq '128'); # length is always 128 here
+  my $P        = shift @data;
+  my $enc      = shift @data;
+  return unless (shift @data eq '16');
+  my $id       = shift @data;
+  return unless (shift @data eq '32');
+  my $u        = shift @data;
+  return unless (shift @data eq '32');
+  my $o        = shift @data;
+
+  return unless defined $id;
+  return unless defined $word;
+
+  $word = pack_if_HEX_notation ($word);
+
+  my $new_hash = module_generate_hash ($word, $id, $u, $o, $P, $V, $R, $enc);
+
+  return ($new_hash, $word);
+}
+
+1;