diff --git a/OpenCL/m20500_a0-pure.cl b/OpenCL/m20500_a0-pure.cl
new file mode 100644
index 000000000..30e47d830
--- /dev/null
+++ b/OpenCL/m20500_a0-pure.cl
@@ -0,0 +1,320 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+#include "inc_rp.h"
+#include "inc_rp.cl"
+
+#define MSB(x)          ((x) >> 24)
+#define CRC32(x,c,t)    (((x) >> 8) ^ (t)[((x) ^ (c)) & 0xff])
+#define CONST           0x08088405
+#define KEY0INIT        0x12345678
+#define KEY1INIT        0x23456789
+#define KEY2INIT        0x34567890
+
+#define update_key012(k0,k1,k2,c,t)           \
+{                                             \
+  (k0) = CRC32 ((k0), c, (t));                \
+  (k1) = ((k1) + ((k0) & 0xff)) * CONST + 1;  \
+  (k2) = CRC32 ((k2), MSB (k1), (t));         \
+}
+
+CONSTANT_VK u32a crc32tab[256] =
+{
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+KERNEL_FQ void m20500_sxx (KERN_ATTR_RULES ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (u64 i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    digests_buf[digests_offset].digest_buf[0],
+    digests_buf[digests_offset].digest_buf[1],
+    digests_buf[digests_offset].digest_buf[2],
+    0
+  };
+
+  /**
+   * base
+   */
+
+  COPY_PW (pws[gid]);
+
+  /**
+   * loop
+   */
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    pw_t t = PASTE_PW;
+
+    t.pw_len = apply_rules (rules_buf[il_pos].cmds, t.i, t.pw_len);
+
+    u32x key0 = KEY0INIT;
+    u32x key1 = KEY1INIT;
+    u32x key2 = KEY2INIT;
+
+    for (u32 i = 0, j = 0; i < t.pw_len; i += 4, j += 1)
+    {
+      if (t.pw_len >= (i + 1)) update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (t.i[j]), l_crc32tab);
+      if (t.pw_len >= (i + 2)) update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (t.i[j]), l_crc32tab);
+      if (t.pw_len >= (i + 3)) update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (t.i[j]), l_crc32tab);
+      if (t.pw_len >= (i + 4)) update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (t.i[j]), l_crc32tab);
+    }
+
+    const u32x r0 = key0;
+    const u32x r1 = key1;
+    const u32x r2 = key2;
+    const u32x r3 = 0;
+
+    COMPARE_S_SIMD (r0, r1, r2, r3);
+  }
+}
+
+KERNEL_FQ void m20500_mxx (KERN_ATTR_RULES ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (u64 i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * base
+   */
+
+  COPY_PW (pws[gid]);
+
+  /**
+   * loop
+   */
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    pw_t t = PASTE_PW;
+
+    t.pw_len = apply_rules (rules_buf[il_pos].cmds, t.i, t.pw_len);
+
+    u32x key0 = KEY0INIT;
+    u32x key1 = KEY1INIT;
+    u32x key2 = KEY2INIT;
+
+    for (u32 i = 0, j = 0; i < t.pw_len; i += 4, j += 1)
+    {
+      if (t.pw_len >= (i + 1)) update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (t.i[j]), l_crc32tab);
+      if (t.pw_len >= (i + 2)) update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (t.i[j]), l_crc32tab);
+      if (t.pw_len >= (i + 3)) update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (t.i[j]), l_crc32tab);
+      if (t.pw_len >= (i + 4)) update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (t.i[j]), l_crc32tab);
+    }
+
+    const u32x r0 = key0;
+    const u32x r1 = key1;
+    const u32x r2 = key2;
+    const u32x r3 = 0;
+
+    COMPARE_M_SIMD (r0, r1, r2, r3);
+  }
+}
+
+#undef update_key012
+#undef CONST
+#undef CRC32
+#undef MSB
+#undef KEY0INIT
+#undef KEY1INIT
+#undef KEY2INIT
diff --git a/OpenCL/m20500_a1-pure.cl b/OpenCL/m20500_a1-pure.cl
new file mode 100644
index 000000000..27db26ea9
--- /dev/null
+++ b/OpenCL/m20500_a1-pure.cl
@@ -0,0 +1,334 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+
+#define MSB(x)          ((x) >> 24)
+#define CRC32(x,c,t)    (((x) >> 8) ^ (t)[((x) ^ (c)) & 0xff])
+#define CONST           0x08088405
+#define KEY0INIT        0x12345678
+#define KEY1INIT        0x23456789
+#define KEY2INIT        0x34567890
+
+#define update_key012(k0,k1,k2,c,t)           \
+{                                             \
+  (k0) = CRC32 ((k0), c, (t));                \
+  (k1) = ((k1) + ((k0) & 0xff)) * CONST + 1;  \
+  (k2) = CRC32 ((k2), MSB (k1), (t));         \
+}
+
+CONSTANT_VK u32a crc32tab[256] =
+{
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+KERNEL_FQ void m20500_sxx (KERN_ATTR_BASIC ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (u64 i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    digests_buf[digests_offset].digest_buf[0],
+    digests_buf[digests_offset].digest_buf[1],
+    digests_buf[digests_offset].digest_buf[2],
+    0
+  };
+
+  /**
+   * loop
+   */
+
+  u32x key0init = KEY0INIT;
+  u32x key1init = KEY1INIT;
+  u32x key2init = KEY2INIT;
+
+  for (u32 i = 0, j = 0; i < pws[gid].pw_len; i += 4, j += 1)
+  {
+    if (pws[gid].pw_len >= (i + 1)) update_key012 (key0init, key1init, key2init, unpack_v8a_from_v32_S (pws[gid].i[j]), l_crc32tab);
+    if (pws[gid].pw_len >= (i + 2)) update_key012 (key0init, key1init, key2init, unpack_v8b_from_v32_S (pws[gid].i[j]), l_crc32tab);
+    if (pws[gid].pw_len >= (i + 3)) update_key012 (key0init, key1init, key2init, unpack_v8c_from_v32_S (pws[gid].i[j]), l_crc32tab);
+    if (pws[gid].pw_len >= (i + 4)) update_key012 (key0init, key1init, key2init, unpack_v8d_from_v32_S (pws[gid].i[j]), l_crc32tab);
+  }
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    u32x key0 = key0init;
+    u32x key1 = key1init;
+    u32x key2 = key2init;
+
+    for (u32 i = 0, j = 0; i < combs_buf[il_pos].pw_len; i += 4, j += 1)
+    {
+      if (combs_buf[il_pos].pw_len >= (i + 1)) update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+      if (combs_buf[il_pos].pw_len >= (i + 2)) update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+      if (combs_buf[il_pos].pw_len >= (i + 3)) update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+      if (combs_buf[il_pos].pw_len >= (i + 4)) update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+    }
+
+    const u32x r0 = key0;
+    const u32x r1 = key1;
+    const u32x r2 = key2;
+    const u32x r3 = 0;
+
+    COMPARE_S_SIMD (r0, r1, r2, r3);
+  }
+}
+
+KERNEL_FQ void m20500_mxx (KERN_ATTR_BASIC ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (u64 i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    digests_buf[digests_offset].digest_buf[0],
+    digests_buf[digests_offset].digest_buf[1],
+    digests_buf[digests_offset].digest_buf[2],
+    0
+  };
+
+  /**
+   * loop
+   */
+
+  u32x key0init = KEY0INIT;
+  u32x key1init = KEY1INIT;
+  u32x key2init = KEY2INIT;
+
+  for (u32 i = 0, j = 0; i < pws[gid].pw_len; i += 4, j += 1)
+  {
+    if (pws[gid].pw_len >= (i + 1)) update_key012 (key0init, key1init, key2init, unpack_v8a_from_v32_S (pws[gid].i[j]), l_crc32tab);
+    if (pws[gid].pw_len >= (i + 2)) update_key012 (key0init, key1init, key2init, unpack_v8b_from_v32_S (pws[gid].i[j]), l_crc32tab);
+    if (pws[gid].pw_len >= (i + 3)) update_key012 (key0init, key1init, key2init, unpack_v8c_from_v32_S (pws[gid].i[j]), l_crc32tab);
+    if (pws[gid].pw_len >= (i + 4)) update_key012 (key0init, key1init, key2init, unpack_v8d_from_v32_S (pws[gid].i[j]), l_crc32tab);
+  }
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    u32x key0 = key0init;
+    u32x key1 = key1init;
+    u32x key2 = key2init;
+
+    for (u32 i = 0, j = 0; i < combs_buf[il_pos].pw_len; i += 4, j += 1)
+    {
+      if (combs_buf[il_pos].pw_len >= (i + 1)) update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+      if (combs_buf[il_pos].pw_len >= (i + 2)) update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+      if (combs_buf[il_pos].pw_len >= (i + 3)) update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+      if (combs_buf[il_pos].pw_len >= (i + 4)) update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (combs_buf[il_pos].i[j]), l_crc32tab);
+    }
+
+    const u32x r0 = key0;
+    const u32x r1 = key1;
+    const u32x r2 = key2;
+    const u32x r3 = 0;
+
+    COMPARE_M_SIMD (r0, r1, r2, r3);
+  }
+}
+
+#undef update_key012
+#undef CONST
+#undef CRC32
+#undef MSB
+#undef KEY0INIT
+#undef KEY1INIT
+#undef KEY2INIT
diff --git a/OpenCL/m20500_a3-pure.cl b/OpenCL/m20500_a3-pure.cl
new file mode 100644
index 000000000..4db65fce5
--- /dev/null
+++ b/OpenCL/m20500_a3-pure.cl
@@ -0,0 +1,468 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+  /* for fixed length 3
+  for (u32 pos = pw_len - 1; pos >= 3; pos--)
+  {
+    const u32 t = hc_bfe_S (pws[gid].i[pos / 4], (pos & 3) * 8, 8);
+
+    inv_update_key012 (prep0, prep1, prep2, t, l_icrc32tab);
+  }
+
+  inv_update_key012 (prep0, prep1, prep2, 0, l_icrc32tab);
+
+  prep2 = INVCRC32 (prep2, MSB (prep1), l_icrc32tab);
+  prep1 = (prep1 - 1) * INVCONST;
+
+    key0 = key0 ^ w0c;
+
+    key1 = key1 - (key0 & 0xff);
+    key0 = INVCRC32 (key0, w0b, l_icrc32tab);
+
+    inv_update_key012 (key0, key1, key2, w0a, l_icrc32tab);
+  */
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+
+#define MSB(x)          ((x) >> 24)
+#define CRC32(x,c,t)    (((x) >> 8) ^ (t)[((x) ^ (c)) & 0xff])
+#define CONST           0x08088405
+#define INVCRC32(x,c,t) (((x) << 8) ^ (t)[(x) >> 24] ^ ((c) & 0xff))
+#define INVCONST        0xd94fa8cd
+#define KEY0INIT        0x12345678
+#define KEY1INIT        0x23456789
+#define KEY2INIT        0x34567890
+
+#define inv_update_key012(k0,k1,k2,c,t)         \
+  (k2) = INVCRC32 ((k2), MSB (k1), (t));        \
+  (k1) = ((k1) - 1) * INVCONST - ((k0) & 0xff); \
+  (k0) = INVCRC32 ((k0), (c), (t));
+
+#define update_key012(k0,k1,k2,c,t)           \
+{                                             \
+  (k0) = CRC32 ((k0), c, (t));                \
+  (k1) = ((k1) + ((k0) & 0xff)) * CONST + 1;  \
+  (k2) = CRC32 ((k2), MSB (k1), (t));         \
+}
+
+CONSTANT_VK u32a icrc32tab[256] =
+{
+  0x00000000, 0xdb710641, 0x6d930ac3, 0xb6e20c82,
+  0xdb261586, 0x005713c7, 0xb6b51f45, 0x6dc41904,
+  0x6d3d2d4d, 0xb64c2b0c, 0x00ae278e, 0xdbdf21cf,
+  0xb61b38cb, 0x6d6a3e8a, 0xdb883208, 0x00f93449,
+  0xda7a5a9a, 0x010b5cdb, 0xb7e95059, 0x6c985618,
+  0x015c4f1c, 0xda2d495d, 0x6ccf45df, 0xb7be439e,
+  0xb74777d7, 0x6c367196, 0xdad47d14, 0x01a57b55,
+  0x6c616251, 0xb7106410, 0x01f26892, 0xda836ed3,
+  0x6f85b375, 0xb4f4b534, 0x0216b9b6, 0xd967bff7,
+  0xb4a3a6f3, 0x6fd2a0b2, 0xd930ac30, 0x0241aa71,
+  0x02b89e38, 0xd9c99879, 0x6f2b94fb, 0xb45a92ba,
+  0xd99e8bbe, 0x02ef8dff, 0xb40d817d, 0x6f7c873c,
+  0xb5ffe9ef, 0x6e8eefae, 0xd86ce32c, 0x031de56d,
+  0x6ed9fc69, 0xb5a8fa28, 0x034af6aa, 0xd83bf0eb,
+  0xd8c2c4a2, 0x03b3c2e3, 0xb551ce61, 0x6e20c820,
+  0x03e4d124, 0xd895d765, 0x6e77dbe7, 0xb506dda6,
+  0xdf0b66ea, 0x047a60ab, 0xb2986c29, 0x69e96a68,
+  0x042d736c, 0xdf5c752d, 0x69be79af, 0xb2cf7fee,
+  0xb2364ba7, 0x69474de6, 0xdfa54164, 0x04d44725,
+  0x69105e21, 0xb2615860, 0x048354e2, 0xdff252a3,
+  0x05713c70, 0xde003a31, 0x68e236b3, 0xb39330f2,
+  0xde5729f6, 0x05262fb7, 0xb3c42335, 0x68b52574,
+  0x684c113d, 0xb33d177c, 0x05df1bfe, 0xdeae1dbf,
+  0xb36a04bb, 0x681b02fa, 0xdef90e78, 0x05880839,
+  0xb08ed59f, 0x6bffd3de, 0xdd1ddf5c, 0x066cd91d,
+  0x6ba8c019, 0xb0d9c658, 0x063bcada, 0xdd4acc9b,
+  0xddb3f8d2, 0x06c2fe93, 0xb020f211, 0x6b51f450,
+  0x0695ed54, 0xdde4eb15, 0x6b06e797, 0xb077e1d6,
+  0x6af48f05, 0xb1858944, 0x076785c6, 0xdc168387,
+  0xb1d29a83, 0x6aa39cc2, 0xdc419040, 0x07309601,
+  0x07c9a248, 0xdcb8a409, 0x6a5aa88b, 0xb12baeca,
+  0xdcefb7ce, 0x079eb18f, 0xb17cbd0d, 0x6a0dbb4c,
+  0x6567cb95, 0xbe16cdd4, 0x08f4c156, 0xd385c717,
+  0xbe41de13, 0x6530d852, 0xd3d2d4d0, 0x08a3d291,
+  0x085ae6d8, 0xd32be099, 0x65c9ec1b, 0xbeb8ea5a,
+  0xd37cf35e, 0x080df51f, 0xbeeff99d, 0x659effdc,
+  0xbf1d910f, 0x646c974e, 0xd28e9bcc, 0x09ff9d8d,
+  0x643b8489, 0xbf4a82c8, 0x09a88e4a, 0xd2d9880b,
+  0xd220bc42, 0x0951ba03, 0xbfb3b681, 0x64c2b0c0,
+  0x0906a9c4, 0xd277af85, 0x6495a307, 0xbfe4a546,
+  0x0ae278e0, 0xd1937ea1, 0x67717223, 0xbc007462,
+  0xd1c46d66, 0x0ab56b27, 0xbc5767a5, 0x672661e4,
+  0x67df55ad, 0xbcae53ec, 0x0a4c5f6e, 0xd13d592f,
+  0xbcf9402b, 0x6788466a, 0xd16a4ae8, 0x0a1b4ca9,
+  0xd098227a, 0x0be9243b, 0xbd0b28b9, 0x667a2ef8,
+  0x0bbe37fc, 0xd0cf31bd, 0x662d3d3f, 0xbd5c3b7e,
+  0xbda50f37, 0x66d40976, 0xd03605f4, 0x0b4703b5,
+  0x66831ab1, 0xbdf21cf0, 0x0b101072, 0xd0611633,
+  0xba6cad7f, 0x611dab3e, 0xd7ffa7bc, 0x0c8ea1fd,
+  0x614ab8f9, 0xba3bbeb8, 0x0cd9b23a, 0xd7a8b47b,
+  0xd7518032, 0x0c208673, 0xbac28af1, 0x61b38cb0,
+  0x0c7795b4, 0xd70693f5, 0x61e49f77, 0xba959936,
+  0x6016f7e5, 0xbb67f1a4, 0x0d85fd26, 0xd6f4fb67,
+  0xbb30e263, 0x6041e422, 0xd6a3e8a0, 0x0dd2eee1,
+  0x0d2bdaa8, 0xd65adce9, 0x60b8d06b, 0xbbc9d62a,
+  0xd60dcf2e, 0x0d7cc96f, 0xbb9ec5ed, 0x60efc3ac,
+  0xd5e91e0a, 0x0e98184b, 0xb87a14c9, 0x630b1288,
+  0x0ecf0b8c, 0xd5be0dcd, 0x635c014f, 0xb82d070e,
+  0xb8d43347, 0x63a53506, 0xd5473984, 0x0e363fc5,
+  0x63f226c1, 0xb8832080, 0x0e612c02, 0xd5102a43,
+  0x0f934490, 0xd4e242d1, 0x62004e53, 0xb9714812,
+  0xd4b55116, 0x0fc45757, 0xb9265bd5, 0x62575d94,
+  0x62ae69dd, 0xb9df6f9c, 0x0f3d631e, 0xd44c655f,
+  0xb9887c5b, 0x62f97a1a, 0xd41b7698, 0x0f6a70d9,
+};
+
+CONSTANT_VK u32a crc32tab[256] =
+{
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+KERNEL_FQ void m20500_sxx (KERN_ATTR_VECTOR ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_icrc32tab[256];
+
+  for (u64 i = lid; i < 256; i += lsz)
+  {
+    l_icrc32tab[i] = icrc32tab[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    KEY0INIT, // static initial values
+    KEY1INIT, // should remain unchanged
+    KEY2INIT,
+    0
+  };
+
+  /**
+   * base
+   */
+
+  const u32 pw_len = pws[gid].pw_len;
+
+  /**
+   * reverse
+   */
+
+  u32 prep0 = digests_buf[digests_offset].digest_buf[0];
+  u32 prep1 = digests_buf[digests_offset].digest_buf[1];
+  u32 prep2 = digests_buf[digests_offset].digest_buf[2];
+
+  for (u32 pos = pw_len - 1; pos >= 4; pos--)
+  {
+    const u32 t = hc_bfe_S (pws[gid].i[pos / 4], (pos & 3) * 8, 8);
+
+    inv_update_key012 (prep0, prep1, prep2, t, l_icrc32tab);
+  }
+
+  if (pw_len >= 4)
+  {
+    inv_update_key012 (prep0, prep1, prep2, 0, l_icrc32tab);
+
+    prep2 = INVCRC32 (prep2, MSB (prep1), l_icrc32tab);
+    prep1 = (prep1 - 1) * INVCONST;
+  }
+
+  /**
+   * loop
+   */
+
+  u32 w0l = pws[gid].i[0];
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
+
+    const u32x w0 = w0l | w0r;
+
+    u32x key0 = prep0;
+    u32x key1 = prep1;
+    u32x key2 = prep2;
+
+    const u32x w0a = unpack_v8a_from_v32_S (w0);
+    const u32x w0b = unpack_v8b_from_v32_S (w0);
+    const u32x w0c = unpack_v8c_from_v32_S (w0);
+    const u32x w0d = unpack_v8d_from_v32_S (w0);
+
+    if (pw_len >= 4) key0 = key0 ^ w0d;
+
+    if (pw_len >= 3)
+    {
+      key1 = key1 - (key0 & 0xff);
+      key0 = INVCRC32 (key0, w0c, l_icrc32tab);
+    }
+
+    if (pw_len >= 2)
+    {
+      inv_update_key012 (key0, key1, key2, w0b, l_icrc32tab);
+    }
+
+    if (pw_len >= 1)
+    {
+      inv_update_key012 (key0, key1, key2, w0a, l_icrc32tab);
+    }
+
+    const u32x r0 = key0;
+    const u32x r1 = key1;
+    const u32x r2 = key2;
+    const u32x r3 = 0;
+
+    COMPARE_S_SIMD (r0, r1, r2, r3);
+  }
+}
+
+KERNEL_FQ void m20500_mxx (KERN_ATTR_VECTOR ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (u64 i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * base
+   */
+
+  const u32 pw_len = pws[gid].pw_len;
+
+  u32x w[64] = { 0 };
+
+  for (int i = 0, idx = 0; i < pw_len; i += 4, idx += 1)
+  {
+    w[idx] = pws[gid].i[idx];
+  }
+
+  /**
+   * loop
+   */
+
+  u32 w0l =  w[0];
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
+
+    const u32x w0 = w0l | w0r;
+
+    u32x key0 = KEY0INIT;
+    u32x key1 = KEY1INIT;
+    u32x key2 = KEY2INIT;
+
+    if (pw_len >=  1) update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (w0), l_crc32tab);
+    if (pw_len >=  2) update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (w0), l_crc32tab);
+    if (pw_len >=  3) update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (w0), l_crc32tab);
+    if (pw_len >=  4) update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (w0), l_crc32tab);
+
+    for (u32 i = 4, j = 1; i < pw_len; i += 4, j += 1)
+    {
+      if (pw_len >= (i + 1)) update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (w[j]), l_crc32tab);
+      if (pw_len >= (i + 2)) update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (w[j]), l_crc32tab);
+      if (pw_len >= (i + 3)) update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (w[j]), l_crc32tab);
+      if (pw_len >= (i + 4)) update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (w[j]), l_crc32tab);
+    }
+
+    const u32x r0 = key0;
+    const u32x r1 = key1;
+    const u32x r2 = key2;
+    const u32x r3 = 0;
+
+    COMPARE_M_SIMD (r0, r1, r2, r3);
+  }
+}
+
+#undef inv_update_key012
+#undef INVCONST
+#undef INVCRC32
+#undef MSB
+#undef KEY0INIT
+#undef KEY1INIT
+#undef KEY2INIT
diff --git a/OpenCL/m20510_a0-pure.cl b/OpenCL/m20510_a0-pure.cl
new file mode 100644
index 000000000..8ad51db4d
--- /dev/null
+++ b/OpenCL/m20510_a0-pure.cl
@@ -0,0 +1,630 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+#include "inc_rp.h"
+#include "inc_rp.cl"
+
+typedef struct pkzip_extra
+{
+  u32 buf[2];
+  u32 len;
+
+} pkzip_extra_t;
+
+#define MSB(x)          ((x) >> 24)
+#define CRC32(x,c,t)    (((x) >> 8) ^ (t)[((x) ^ (c)) & 0xff])
+#define INVCRC32(x,c,t) (((x) << 8) ^ (t)[(x) >> 24] ^ ((c) & 0xff))
+#define INVCONST        0xd94fa8cd
+#define KEY0INIT        0x12345678
+#define KEY1INIT        0x23456789
+#define KEY2INIT        0x34567890
+
+#define inv_update_key012(k0,k1,k2,c,t)         \
+  (k2) = INVCRC32 ((k2), MSB (k1), (t));        \
+  (k1) = ((k1) - 1) * INVCONST - ((k0) & 0xff); \
+  (k0) = INVCRC32 ((k0), (c), (t));
+
+CONSTANT_VK u32a crc32tab[256] =
+{
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+CONSTANT_VK u32a icrc32tab[256] =
+{
+  0x00000000, 0xdb710641, 0x6d930ac3, 0xb6e20c82,
+  0xdb261586, 0x005713c7, 0xb6b51f45, 0x6dc41904,
+  0x6d3d2d4d, 0xb64c2b0c, 0x00ae278e, 0xdbdf21cf,
+  0xb61b38cb, 0x6d6a3e8a, 0xdb883208, 0x00f93449,
+  0xda7a5a9a, 0x010b5cdb, 0xb7e95059, 0x6c985618,
+  0x015c4f1c, 0xda2d495d, 0x6ccf45df, 0xb7be439e,
+  0xb74777d7, 0x6c367196, 0xdad47d14, 0x01a57b55,
+  0x6c616251, 0xb7106410, 0x01f26892, 0xda836ed3,
+  0x6f85b375, 0xb4f4b534, 0x0216b9b6, 0xd967bff7,
+  0xb4a3a6f3, 0x6fd2a0b2, 0xd930ac30, 0x0241aa71,
+  0x02b89e38, 0xd9c99879, 0x6f2b94fb, 0xb45a92ba,
+  0xd99e8bbe, 0x02ef8dff, 0xb40d817d, 0x6f7c873c,
+  0xb5ffe9ef, 0x6e8eefae, 0xd86ce32c, 0x031de56d,
+  0x6ed9fc69, 0xb5a8fa28, 0x034af6aa, 0xd83bf0eb,
+  0xd8c2c4a2, 0x03b3c2e3, 0xb551ce61, 0x6e20c820,
+  0x03e4d124, 0xd895d765, 0x6e77dbe7, 0xb506dda6,
+  0xdf0b66ea, 0x047a60ab, 0xb2986c29, 0x69e96a68,
+  0x042d736c, 0xdf5c752d, 0x69be79af, 0xb2cf7fee,
+  0xb2364ba7, 0x69474de6, 0xdfa54164, 0x04d44725,
+  0x69105e21, 0xb2615860, 0x048354e2, 0xdff252a3,
+  0x05713c70, 0xde003a31, 0x68e236b3, 0xb39330f2,
+  0xde5729f6, 0x05262fb7, 0xb3c42335, 0x68b52574,
+  0x684c113d, 0xb33d177c, 0x05df1bfe, 0xdeae1dbf,
+  0xb36a04bb, 0x681b02fa, 0xdef90e78, 0x05880839,
+  0xb08ed59f, 0x6bffd3de, 0xdd1ddf5c, 0x066cd91d,
+  0x6ba8c019, 0xb0d9c658, 0x063bcada, 0xdd4acc9b,
+  0xddb3f8d2, 0x06c2fe93, 0xb020f211, 0x6b51f450,
+  0x0695ed54, 0xdde4eb15, 0x6b06e797, 0xb077e1d6,
+  0x6af48f05, 0xb1858944, 0x076785c6, 0xdc168387,
+  0xb1d29a83, 0x6aa39cc2, 0xdc419040, 0x07309601,
+  0x07c9a248, 0xdcb8a409, 0x6a5aa88b, 0xb12baeca,
+  0xdcefb7ce, 0x079eb18f, 0xb17cbd0d, 0x6a0dbb4c,
+  0x6567cb95, 0xbe16cdd4, 0x08f4c156, 0xd385c717,
+  0xbe41de13, 0x6530d852, 0xd3d2d4d0, 0x08a3d291,
+  0x085ae6d8, 0xd32be099, 0x65c9ec1b, 0xbeb8ea5a,
+  0xd37cf35e, 0x080df51f, 0xbeeff99d, 0x659effdc,
+  0xbf1d910f, 0x646c974e, 0xd28e9bcc, 0x09ff9d8d,
+  0x643b8489, 0xbf4a82c8, 0x09a88e4a, 0xd2d9880b,
+  0xd220bc42, 0x0951ba03, 0xbfb3b681, 0x64c2b0c0,
+  0x0906a9c4, 0xd277af85, 0x6495a307, 0xbfe4a546,
+  0x0ae278e0, 0xd1937ea1, 0x67717223, 0xbc007462,
+  0xd1c46d66, 0x0ab56b27, 0xbc5767a5, 0x672661e4,
+  0x67df55ad, 0xbcae53ec, 0x0a4c5f6e, 0xd13d592f,
+  0xbcf9402b, 0x6788466a, 0xd16a4ae8, 0x0a1b4ca9,
+  0xd098227a, 0x0be9243b, 0xbd0b28b9, 0x667a2ef8,
+  0x0bbe37fc, 0xd0cf31bd, 0x662d3d3f, 0xbd5c3b7e,
+  0xbda50f37, 0x66d40976, 0xd03605f4, 0x0b4703b5,
+  0x66831ab1, 0xbdf21cf0, 0x0b101072, 0xd0611633,
+  0xba6cad7f, 0x611dab3e, 0xd7ffa7bc, 0x0c8ea1fd,
+  0x614ab8f9, 0xba3bbeb8, 0x0cd9b23a, 0xd7a8b47b,
+  0xd7518032, 0x0c208673, 0xbac28af1, 0x61b38cb0,
+  0x0c7795b4, 0xd70693f5, 0x61e49f77, 0xba959936,
+  0x6016f7e5, 0xbb67f1a4, 0x0d85fd26, 0xd6f4fb67,
+  0xbb30e263, 0x6041e422, 0xd6a3e8a0, 0x0dd2eee1,
+  0x0d2bdaa8, 0xd65adce9, 0x60b8d06b, 0xbbc9d62a,
+  0xd60dcf2e, 0x0d7cc96f, 0xbb9ec5ed, 0x60efc3ac,
+  0xd5e91e0a, 0x0e98184b, 0xb87a14c9, 0x630b1288,
+  0x0ecf0b8c, 0xd5be0dcd, 0x635c014f, 0xb82d070e,
+  0xb8d43347, 0x63a53506, 0xd5473984, 0x0e363fc5,
+  0x63f226c1, 0xb8832080, 0x0e612c02, 0xd5102a43,
+  0x0f934490, 0xd4e242d1, 0x62004e53, 0xb9714812,
+  0xd4b55116, 0x0fc45757, 0xb9265bd5, 0x62575d94,
+  0x62ae69dd, 0xb9df6f9c, 0x0f3d631e, 0xd44c655f,
+  0xb9887c5b, 0x62f97a1a, 0xd41b7698, 0x0f6a70d9,
+};
+
+CONSTANT_VK u32a lsbk0[256] =
+{
+  0x00, 0x56, 0xac, 0x21, 0x77, 0xcd, 0x42, 0x98,
+  0xee, 0x0d, 0x63, 0xb9, 0x2e, 0x84, 0xda, 0x4f,
+  0xa5, 0xfb, 0x1a, 0x70, 0xc6, 0x3b, 0x91, 0xe7,
+  0x06, 0x5c, 0xb2, 0x27, 0x7d, 0xd3, 0x48, 0x9e,
+  0xf4, 0x13, 0x69, 0xbf, 0x34, 0x8a, 0xe0, 0x55,
+  0xab, 0x20, 0x76, 0xcc, 0x41, 0x97, 0xed, 0x0c,
+  0x62, 0xb8, 0x2d, 0x83, 0xd9, 0x4e, 0xa4, 0xfa,
+  0x19, 0x6f, 0xc5, 0x3a, 0x90, 0xe6, 0x05, 0x5b,
+  0xb1, 0x26, 0x7c, 0xd2, 0x47, 0x9d, 0xf3, 0x12,
+  0x68, 0xbe, 0x33, 0x89, 0xdf, 0x54, 0xaa, 0x1f,
+  0x75, 0xcb, 0x40, 0x96, 0xec, 0x0b, 0x61, 0xb7,
+  0x2c, 0x82, 0xd8, 0x4d, 0xa3, 0xf9, 0x18, 0x6e,
+  0xc4, 0x39, 0x8f, 0xe5, 0x04, 0x5a, 0xb0, 0x25,
+  0x7b, 0xd1, 0x46, 0x9c, 0xf2, 0x11, 0x67, 0xbd,
+  0x32, 0x88, 0xde, 0x53, 0xa9, 0xff, 0x1e, 0x74,
+  0xca, 0x3f, 0x95, 0xeb, 0x0a, 0x60, 0xb6, 0x2b,
+  0x81, 0xd7, 0x4c, 0xa2, 0xf8, 0x17, 0x6d, 0xc3,
+  0x38, 0x8e, 0xe4, 0x03, 0x59, 0xaf, 0x24, 0x7a,
+  0xd0, 0x45, 0x9b, 0xf1, 0x10, 0x66, 0xbc, 0x31,
+  0x87, 0xdd, 0x52, 0xa8, 0xfe, 0x1d, 0x73, 0xc9,
+  0x3e, 0x94, 0xea, 0x09, 0x5f, 0xb5, 0x2a, 0x80,
+  0xd6, 0x4b, 0xa1, 0xf7, 0x16, 0x6c, 0xc2, 0x37,
+  0x8d, 0xe3, 0x02, 0x58, 0xae, 0x23, 0x79, 0xcf,
+  0x44, 0x9a, 0xf0, 0x0f, 0x65, 0xbb, 0x30, 0x86,
+  0xdc, 0x51, 0xa7, 0xfd, 0x1c, 0x72, 0xc8, 0x3d,
+  0x93, 0xe9, 0x08, 0x5e, 0xb4, 0x29, 0x7f, 0xd5,
+  0x4a, 0xa0, 0xf6, 0x15, 0x6b, 0xc1, 0x36, 0x8c,
+  0xe2, 0x01, 0x57, 0xad, 0x22, 0x78, 0xce, 0x43,
+  0x99, 0xef, 0x0e, 0x64, 0xba, 0x2f, 0x85, 0xdb,
+  0x50, 0xa6, 0xfc, 0x1b, 0x71, 0xc7, 0x3c, 0x92,
+  0xe8, 0x07, 0x5d, 0xb3, 0x28, 0x7e, 0xd4, 0x49,
+  0x9f, 0xf5, 0x14, 0x6a, 0xc0, 0x35, 0x8b, 0xe1
+};
+
+CONSTANT_VK int lsbk0_count0[256] =
+{
+    0,   2,   3,   3,   4,   6,   6,   7,
+    8,   9,  11,  12,  12,  13,  15,  15,
+   16,  17,  18,  20,  21,  21,  22,  24,
+   25,  26,  27,  27,  29,  30,  30,  31,
+   33,  34,  35,  36,  36,  38,  39,  39,
+   40,  41,  42,  43,  44,  44,  46,  47,
+   48,  49,  50,  50,  52,  53,  53,  54,
+   56,  57,  58,  59,  59,  61,  62,  63,
+   64,  65,  66,  67,  68,  68,  70,  71,
+   72,  73,  74,  75,  76,  77,  77,  79,
+   79,  80,  81,  82,  83,  84,  85,  86,
+   88,  88,  89,  90,  91,  92,  93,  94,
+   95,  97,  97,  98,  99, 100, 101, 103,
+  103, 104, 105, 106, 107, 108, 109, 110,
+  112, 112, 113, 114, 115, 116, 117, 118,
+  119, 121, 121, 122, 123, 124, 126, 127,
+  127, 128, 130, 130, 131, 132, 133, 135,
+  136, 136, 137, 139, 140, 141, 142, 142,
+  144, 145, 145, 146, 148, 149, 150, 151,
+  151, 152, 154, 154, 155, 156, 157, 159,
+  160, 160, 161, 163, 164, 165, 166, 166,
+  168, 169, 169, 170, 172, 173, 174, 175,
+  175, 177, 178, 179, 180, 181, 182, 183,
+  184, 184, 186, 187, 188, 189, 190, 191,
+  192, 193, 193, 195, 196, 197, 198, 199,
+  200, 201, 202, 203, 204, 205, 206, 207,
+  208, 208, 210, 211, 212, 213, 214, 215,
+  216, 217, 218, 220, 220, 221, 222, 223,
+  224, 225, 226, 227, 229, 229, 230, 231,
+  232, 233, 234, 235, 236, 238, 238, 239,
+  240, 241, 243, 244, 244, 245, 247, 247,
+  248, 249, 250, 252, 253, 253, 254, 255
+};
+
+CONSTANT_VK int lsbk0_count1[256] =
+{
+    2,   3,   3,   4,   6,   6,   7,   8,
+    9,  11,  12,  12,  13,  15,  15,  16,
+   17,  18,  20,  21,  21,  22,  24,  25,
+   26,  27,  27,  29,  30,  30,  31,  33,
+   34,  35,  36,  36,  38,  39,  39,  40,
+   41,  42,  43,  44,  44,  46,  47,  48,
+   49,  50,  50,  52,  53,  53,  54,  56,
+   57,  58,  59,  59,  61,  62,  63,  64,
+   65,  66,  67,  68,  68,  70,  71,  72,
+   73,  74,  75,  76,  77,  77,  79,  79,
+   80,  81,  82,  83,  84,  85,  86,  88,
+   88,  89,  90,  91,  92,  93,  94,  95,
+   97,  97,  98,  99, 100, 101, 103, 103,
+  104, 105, 106, 107, 108, 109, 110, 112,
+  112, 113, 114, 115, 116, 117, 118, 119,
+  121, 121, 122, 123, 124, 126, 127, 127,
+  128, 130, 130, 131, 132, 133, 135, 136,
+  136, 137, 139, 140, 141, 142, 142, 144,
+  145, 145, 146, 148, 149, 150, 151, 151,
+  152, 154, 154, 155, 156, 157, 159, 160,
+  160, 161, 163, 164, 165, 166, 166, 168,
+  169, 169, 170, 172, 173, 174, 175, 175,
+  177, 178, 179, 180, 181, 182, 183, 184,
+  184, 186, 187, 188, 189, 190, 191, 192,
+  193, 193, 195, 196, 197, 198, 199, 200,
+  201, 202, 203, 204, 205, 206, 207, 208,
+  208, 210, 211, 212, 213, 214, 215, 216,
+  217, 218, 220, 220, 221, 222, 223, 224,
+  225, 226, 227, 229, 229, 230, 231, 232,
+  233, 234, 235, 236, 238, 238, 239, 240,
+  241, 243, 244, 244, 245, 247, 247, 248,
+  249, 250, 252, 253, 253, 254, 255, 256
+};
+
+DECLSPEC int derivelast6bytes (const u32x k0, const u32x k1, const u32x k2, u32 *password, LOCAL_AS u32 *l_crc32tab, LOCAL_AS u32 *l_icrc32tab, LOCAL_AS u32 *l_lsbk0, LOCAL_AS int *l_lsbk0_count0, LOCAL_AS int *l_lsbk0_count1)
+{
+  // step 1
+  const u32 k2_1 = INVCRC32 (k2,   (k1   >> 24), l_icrc32tab);
+  const u32 k1_1 = (k1 - 1) * INVCONST - (k0 & 0xff);
+  const u32 k2_2 = INVCRC32 (k2_1, (k1_1 >> 24), l_icrc32tab);
+
+  // step 2
+  u32 k2_3 = INVCRC32 (k2_2, 0, l_icrc32tab);
+  u32 k2_4 = INVCRC32 (k2_3, 0, l_icrc32tab);
+  u32 k2_5 = INVCRC32 (k2_4, 0, l_icrc32tab);
+
+  // step 3
+  const u32 k1_5 = ((u32)((0x90)        ^ l_icrc32tab[(k2_5 >> 24)])) << 24;
+            k2_5 = CRC32 (KEY2INIT, (k1_5 >> 24), l_crc32tab);
+  const u32 k1_4 = ((u32)((k2_5 & 0xFF) ^ l_icrc32tab[(k2_4 >> 24)])) << 24;
+            k2_4 = CRC32 (k2_5    , (k1_4 >> 24), l_crc32tab);
+  const u32 k1_3 = ((u32)((k2_4 & 0xFF) ^ l_icrc32tab[(k2_3 >> 24)])) << 24;
+            k2_3 = CRC32 (k2_4    , (k1_3 >> 24), l_crc32tab);
+  const u32 k1_2 = ((u32)((k2_3 & 0xFF) ^ l_icrc32tab[(k2_2 >> 24)])) << 24;
+
+  // step 5.2
+
+  #define IDX(x) ((x) & 0xff)
+
+  const u32 rhs_step1_0 = (k1_1 - 1) * INVCONST;
+
+  u32 diff0 = ((rhs_step1_0 - 1) * INVCONST - (k1_3 & 0xff000000)) >> 24;
+
+  for (int c0 = 0; c0 < 2; c0++, diff0--)
+  {
+    for (int i0 = l_lsbk0_count0[IDX (diff0)]; i0 < l_lsbk0_count1[IDX (diff0)]; i0++)
+    {
+      if (((rhs_step1_0 - l_lsbk0[i0]) >> 24) != (k1_2 >> 24)) continue;
+
+      const u32 rhs_step1_1 = (rhs_step1_0 - l_lsbk0[i0] - 1) * INVCONST;
+
+      u32 diff1 = ((rhs_step1_1 - 1) * INVCONST - (k1_4 & 0xff000000)) >> 24;
+
+      for (int c1 = 0; c1 < 2; c1++, diff1--)
+      {
+        for (int i1 = l_lsbk0_count0[IDX (diff1)]; i1 < l_lsbk0_count1[IDX (diff1)]; i1++)
+        {
+          if (((rhs_step1_1 - l_lsbk0[i1]) >> 24) != (k1_3 >> 24)) continue;
+
+          const u32 rhs_step1_2 = (rhs_step1_1 - l_lsbk0[i1] - 1) * INVCONST;
+
+          u32 diff2 = ((rhs_step1_2 - 1) * INVCONST - (k1_5 & 0xff000000)) >> 24;
+
+          for (int c2 = 0; c2 < 2; c2++, diff2--)
+          {
+            for (int i2 = l_lsbk0_count0[IDX (diff2)]; i2 < l_lsbk0_count1[IDX (diff2)]; i2++)
+            {
+              if (((rhs_step1_2 - l_lsbk0[i2]) >> 24) != (k1_4 >> 24)) continue;
+
+              const u32 rhs_step1_3 = (rhs_step1_2 - l_lsbk0[i2] - 1) * INVCONST;
+
+              u32 diff3 = ((rhs_step1_3 - 1) * INVCONST - (0x23000000)) >> 24;
+
+              for (int c3 = 0; c3 < 2; c3++, diff3--)
+              {
+                for (int i3 = l_lsbk0_count0[IDX (diff3)]; i3 < l_lsbk0_count1[IDX (diff3)]; i3++)
+                {
+                  if (((rhs_step1_3 - l_lsbk0[i3]) >> 24) != (k1_5 >> 24)) continue;
+
+                  const u32 rhs_step1_4 = (rhs_step1_3 - l_lsbk0[i3] - 1) * INVCONST;
+
+                  u32 diff4 = ((rhs_step1_4 - 1) * INVCONST - (0x05000000)) >> 24;
+
+                  for (int c4 = 0; c4 < 2; c4++, diff4--)
+                  {
+                    for (int i4 = l_lsbk0_count0[IDX (diff4)]; i4 < l_lsbk0_count1[IDX (diff4)]; i4++)
+                    {
+                      if ((rhs_step1_4 - l_lsbk0[i4]) != KEY1INIT) continue;
+
+                      u32 kk;
+
+                      u32 t5 = ((l_lsbk0[i0]) ^ l_icrc32tab[k0 >> 24]) & 0xff;
+
+                      kk = INVCRC32 (k0, t5, l_icrc32tab);
+
+                      u32 t4 = ((l_lsbk0[i1]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t4, l_icrc32tab);
+
+                      u32 t3 = ((l_lsbk0[i2]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t3, l_icrc32tab);
+
+                      u32 t2 = ((l_lsbk0[i3]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t2, l_icrc32tab);
+
+                      u32 t1 = ((l_lsbk0[i4]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t1, l_icrc32tab);
+
+                      u32 t0 = ((KEY0INIT)    ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      if (INVCRC32 (kk, t0, l_icrc32tab) == KEY0INIT)
+                      {
+                        // found
+
+                        password[0] = t0 <<  0
+                                    | t1 <<  8
+                                    | t2 << 16
+                                    | t3 << 24;
+
+                        password[1] = t4 <<  0
+                                    | t5 <<  8;
+
+                        return 1;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  #undef IDX0
+  #undef IDX1
+
+  // not found
+
+  return 0;
+}
+
+KERNEL_FQ void m20510_sxx (KERN_ATTR_RULES ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  LOCAL_VK u32 l_icrc32tab[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_icrc32tab[i] = icrc32tab[i];
+  }
+
+  LOCAL_VK u32 l_lsbk0[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_lsbk0[i] = lsbk0[i];
+  }
+
+  LOCAL_VK int l_lsbk0_count0[256];
+  LOCAL_VK int l_lsbk0_count1[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_lsbk0_count0[i] = lsbk0_count0[i];
+    l_lsbk0_count1[i] = lsbk0_count1[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    KEY0INIT, // static initial values
+    KEY1INIT, // should remain unchanged
+    KEY2INIT,
+    0
+  };
+
+  /**
+   * base
+   */
+
+  COPY_PW (pws[gid]);
+
+  /**
+   * reverse
+   */
+
+  u32 prep0 = hc_swap32_S (digests_buf[digests_offset].digest_buf[0]);
+  u32 prep1 = hc_swap32_S (digests_buf[digests_offset].digest_buf[1]);
+  u32 prep2 = hc_swap32_S (digests_buf[digests_offset].digest_buf[2]);
+
+  /**
+   * loop
+   */
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    pw_t t = PASTE_PW;
+
+    t.pw_len = apply_rules (rules_buf[il_pos].cmds, t.i, t.pw_len);
+
+    u32x key0 = prep0;
+    u32x key1 = prep1;
+    u32x key2 = prep2;
+
+    for (int pos = t.pw_len - 1; pos >= 0; pos--)
+    {
+      const u32 tt = hc_bfe_S (t.i[pos / 4], (pos & 3) * 8, 8);
+
+      inv_update_key012 (key0, key1, key2, tt, l_icrc32tab);
+    }
+
+    u32 password[2];
+
+    if (derivelast6bytes (key0, key1, key2, password, l_crc32tab, l_icrc32tab, l_lsbk0, l_lsbk0_count0, l_lsbk0_count1) == 1)
+    {
+      GLOBAL_AS pkzip_extra_t *pkzip_extra = (GLOBAL_AS pkzip_extra_t *) tmps;
+
+      pkzip_extra[gid].buf[0] = password[0];
+      pkzip_extra[gid].buf[1] = password[1];
+
+      pkzip_extra[gid].len = 6;
+
+      const u32x r0 = KEY0INIT;
+      const u32x r1 = KEY1INIT;
+      const u32x r2 = KEY2INIT;
+      const u32x r3 = 0;
+
+      COMPARE_S_SIMD (r0, r1, r2, r3);
+    }
+  }
+}
+
+KERNEL_FQ void m20510_mxx (KERN_ATTR_RULES ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * NOT AVAILABLE
+   */
+}
+
+#undef MSB
+#undef CRC32
+#undef INVCRC32
+#undef INVCONST
+#undef KEY0INIT
+#undef KEY1INIT
+#undef KEY2INIT
+#undef inv_update_key012
diff --git a/OpenCL/m20510_a1-pure.cl b/OpenCL/m20510_a1-pure.cl
new file mode 100644
index 000000000..32e15cab7
--- /dev/null
+++ b/OpenCL/m20510_a1-pure.cl
@@ -0,0 +1,634 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+
+typedef struct pkzip_extra
+{
+  u32 buf[2];
+  u32 len;
+
+} pkzip_extra_t;
+
+#define MSB(x)          ((x) >> 24)
+#define CRC32(x,c,t)    (((x) >> 8) ^ (t)[((x) ^ (c)) & 0xff])
+#define INVCRC32(x,c,t) (((x) << 8) ^ (t)[(x) >> 24] ^ ((c) & 0xff))
+#define INVCONST        0xd94fa8cd
+#define KEY0INIT        0x12345678
+#define KEY1INIT        0x23456789
+#define KEY2INIT        0x34567890
+
+#define inv_update_key012(k0,k1,k2,c,t)         \
+  (k2) = INVCRC32 ((k2), MSB (k1), (t));        \
+  (k1) = ((k1) - 1) * INVCONST - ((k0) & 0xff); \
+  (k0) = INVCRC32 ((k0), (c), (t));
+
+CONSTANT_VK u32a crc32tab[256] =
+{
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+CONSTANT_VK u32a icrc32tab[256] =
+{
+  0x00000000, 0xdb710641, 0x6d930ac3, 0xb6e20c82,
+  0xdb261586, 0x005713c7, 0xb6b51f45, 0x6dc41904,
+  0x6d3d2d4d, 0xb64c2b0c, 0x00ae278e, 0xdbdf21cf,
+  0xb61b38cb, 0x6d6a3e8a, 0xdb883208, 0x00f93449,
+  0xda7a5a9a, 0x010b5cdb, 0xb7e95059, 0x6c985618,
+  0x015c4f1c, 0xda2d495d, 0x6ccf45df, 0xb7be439e,
+  0xb74777d7, 0x6c367196, 0xdad47d14, 0x01a57b55,
+  0x6c616251, 0xb7106410, 0x01f26892, 0xda836ed3,
+  0x6f85b375, 0xb4f4b534, 0x0216b9b6, 0xd967bff7,
+  0xb4a3a6f3, 0x6fd2a0b2, 0xd930ac30, 0x0241aa71,
+  0x02b89e38, 0xd9c99879, 0x6f2b94fb, 0xb45a92ba,
+  0xd99e8bbe, 0x02ef8dff, 0xb40d817d, 0x6f7c873c,
+  0xb5ffe9ef, 0x6e8eefae, 0xd86ce32c, 0x031de56d,
+  0x6ed9fc69, 0xb5a8fa28, 0x034af6aa, 0xd83bf0eb,
+  0xd8c2c4a2, 0x03b3c2e3, 0xb551ce61, 0x6e20c820,
+  0x03e4d124, 0xd895d765, 0x6e77dbe7, 0xb506dda6,
+  0xdf0b66ea, 0x047a60ab, 0xb2986c29, 0x69e96a68,
+  0x042d736c, 0xdf5c752d, 0x69be79af, 0xb2cf7fee,
+  0xb2364ba7, 0x69474de6, 0xdfa54164, 0x04d44725,
+  0x69105e21, 0xb2615860, 0x048354e2, 0xdff252a3,
+  0x05713c70, 0xde003a31, 0x68e236b3, 0xb39330f2,
+  0xde5729f6, 0x05262fb7, 0xb3c42335, 0x68b52574,
+  0x684c113d, 0xb33d177c, 0x05df1bfe, 0xdeae1dbf,
+  0xb36a04bb, 0x681b02fa, 0xdef90e78, 0x05880839,
+  0xb08ed59f, 0x6bffd3de, 0xdd1ddf5c, 0x066cd91d,
+  0x6ba8c019, 0xb0d9c658, 0x063bcada, 0xdd4acc9b,
+  0xddb3f8d2, 0x06c2fe93, 0xb020f211, 0x6b51f450,
+  0x0695ed54, 0xdde4eb15, 0x6b06e797, 0xb077e1d6,
+  0x6af48f05, 0xb1858944, 0x076785c6, 0xdc168387,
+  0xb1d29a83, 0x6aa39cc2, 0xdc419040, 0x07309601,
+  0x07c9a248, 0xdcb8a409, 0x6a5aa88b, 0xb12baeca,
+  0xdcefb7ce, 0x079eb18f, 0xb17cbd0d, 0x6a0dbb4c,
+  0x6567cb95, 0xbe16cdd4, 0x08f4c156, 0xd385c717,
+  0xbe41de13, 0x6530d852, 0xd3d2d4d0, 0x08a3d291,
+  0x085ae6d8, 0xd32be099, 0x65c9ec1b, 0xbeb8ea5a,
+  0xd37cf35e, 0x080df51f, 0xbeeff99d, 0x659effdc,
+  0xbf1d910f, 0x646c974e, 0xd28e9bcc, 0x09ff9d8d,
+  0x643b8489, 0xbf4a82c8, 0x09a88e4a, 0xd2d9880b,
+  0xd220bc42, 0x0951ba03, 0xbfb3b681, 0x64c2b0c0,
+  0x0906a9c4, 0xd277af85, 0x6495a307, 0xbfe4a546,
+  0x0ae278e0, 0xd1937ea1, 0x67717223, 0xbc007462,
+  0xd1c46d66, 0x0ab56b27, 0xbc5767a5, 0x672661e4,
+  0x67df55ad, 0xbcae53ec, 0x0a4c5f6e, 0xd13d592f,
+  0xbcf9402b, 0x6788466a, 0xd16a4ae8, 0x0a1b4ca9,
+  0xd098227a, 0x0be9243b, 0xbd0b28b9, 0x667a2ef8,
+  0x0bbe37fc, 0xd0cf31bd, 0x662d3d3f, 0xbd5c3b7e,
+  0xbda50f37, 0x66d40976, 0xd03605f4, 0x0b4703b5,
+  0x66831ab1, 0xbdf21cf0, 0x0b101072, 0xd0611633,
+  0xba6cad7f, 0x611dab3e, 0xd7ffa7bc, 0x0c8ea1fd,
+  0x614ab8f9, 0xba3bbeb8, 0x0cd9b23a, 0xd7a8b47b,
+  0xd7518032, 0x0c208673, 0xbac28af1, 0x61b38cb0,
+  0x0c7795b4, 0xd70693f5, 0x61e49f77, 0xba959936,
+  0x6016f7e5, 0xbb67f1a4, 0x0d85fd26, 0xd6f4fb67,
+  0xbb30e263, 0x6041e422, 0xd6a3e8a0, 0x0dd2eee1,
+  0x0d2bdaa8, 0xd65adce9, 0x60b8d06b, 0xbbc9d62a,
+  0xd60dcf2e, 0x0d7cc96f, 0xbb9ec5ed, 0x60efc3ac,
+  0xd5e91e0a, 0x0e98184b, 0xb87a14c9, 0x630b1288,
+  0x0ecf0b8c, 0xd5be0dcd, 0x635c014f, 0xb82d070e,
+  0xb8d43347, 0x63a53506, 0xd5473984, 0x0e363fc5,
+  0x63f226c1, 0xb8832080, 0x0e612c02, 0xd5102a43,
+  0x0f934490, 0xd4e242d1, 0x62004e53, 0xb9714812,
+  0xd4b55116, 0x0fc45757, 0xb9265bd5, 0x62575d94,
+  0x62ae69dd, 0xb9df6f9c, 0x0f3d631e, 0xd44c655f,
+  0xb9887c5b, 0x62f97a1a, 0xd41b7698, 0x0f6a70d9,
+};
+
+CONSTANT_VK u32a lsbk0[256] =
+{
+  0x00, 0x56, 0xac, 0x21, 0x77, 0xcd, 0x42, 0x98,
+  0xee, 0x0d, 0x63, 0xb9, 0x2e, 0x84, 0xda, 0x4f,
+  0xa5, 0xfb, 0x1a, 0x70, 0xc6, 0x3b, 0x91, 0xe7,
+  0x06, 0x5c, 0xb2, 0x27, 0x7d, 0xd3, 0x48, 0x9e,
+  0xf4, 0x13, 0x69, 0xbf, 0x34, 0x8a, 0xe0, 0x55,
+  0xab, 0x20, 0x76, 0xcc, 0x41, 0x97, 0xed, 0x0c,
+  0x62, 0xb8, 0x2d, 0x83, 0xd9, 0x4e, 0xa4, 0xfa,
+  0x19, 0x6f, 0xc5, 0x3a, 0x90, 0xe6, 0x05, 0x5b,
+  0xb1, 0x26, 0x7c, 0xd2, 0x47, 0x9d, 0xf3, 0x12,
+  0x68, 0xbe, 0x33, 0x89, 0xdf, 0x54, 0xaa, 0x1f,
+  0x75, 0xcb, 0x40, 0x96, 0xec, 0x0b, 0x61, 0xb7,
+  0x2c, 0x82, 0xd8, 0x4d, 0xa3, 0xf9, 0x18, 0x6e,
+  0xc4, 0x39, 0x8f, 0xe5, 0x04, 0x5a, 0xb0, 0x25,
+  0x7b, 0xd1, 0x46, 0x9c, 0xf2, 0x11, 0x67, 0xbd,
+  0x32, 0x88, 0xde, 0x53, 0xa9, 0xff, 0x1e, 0x74,
+  0xca, 0x3f, 0x95, 0xeb, 0x0a, 0x60, 0xb6, 0x2b,
+  0x81, 0xd7, 0x4c, 0xa2, 0xf8, 0x17, 0x6d, 0xc3,
+  0x38, 0x8e, 0xe4, 0x03, 0x59, 0xaf, 0x24, 0x7a,
+  0xd0, 0x45, 0x9b, 0xf1, 0x10, 0x66, 0xbc, 0x31,
+  0x87, 0xdd, 0x52, 0xa8, 0xfe, 0x1d, 0x73, 0xc9,
+  0x3e, 0x94, 0xea, 0x09, 0x5f, 0xb5, 0x2a, 0x80,
+  0xd6, 0x4b, 0xa1, 0xf7, 0x16, 0x6c, 0xc2, 0x37,
+  0x8d, 0xe3, 0x02, 0x58, 0xae, 0x23, 0x79, 0xcf,
+  0x44, 0x9a, 0xf0, 0x0f, 0x65, 0xbb, 0x30, 0x86,
+  0xdc, 0x51, 0xa7, 0xfd, 0x1c, 0x72, 0xc8, 0x3d,
+  0x93, 0xe9, 0x08, 0x5e, 0xb4, 0x29, 0x7f, 0xd5,
+  0x4a, 0xa0, 0xf6, 0x15, 0x6b, 0xc1, 0x36, 0x8c,
+  0xe2, 0x01, 0x57, 0xad, 0x22, 0x78, 0xce, 0x43,
+  0x99, 0xef, 0x0e, 0x64, 0xba, 0x2f, 0x85, 0xdb,
+  0x50, 0xa6, 0xfc, 0x1b, 0x71, 0xc7, 0x3c, 0x92,
+  0xe8, 0x07, 0x5d, 0xb3, 0x28, 0x7e, 0xd4, 0x49,
+  0x9f, 0xf5, 0x14, 0x6a, 0xc0, 0x35, 0x8b, 0xe1
+};
+
+CONSTANT_VK int lsbk0_count0[256] =
+{
+    0,   2,   3,   3,   4,   6,   6,   7,
+    8,   9,  11,  12,  12,  13,  15,  15,
+   16,  17,  18,  20,  21,  21,  22,  24,
+   25,  26,  27,  27,  29,  30,  30,  31,
+   33,  34,  35,  36,  36,  38,  39,  39,
+   40,  41,  42,  43,  44,  44,  46,  47,
+   48,  49,  50,  50,  52,  53,  53,  54,
+   56,  57,  58,  59,  59,  61,  62,  63,
+   64,  65,  66,  67,  68,  68,  70,  71,
+   72,  73,  74,  75,  76,  77,  77,  79,
+   79,  80,  81,  82,  83,  84,  85,  86,
+   88,  88,  89,  90,  91,  92,  93,  94,
+   95,  97,  97,  98,  99, 100, 101, 103,
+  103, 104, 105, 106, 107, 108, 109, 110,
+  112, 112, 113, 114, 115, 116, 117, 118,
+  119, 121, 121, 122, 123, 124, 126, 127,
+  127, 128, 130, 130, 131, 132, 133, 135,
+  136, 136, 137, 139, 140, 141, 142, 142,
+  144, 145, 145, 146, 148, 149, 150, 151,
+  151, 152, 154, 154, 155, 156, 157, 159,
+  160, 160, 161, 163, 164, 165, 166, 166,
+  168, 169, 169, 170, 172, 173, 174, 175,
+  175, 177, 178, 179, 180, 181, 182, 183,
+  184, 184, 186, 187, 188, 189, 190, 191,
+  192, 193, 193, 195, 196, 197, 198, 199,
+  200, 201, 202, 203, 204, 205, 206, 207,
+  208, 208, 210, 211, 212, 213, 214, 215,
+  216, 217, 218, 220, 220, 221, 222, 223,
+  224, 225, 226, 227, 229, 229, 230, 231,
+  232, 233, 234, 235, 236, 238, 238, 239,
+  240, 241, 243, 244, 244, 245, 247, 247,
+  248, 249, 250, 252, 253, 253, 254, 255
+};
+
+CONSTANT_VK int lsbk0_count1[256] =
+{
+    2,   3,   3,   4,   6,   6,   7,   8,
+    9,  11,  12,  12,  13,  15,  15,  16,
+   17,  18,  20,  21,  21,  22,  24,  25,
+   26,  27,  27,  29,  30,  30,  31,  33,
+   34,  35,  36,  36,  38,  39,  39,  40,
+   41,  42,  43,  44,  44,  46,  47,  48,
+   49,  50,  50,  52,  53,  53,  54,  56,
+   57,  58,  59,  59,  61,  62,  63,  64,
+   65,  66,  67,  68,  68,  70,  71,  72,
+   73,  74,  75,  76,  77,  77,  79,  79,
+   80,  81,  82,  83,  84,  85,  86,  88,
+   88,  89,  90,  91,  92,  93,  94,  95,
+   97,  97,  98,  99, 100, 101, 103, 103,
+  104, 105, 106, 107, 108, 109, 110, 112,
+  112, 113, 114, 115, 116, 117, 118, 119,
+  121, 121, 122, 123, 124, 126, 127, 127,
+  128, 130, 130, 131, 132, 133, 135, 136,
+  136, 137, 139, 140, 141, 142, 142, 144,
+  145, 145, 146, 148, 149, 150, 151, 151,
+  152, 154, 154, 155, 156, 157, 159, 160,
+  160, 161, 163, 164, 165, 166, 166, 168,
+  169, 169, 170, 172, 173, 174, 175, 175,
+  177, 178, 179, 180, 181, 182, 183, 184,
+  184, 186, 187, 188, 189, 190, 191, 192,
+  193, 193, 195, 196, 197, 198, 199, 200,
+  201, 202, 203, 204, 205, 206, 207, 208,
+  208, 210, 211, 212, 213, 214, 215, 216,
+  217, 218, 220, 220, 221, 222, 223, 224,
+  225, 226, 227, 229, 229, 230, 231, 232,
+  233, 234, 235, 236, 238, 238, 239, 240,
+  241, 243, 244, 244, 245, 247, 247, 248,
+  249, 250, 252, 253, 253, 254, 255, 256
+};
+
+DECLSPEC int derivelast6bytes (const u32x k0, const u32x k1, const u32x k2, u32 *password, LOCAL_AS u32 *l_crc32tab, LOCAL_AS u32 *l_icrc32tab, LOCAL_AS u32 *l_lsbk0, LOCAL_AS int *l_lsbk0_count0, LOCAL_AS int *l_lsbk0_count1)
+{
+  // step 1
+  const u32 k2_1 = INVCRC32 (k2,   (k1   >> 24), l_icrc32tab);
+  const u32 k1_1 = (k1 - 1) * INVCONST - (k0 & 0xff);
+  const u32 k2_2 = INVCRC32 (k2_1, (k1_1 >> 24), l_icrc32tab);
+
+  // step 2
+  u32 k2_3 = INVCRC32 (k2_2, 0, l_icrc32tab);
+  u32 k2_4 = INVCRC32 (k2_3, 0, l_icrc32tab);
+  u32 k2_5 = INVCRC32 (k2_4, 0, l_icrc32tab);
+
+  // step 3
+  const u32 k1_5 = ((u32)((0x90)        ^ l_icrc32tab[(k2_5 >> 24)])) << 24;
+            k2_5 = CRC32 (KEY2INIT, (k1_5 >> 24), l_crc32tab);
+  const u32 k1_4 = ((u32)((k2_5 & 0xFF) ^ l_icrc32tab[(k2_4 >> 24)])) << 24;
+            k2_4 = CRC32 (k2_5    , (k1_4 >> 24), l_crc32tab);
+  const u32 k1_3 = ((u32)((k2_4 & 0xFF) ^ l_icrc32tab[(k2_3 >> 24)])) << 24;
+            k2_3 = CRC32 (k2_4    , (k1_3 >> 24), l_crc32tab);
+  const u32 k1_2 = ((u32)((k2_3 & 0xFF) ^ l_icrc32tab[(k2_2 >> 24)])) << 24;
+
+  // step 5.2
+
+  #define IDX(x) ((x) & 0xff)
+
+  const u32 rhs_step1_0 = (k1_1 - 1) * INVCONST;
+
+  u32 diff0 = ((rhs_step1_0 - 1) * INVCONST - (k1_3 & 0xff000000)) >> 24;
+
+  for (int c0 = 0; c0 < 2; c0++, diff0--)
+  {
+    for (int i0 = l_lsbk0_count0[IDX (diff0)]; i0 < l_lsbk0_count1[IDX (diff0)]; i0++)
+    {
+      if (((rhs_step1_0 - l_lsbk0[i0]) >> 24) != (k1_2 >> 24)) continue;
+
+      const u32 rhs_step1_1 = (rhs_step1_0 - l_lsbk0[i0] - 1) * INVCONST;
+
+      u32 diff1 = ((rhs_step1_1 - 1) * INVCONST - (k1_4 & 0xff000000)) >> 24;
+
+      for (int c1 = 0; c1 < 2; c1++, diff1--)
+      {
+        for (int i1 = l_lsbk0_count0[IDX (diff1)]; i1 < l_lsbk0_count1[IDX (diff1)]; i1++)
+        {
+          if (((rhs_step1_1 - l_lsbk0[i1]) >> 24) != (k1_3 >> 24)) continue;
+
+          const u32 rhs_step1_2 = (rhs_step1_1 - l_lsbk0[i1] - 1) * INVCONST;
+
+          u32 diff2 = ((rhs_step1_2 - 1) * INVCONST - (k1_5 & 0xff000000)) >> 24;
+
+          for (int c2 = 0; c2 < 2; c2++, diff2--)
+          {
+            for (int i2 = l_lsbk0_count0[IDX (diff2)]; i2 < l_lsbk0_count1[IDX (diff2)]; i2++)
+            {
+              if (((rhs_step1_2 - l_lsbk0[i2]) >> 24) != (k1_4 >> 24)) continue;
+
+              const u32 rhs_step1_3 = (rhs_step1_2 - l_lsbk0[i2] - 1) * INVCONST;
+
+              u32 diff3 = ((rhs_step1_3 - 1) * INVCONST - (0x23000000)) >> 24;
+
+              for (int c3 = 0; c3 < 2; c3++, diff3--)
+              {
+                for (int i3 = l_lsbk0_count0[IDX (diff3)]; i3 < l_lsbk0_count1[IDX (diff3)]; i3++)
+                {
+                  if (((rhs_step1_3 - l_lsbk0[i3]) >> 24) != (k1_5 >> 24)) continue;
+
+                  const u32 rhs_step1_4 = (rhs_step1_3 - l_lsbk0[i3] - 1) * INVCONST;
+
+                  u32 diff4 = ((rhs_step1_4 - 1) * INVCONST - (0x05000000)) >> 24;
+
+                  for (int c4 = 0; c4 < 2; c4++, diff4--)
+                  {
+                    for (int i4 = l_lsbk0_count0[IDX (diff4)]; i4 < l_lsbk0_count1[IDX (diff4)]; i4++)
+                    {
+                      if ((rhs_step1_4 - l_lsbk0[i4]) != KEY1INIT) continue;
+
+                      u32 kk;
+
+                      u32 t5 = ((l_lsbk0[i0]) ^ l_icrc32tab[k0 >> 24]) & 0xff;
+
+                      kk = INVCRC32 (k0, t5, l_icrc32tab);
+
+                      u32 t4 = ((l_lsbk0[i1]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t4, l_icrc32tab);
+
+                      u32 t3 = ((l_lsbk0[i2]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t3, l_icrc32tab);
+
+                      u32 t2 = ((l_lsbk0[i3]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t2, l_icrc32tab);
+
+                      u32 t1 = ((l_lsbk0[i4]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t1, l_icrc32tab);
+
+                      u32 t0 = ((KEY0INIT)    ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      if (INVCRC32 (kk, t0, l_icrc32tab) == KEY0INIT)
+                      {
+                        // found
+
+                        password[0] = t0 <<  0
+                                    | t1 <<  8
+                                    | t2 << 16
+                                    | t3 << 24;
+
+                        password[1] = t4 <<  0
+                                    | t5 <<  8;
+
+                        return 1;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  #undef IDX0
+  #undef IDX1
+
+  // not found
+
+  return 0;
+}
+
+KERNEL_FQ void m20510_sxx (KERN_ATTR_BASIC ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  LOCAL_VK u32 l_icrc32tab[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_icrc32tab[i] = icrc32tab[i];
+  }
+
+  LOCAL_VK u32 l_lsbk0[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_lsbk0[i] = lsbk0[i];
+  }
+
+  LOCAL_VK int l_lsbk0_count0[256];
+  LOCAL_VK int l_lsbk0_count1[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_lsbk0_count0[i] = lsbk0_count0[i];
+    l_lsbk0_count1[i] = lsbk0_count1[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    KEY0INIT, // static initial values
+    KEY1INIT, // should remain unchanged
+    KEY2INIT,
+    0
+  };
+
+  /**
+   * reverse
+   */
+
+  u32 prep0 = hc_swap32_S (digests_buf[digests_offset].digest_buf[0]);
+  u32 prep1 = hc_swap32_S (digests_buf[digests_offset].digest_buf[1]);
+  u32 prep2 = hc_swap32_S (digests_buf[digests_offset].digest_buf[2]);
+
+  /**
+   * loop
+   */
+
+  u32 pws_pw_len = pws[gid].pw_len;
+
+  u32x w[64] = { 0 };
+
+  for (int i = 0, idx = 0; i < pws_pw_len; i += 4, idx += 1)
+  {
+    w[idx] = pws[gid].i[idx];
+  }
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    u32x key0 = prep0;
+    u32x key1 = prep1;
+    u32x key2 = prep2;
+
+    for (int pos = combs_buf[il_pos].pw_len - 1; pos >= 0; pos--)
+    {
+      const u32 t = hc_bfe_S (combs_buf[il_pos].i[pos / 4], (pos & 3) * 8, 8);
+
+      inv_update_key012 (key0, key1, key2, t, l_icrc32tab);
+    }
+
+    for (int pos = pws_pw_len - 1; pos >= 0; pos--)
+    {
+      const u32 t = hc_bfe_S (w[pos / 4], (pos & 3) * 8, 8);
+
+      inv_update_key012 (key0, key1, key2, t, l_icrc32tab);
+    }
+
+    u32 password[2];
+
+    if (derivelast6bytes (key0, key1, key2, password, l_crc32tab, l_icrc32tab, l_lsbk0, l_lsbk0_count0, l_lsbk0_count1) == 1)
+    {
+      GLOBAL_AS pkzip_extra_t *pkzip_extra = (GLOBAL_AS pkzip_extra_t *) tmps;
+
+      pkzip_extra[gid].buf[0] = password[0];
+      pkzip_extra[gid].buf[1] = password[1];
+
+      pkzip_extra[gid].len = 6;
+
+      const u32x r0 = KEY0INIT;
+      const u32x r1 = KEY1INIT;
+      const u32x r2 = KEY2INIT;
+      const u32x r3 = 0;
+
+      COMPARE_S_SIMD (r0, r1, r2, r3);
+    }
+  }
+}
+
+KERNEL_FQ void m20510_mxx (KERN_ATTR_BASIC ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * NOT AVAILABLE
+   */
+}
+
+#undef MSB
+#undef CRC32
+#undef INVCRC32
+#undef INVCONST
+#undef KEY0INIT
+#undef KEY1INIT
+#undef KEY2INIT
+#undef inv_update_key012
diff --git a/OpenCL/m20510_a3-pure.cl b/OpenCL/m20510_a3-pure.cl
new file mode 100644
index 000000000..7eaf21d98
--- /dev/null
+++ b/OpenCL/m20510_a3-pure.cl
@@ -0,0 +1,653 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#include "inc_vendor.h"
+#include "inc_types.h"
+#include "inc_platform.cl"
+#include "inc_common.cl"
+#include "inc_simd.cl"
+
+typedef struct pkzip_extra
+{
+  u32 buf[2];
+  u32 len;
+
+} pkzip_extra_t;
+
+#define MSB(x)          ((x) >> 24)
+#define CRC32(x,c,t)    (((x) >> 8) ^ (t)[((x) ^ (c)) & 0xff])
+#define INVCRC32(x,c,t) (((x) << 8) ^ (t)[(x) >> 24] ^ ((c) & 0xff))
+#define INVCONST        0xd94fa8cd
+#define KEY0INIT        0x12345678
+#define KEY1INIT        0x23456789
+#define KEY2INIT        0x34567890
+
+#define inv_update_key012(k0,k1,k2,c,t)         \
+  (k2) = INVCRC32 ((k2), MSB (k1), (t));        \
+  (k1) = ((k1) - 1) * INVCONST - ((k0) & 0xff); \
+  (k0) = INVCRC32 ((k0), (c), (t));
+
+CONSTANT_VK u32a crc32tab[256] =
+{
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+CONSTANT_VK u32a icrc32tab[256] =
+{
+  0x00000000, 0xdb710641, 0x6d930ac3, 0xb6e20c82,
+  0xdb261586, 0x005713c7, 0xb6b51f45, 0x6dc41904,
+  0x6d3d2d4d, 0xb64c2b0c, 0x00ae278e, 0xdbdf21cf,
+  0xb61b38cb, 0x6d6a3e8a, 0xdb883208, 0x00f93449,
+  0xda7a5a9a, 0x010b5cdb, 0xb7e95059, 0x6c985618,
+  0x015c4f1c, 0xda2d495d, 0x6ccf45df, 0xb7be439e,
+  0xb74777d7, 0x6c367196, 0xdad47d14, 0x01a57b55,
+  0x6c616251, 0xb7106410, 0x01f26892, 0xda836ed3,
+  0x6f85b375, 0xb4f4b534, 0x0216b9b6, 0xd967bff7,
+  0xb4a3a6f3, 0x6fd2a0b2, 0xd930ac30, 0x0241aa71,
+  0x02b89e38, 0xd9c99879, 0x6f2b94fb, 0xb45a92ba,
+  0xd99e8bbe, 0x02ef8dff, 0xb40d817d, 0x6f7c873c,
+  0xb5ffe9ef, 0x6e8eefae, 0xd86ce32c, 0x031de56d,
+  0x6ed9fc69, 0xb5a8fa28, 0x034af6aa, 0xd83bf0eb,
+  0xd8c2c4a2, 0x03b3c2e3, 0xb551ce61, 0x6e20c820,
+  0x03e4d124, 0xd895d765, 0x6e77dbe7, 0xb506dda6,
+  0xdf0b66ea, 0x047a60ab, 0xb2986c29, 0x69e96a68,
+  0x042d736c, 0xdf5c752d, 0x69be79af, 0xb2cf7fee,
+  0xb2364ba7, 0x69474de6, 0xdfa54164, 0x04d44725,
+  0x69105e21, 0xb2615860, 0x048354e2, 0xdff252a3,
+  0x05713c70, 0xde003a31, 0x68e236b3, 0xb39330f2,
+  0xde5729f6, 0x05262fb7, 0xb3c42335, 0x68b52574,
+  0x684c113d, 0xb33d177c, 0x05df1bfe, 0xdeae1dbf,
+  0xb36a04bb, 0x681b02fa, 0xdef90e78, 0x05880839,
+  0xb08ed59f, 0x6bffd3de, 0xdd1ddf5c, 0x066cd91d,
+  0x6ba8c019, 0xb0d9c658, 0x063bcada, 0xdd4acc9b,
+  0xddb3f8d2, 0x06c2fe93, 0xb020f211, 0x6b51f450,
+  0x0695ed54, 0xdde4eb15, 0x6b06e797, 0xb077e1d6,
+  0x6af48f05, 0xb1858944, 0x076785c6, 0xdc168387,
+  0xb1d29a83, 0x6aa39cc2, 0xdc419040, 0x07309601,
+  0x07c9a248, 0xdcb8a409, 0x6a5aa88b, 0xb12baeca,
+  0xdcefb7ce, 0x079eb18f, 0xb17cbd0d, 0x6a0dbb4c,
+  0x6567cb95, 0xbe16cdd4, 0x08f4c156, 0xd385c717,
+  0xbe41de13, 0x6530d852, 0xd3d2d4d0, 0x08a3d291,
+  0x085ae6d8, 0xd32be099, 0x65c9ec1b, 0xbeb8ea5a,
+  0xd37cf35e, 0x080df51f, 0xbeeff99d, 0x659effdc,
+  0xbf1d910f, 0x646c974e, 0xd28e9bcc, 0x09ff9d8d,
+  0x643b8489, 0xbf4a82c8, 0x09a88e4a, 0xd2d9880b,
+  0xd220bc42, 0x0951ba03, 0xbfb3b681, 0x64c2b0c0,
+  0x0906a9c4, 0xd277af85, 0x6495a307, 0xbfe4a546,
+  0x0ae278e0, 0xd1937ea1, 0x67717223, 0xbc007462,
+  0xd1c46d66, 0x0ab56b27, 0xbc5767a5, 0x672661e4,
+  0x67df55ad, 0xbcae53ec, 0x0a4c5f6e, 0xd13d592f,
+  0xbcf9402b, 0x6788466a, 0xd16a4ae8, 0x0a1b4ca9,
+  0xd098227a, 0x0be9243b, 0xbd0b28b9, 0x667a2ef8,
+  0x0bbe37fc, 0xd0cf31bd, 0x662d3d3f, 0xbd5c3b7e,
+  0xbda50f37, 0x66d40976, 0xd03605f4, 0x0b4703b5,
+  0x66831ab1, 0xbdf21cf0, 0x0b101072, 0xd0611633,
+  0xba6cad7f, 0x611dab3e, 0xd7ffa7bc, 0x0c8ea1fd,
+  0x614ab8f9, 0xba3bbeb8, 0x0cd9b23a, 0xd7a8b47b,
+  0xd7518032, 0x0c208673, 0xbac28af1, 0x61b38cb0,
+  0x0c7795b4, 0xd70693f5, 0x61e49f77, 0xba959936,
+  0x6016f7e5, 0xbb67f1a4, 0x0d85fd26, 0xd6f4fb67,
+  0xbb30e263, 0x6041e422, 0xd6a3e8a0, 0x0dd2eee1,
+  0x0d2bdaa8, 0xd65adce9, 0x60b8d06b, 0xbbc9d62a,
+  0xd60dcf2e, 0x0d7cc96f, 0xbb9ec5ed, 0x60efc3ac,
+  0xd5e91e0a, 0x0e98184b, 0xb87a14c9, 0x630b1288,
+  0x0ecf0b8c, 0xd5be0dcd, 0x635c014f, 0xb82d070e,
+  0xb8d43347, 0x63a53506, 0xd5473984, 0x0e363fc5,
+  0x63f226c1, 0xb8832080, 0x0e612c02, 0xd5102a43,
+  0x0f934490, 0xd4e242d1, 0x62004e53, 0xb9714812,
+  0xd4b55116, 0x0fc45757, 0xb9265bd5, 0x62575d94,
+  0x62ae69dd, 0xb9df6f9c, 0x0f3d631e, 0xd44c655f,
+  0xb9887c5b, 0x62f97a1a, 0xd41b7698, 0x0f6a70d9,
+};
+
+CONSTANT_VK u32a lsbk0[256] =
+{
+  0x00, 0x56, 0xac, 0x21, 0x77, 0xcd, 0x42, 0x98,
+  0xee, 0x0d, 0x63, 0xb9, 0x2e, 0x84, 0xda, 0x4f,
+  0xa5, 0xfb, 0x1a, 0x70, 0xc6, 0x3b, 0x91, 0xe7,
+  0x06, 0x5c, 0xb2, 0x27, 0x7d, 0xd3, 0x48, 0x9e,
+  0xf4, 0x13, 0x69, 0xbf, 0x34, 0x8a, 0xe0, 0x55,
+  0xab, 0x20, 0x76, 0xcc, 0x41, 0x97, 0xed, 0x0c,
+  0x62, 0xb8, 0x2d, 0x83, 0xd9, 0x4e, 0xa4, 0xfa,
+  0x19, 0x6f, 0xc5, 0x3a, 0x90, 0xe6, 0x05, 0x5b,
+  0xb1, 0x26, 0x7c, 0xd2, 0x47, 0x9d, 0xf3, 0x12,
+  0x68, 0xbe, 0x33, 0x89, 0xdf, 0x54, 0xaa, 0x1f,
+  0x75, 0xcb, 0x40, 0x96, 0xec, 0x0b, 0x61, 0xb7,
+  0x2c, 0x82, 0xd8, 0x4d, 0xa3, 0xf9, 0x18, 0x6e,
+  0xc4, 0x39, 0x8f, 0xe5, 0x04, 0x5a, 0xb0, 0x25,
+  0x7b, 0xd1, 0x46, 0x9c, 0xf2, 0x11, 0x67, 0xbd,
+  0x32, 0x88, 0xde, 0x53, 0xa9, 0xff, 0x1e, 0x74,
+  0xca, 0x3f, 0x95, 0xeb, 0x0a, 0x60, 0xb6, 0x2b,
+  0x81, 0xd7, 0x4c, 0xa2, 0xf8, 0x17, 0x6d, 0xc3,
+  0x38, 0x8e, 0xe4, 0x03, 0x59, 0xaf, 0x24, 0x7a,
+  0xd0, 0x45, 0x9b, 0xf1, 0x10, 0x66, 0xbc, 0x31,
+  0x87, 0xdd, 0x52, 0xa8, 0xfe, 0x1d, 0x73, 0xc9,
+  0x3e, 0x94, 0xea, 0x09, 0x5f, 0xb5, 0x2a, 0x80,
+  0xd6, 0x4b, 0xa1, 0xf7, 0x16, 0x6c, 0xc2, 0x37,
+  0x8d, 0xe3, 0x02, 0x58, 0xae, 0x23, 0x79, 0xcf,
+  0x44, 0x9a, 0xf0, 0x0f, 0x65, 0xbb, 0x30, 0x86,
+  0xdc, 0x51, 0xa7, 0xfd, 0x1c, 0x72, 0xc8, 0x3d,
+  0x93, 0xe9, 0x08, 0x5e, 0xb4, 0x29, 0x7f, 0xd5,
+  0x4a, 0xa0, 0xf6, 0x15, 0x6b, 0xc1, 0x36, 0x8c,
+  0xe2, 0x01, 0x57, 0xad, 0x22, 0x78, 0xce, 0x43,
+  0x99, 0xef, 0x0e, 0x64, 0xba, 0x2f, 0x85, 0xdb,
+  0x50, 0xa6, 0xfc, 0x1b, 0x71, 0xc7, 0x3c, 0x92,
+  0xe8, 0x07, 0x5d, 0xb3, 0x28, 0x7e, 0xd4, 0x49,
+  0x9f, 0xf5, 0x14, 0x6a, 0xc0, 0x35, 0x8b, 0xe1
+};
+
+CONSTANT_VK int lsbk0_count0[256] =
+{
+    0,   2,   3,   3,   4,   6,   6,   7,
+    8,   9,  11,  12,  12,  13,  15,  15,
+   16,  17,  18,  20,  21,  21,  22,  24,
+   25,  26,  27,  27,  29,  30,  30,  31,
+   33,  34,  35,  36,  36,  38,  39,  39,
+   40,  41,  42,  43,  44,  44,  46,  47,
+   48,  49,  50,  50,  52,  53,  53,  54,
+   56,  57,  58,  59,  59,  61,  62,  63,
+   64,  65,  66,  67,  68,  68,  70,  71,
+   72,  73,  74,  75,  76,  77,  77,  79,
+   79,  80,  81,  82,  83,  84,  85,  86,
+   88,  88,  89,  90,  91,  92,  93,  94,
+   95,  97,  97,  98,  99, 100, 101, 103,
+  103, 104, 105, 106, 107, 108, 109, 110,
+  112, 112, 113, 114, 115, 116, 117, 118,
+  119, 121, 121, 122, 123, 124, 126, 127,
+  127, 128, 130, 130, 131, 132, 133, 135,
+  136, 136, 137, 139, 140, 141, 142, 142,
+  144, 145, 145, 146, 148, 149, 150, 151,
+  151, 152, 154, 154, 155, 156, 157, 159,
+  160, 160, 161, 163, 164, 165, 166, 166,
+  168, 169, 169, 170, 172, 173, 174, 175,
+  175, 177, 178, 179, 180, 181, 182, 183,
+  184, 184, 186, 187, 188, 189, 190, 191,
+  192, 193, 193, 195, 196, 197, 198, 199,
+  200, 201, 202, 203, 204, 205, 206, 207,
+  208, 208, 210, 211, 212, 213, 214, 215,
+  216, 217, 218, 220, 220, 221, 222, 223,
+  224, 225, 226, 227, 229, 229, 230, 231,
+  232, 233, 234, 235, 236, 238, 238, 239,
+  240, 241, 243, 244, 244, 245, 247, 247,
+  248, 249, 250, 252, 253, 253, 254, 255
+};
+
+CONSTANT_VK int lsbk0_count1[256] =
+{
+    2,   3,   3,   4,   6,   6,   7,   8,
+    9,  11,  12,  12,  13,  15,  15,  16,
+   17,  18,  20,  21,  21,  22,  24,  25,
+   26,  27,  27,  29,  30,  30,  31,  33,
+   34,  35,  36,  36,  38,  39,  39,  40,
+   41,  42,  43,  44,  44,  46,  47,  48,
+   49,  50,  50,  52,  53,  53,  54,  56,
+   57,  58,  59,  59,  61,  62,  63,  64,
+   65,  66,  67,  68,  68,  70,  71,  72,
+   73,  74,  75,  76,  77,  77,  79,  79,
+   80,  81,  82,  83,  84,  85,  86,  88,
+   88,  89,  90,  91,  92,  93,  94,  95,
+   97,  97,  98,  99, 100, 101, 103, 103,
+  104, 105, 106, 107, 108, 109, 110, 112,
+  112, 113, 114, 115, 116, 117, 118, 119,
+  121, 121, 122, 123, 124, 126, 127, 127,
+  128, 130, 130, 131, 132, 133, 135, 136,
+  136, 137, 139, 140, 141, 142, 142, 144,
+  145, 145, 146, 148, 149, 150, 151, 151,
+  152, 154, 154, 155, 156, 157, 159, 160,
+  160, 161, 163, 164, 165, 166, 166, 168,
+  169, 169, 170, 172, 173, 174, 175, 175,
+  177, 178, 179, 180, 181, 182, 183, 184,
+  184, 186, 187, 188, 189, 190, 191, 192,
+  193, 193, 195, 196, 197, 198, 199, 200,
+  201, 202, 203, 204, 205, 206, 207, 208,
+  208, 210, 211, 212, 213, 214, 215, 216,
+  217, 218, 220, 220, 221, 222, 223, 224,
+  225, 226, 227, 229, 229, 230, 231, 232,
+  233, 234, 235, 236, 238, 238, 239, 240,
+  241, 243, 244, 244, 245, 247, 247, 248,
+  249, 250, 252, 253, 253, 254, 255, 256
+};
+
+DECLSPEC int derivelast6bytes (const u32x k0, const u32x k1, const u32x k2, u32 *password, LOCAL_AS u32 *l_crc32tab, LOCAL_AS u32 *l_icrc32tab, LOCAL_AS u32 *l_lsbk0, LOCAL_AS int *l_lsbk0_count0, LOCAL_AS int *l_lsbk0_count1)
+{
+  // step 1
+  const u32 k2_1 = INVCRC32 (k2,   (k1   >> 24), l_icrc32tab);
+  const u32 k1_1 = (k1 - 1) * INVCONST - (k0 & 0xff);
+  const u32 k2_2 = INVCRC32 (k2_1, (k1_1 >> 24), l_icrc32tab);
+
+  // step 2
+  u32 k2_3 = INVCRC32 (k2_2, 0, l_icrc32tab);
+  u32 k2_4 = INVCRC32 (k2_3, 0, l_icrc32tab);
+  u32 k2_5 = INVCRC32 (k2_4, 0, l_icrc32tab);
+
+  // step 3
+  const u32 k1_5 = ((u32)((0x90)        ^ l_icrc32tab[(k2_5 >> 24)])) << 24;
+            k2_5 = CRC32 (KEY2INIT, (k1_5 >> 24), l_crc32tab);
+  const u32 k1_4 = ((u32)((k2_5 & 0xFF) ^ l_icrc32tab[(k2_4 >> 24)])) << 24;
+            k2_4 = CRC32 (k2_5    , (k1_4 >> 24), l_crc32tab);
+  const u32 k1_3 = ((u32)((k2_4 & 0xFF) ^ l_icrc32tab[(k2_3 >> 24)])) << 24;
+            k2_3 = CRC32 (k2_4    , (k1_3 >> 24), l_crc32tab);
+  const u32 k1_2 = ((u32)((k2_3 & 0xFF) ^ l_icrc32tab[(k2_2 >> 24)])) << 24;
+
+  // step 5.2
+
+  #define IDX(x) ((x) & 0xff)
+
+  const u32 rhs_step1_0 = (k1_1 - 1) * INVCONST;
+
+  u32 diff0 = ((rhs_step1_0 - 1) * INVCONST - (k1_3 & 0xff000000)) >> 24;
+
+  for (int c0 = 0; c0 < 2; c0++, diff0--)
+  {
+    for (int i0 = l_lsbk0_count0[IDX (diff0)]; i0 < l_lsbk0_count1[IDX (diff0)]; i0++)
+    {
+      if (((rhs_step1_0 - l_lsbk0[i0]) >> 24) != (k1_2 >> 24)) continue;
+
+      const u32 rhs_step1_1 = (rhs_step1_0 - l_lsbk0[i0] - 1) * INVCONST;
+
+      u32 diff1 = ((rhs_step1_1 - 1) * INVCONST - (k1_4 & 0xff000000)) >> 24;
+
+      for (int c1 = 0; c1 < 2; c1++, diff1--)
+      {
+        for (int i1 = l_lsbk0_count0[IDX (diff1)]; i1 < l_lsbk0_count1[IDX (diff1)]; i1++)
+        {
+          if (((rhs_step1_1 - l_lsbk0[i1]) >> 24) != (k1_3 >> 24)) continue;
+
+          const u32 rhs_step1_2 = (rhs_step1_1 - l_lsbk0[i1] - 1) * INVCONST;
+
+          u32 diff2 = ((rhs_step1_2 - 1) * INVCONST - (k1_5 & 0xff000000)) >> 24;
+
+          for (int c2 = 0; c2 < 2; c2++, diff2--)
+          {
+            for (int i2 = l_lsbk0_count0[IDX (diff2)]; i2 < l_lsbk0_count1[IDX (diff2)]; i2++)
+            {
+              if (((rhs_step1_2 - l_lsbk0[i2]) >> 24) != (k1_4 >> 24)) continue;
+
+              const u32 rhs_step1_3 = (rhs_step1_2 - l_lsbk0[i2] - 1) * INVCONST;
+
+              u32 diff3 = ((rhs_step1_3 - 1) * INVCONST - (0x23000000)) >> 24;
+
+              for (int c3 = 0; c3 < 2; c3++, diff3--)
+              {
+                for (int i3 = l_lsbk0_count0[IDX (diff3)]; i3 < l_lsbk0_count1[IDX (diff3)]; i3++)
+                {
+                  if (((rhs_step1_3 - l_lsbk0[i3]) >> 24) != (k1_5 >> 24)) continue;
+
+                  const u32 rhs_step1_4 = (rhs_step1_3 - l_lsbk0[i3] - 1) * INVCONST;
+
+                  u32 diff4 = ((rhs_step1_4 - 1) * INVCONST - (0x05000000)) >> 24;
+
+                  for (int c4 = 0; c4 < 2; c4++, diff4--)
+                  {
+                    for (int i4 = l_lsbk0_count0[IDX (diff4)]; i4 < l_lsbk0_count1[IDX (diff4)]; i4++)
+                    {
+                      if ((rhs_step1_4 - l_lsbk0[i4]) != KEY1INIT) continue;
+
+                      u32 kk;
+
+                      u32 t5 = ((l_lsbk0[i0]) ^ l_icrc32tab[k0 >> 24]) & 0xff;
+
+                      kk = INVCRC32 (k0, t5, l_icrc32tab);
+
+                      u32 t4 = ((l_lsbk0[i1]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t4, l_icrc32tab);
+
+                      u32 t3 = ((l_lsbk0[i2]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t3, l_icrc32tab);
+
+                      u32 t2 = ((l_lsbk0[i3]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t2, l_icrc32tab);
+
+                      u32 t1 = ((l_lsbk0[i4]) ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      kk = INVCRC32 (kk, t1, l_icrc32tab);
+
+                      u32 t0 = ((KEY0INIT)    ^ l_icrc32tab[kk >> 24]) & 0xff;
+
+                      if (INVCRC32 (kk, t0, l_icrc32tab) == KEY0INIT)
+                      {
+                        // found
+
+                        password[0] = t0 <<  0
+                                    | t1 <<  8
+                                    | t2 << 16
+                                    | t3 << 24;
+
+                        password[1] = t4 <<  0
+                                    | t5 <<  8;
+
+                        return 1;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  #undef IDX0
+  #undef IDX1
+
+  // not found
+
+  return 0;
+}
+
+KERNEL_FQ void m20510_sxx (KERN_ATTR_VECTOR ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * sbox, kbox
+   */
+
+  LOCAL_VK u32 l_crc32tab[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_crc32tab[i] = crc32tab[i];
+  }
+
+  LOCAL_VK u32 l_icrc32tab[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_icrc32tab[i] = icrc32tab[i];
+  }
+
+  LOCAL_VK u32 l_lsbk0[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_lsbk0[i] = lsbk0[i];
+  }
+
+  LOCAL_VK int l_lsbk0_count0[256];
+  LOCAL_VK int l_lsbk0_count1[256];
+
+  for (int i = lid; i < 256; i += lsz)
+  {
+    l_lsbk0_count0[i] = lsbk0_count0[i];
+    l_lsbk0_count1[i] = lsbk0_count1[i];
+  }
+
+  SYNC_THREADS();
+
+  if (gid >= gid_max) return;
+
+  /**
+   * digest
+   */
+
+  const u32 search[4] =
+  {
+    KEY0INIT, // static initial values
+    KEY1INIT, // should remain unchanged
+    KEY2INIT,
+    0
+  };
+
+  /**
+   * base
+   */
+
+  const int pw_len = (const int) pws[gid].pw_len;
+
+  /**
+   * reverse
+   */
+
+  u32 prep0 = hc_swap32_S (digests_buf[digests_offset].digest_buf[0]);
+  u32 prep1 = hc_swap32_S (digests_buf[digests_offset].digest_buf[1]);
+  u32 prep2 = hc_swap32_S (digests_buf[digests_offset].digest_buf[2]);
+
+  for (int pos = pw_len - 1; pos >= 4; pos--)
+  {
+    const u32 t = hc_bfe_S (pws[gid].i[pos / 4], (pos & 3) * 8, 8);
+
+    inv_update_key012 (prep0, prep1, prep2, t, l_icrc32tab);
+  }
+
+  /**
+   * loop
+   */
+
+  u32 w0l = pws[gid].i[0];
+
+  for (u32 il_pos = 0; il_pos < il_cnt; il_pos += VECT_SIZE)
+  {
+    const u32x w0r = words_buf_r[il_pos / VECT_SIZE];
+
+    const u32x w0 = w0l | w0r;
+
+    u32x key0 = prep0;
+    u32x key1 = prep1;
+    u32x key2 = prep2;
+
+    if (pw_len == 1)
+    {
+      inv_update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (w0), l_icrc32tab);
+    }
+    else if (pw_len == 2)
+    {
+      inv_update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (w0), l_icrc32tab);
+      inv_update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (w0), l_icrc32tab);
+    }
+    else if (pw_len == 3)
+    {
+      inv_update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (w0), l_icrc32tab);
+      inv_update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (w0), l_icrc32tab);
+      inv_update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (w0), l_icrc32tab);
+    }
+    else
+    {
+      inv_update_key012 (key0, key1, key2, unpack_v8d_from_v32_S (w0), l_icrc32tab);
+      inv_update_key012 (key0, key1, key2, unpack_v8c_from_v32_S (w0), l_icrc32tab);
+      inv_update_key012 (key0, key1, key2, unpack_v8b_from_v32_S (w0), l_icrc32tab);
+      inv_update_key012 (key0, key1, key2, unpack_v8a_from_v32_S (w0), l_icrc32tab);
+    }
+
+    u32 password[2];
+
+    if (derivelast6bytes (key0, key1, key2, password, l_crc32tab, l_icrc32tab, l_lsbk0, l_lsbk0_count0, l_lsbk0_count1) == 1)
+    {
+      GLOBAL_AS pkzip_extra_t *pkzip_extra = (GLOBAL_AS pkzip_extra_t *) tmps;
+
+      pkzip_extra[gid].buf[0] = password[0];
+      pkzip_extra[gid].buf[1] = password[1];
+
+      pkzip_extra[gid].len = 6;
+
+      const u32x r0 = KEY0INIT;
+      const u32x r1 = KEY1INIT;
+      const u32x r2 = KEY2INIT;
+      const u32x r3 = 0;
+
+      COMPARE_S_SIMD (r0, r1, r2, r3);
+    }
+  }
+}
+
+KERNEL_FQ void m20510_mxx (KERN_ATTR_VECTOR ())
+{
+  /**
+   * modifier
+   */
+
+  const u64 gid = get_global_id (0);
+  const u64 lid = get_local_id (0);
+  const u64 lsz = get_local_size (0);
+
+  /**
+   * NOT AVAILABLE
+   */
+}
+
+#undef MSB
+#undef CRC32
+#undef INVCRC32
+#undef INVCONST
+#undef KEY0INIT
+#undef KEY1INIT
+#undef KEY2INIT
+#undef inv_update_key012
diff --git a/docs/changes.txt b/docs/changes.txt
index 50302b74e..543eb0a27 100644
--- a/docs/changes.txt
+++ b/docs/changes.txt
@@ -33,6 +33,7 @@
 - Added hash-mode: Python passlib pbkdf2-sha1
 - Added hash-mode: Python passlib pbkdf2-sha256
 - Added hash-mode: Python passlib pbkdf2-sha512
+- Added hash-mode: PKZIP Stream Cipher
 
 ##
 ## Bugs
diff --git a/src/modules/module_20500.c b/src/modules/module_20500.c
new file mode 100644
index 000000000..3eb5cb3f9
--- /dev/null
+++ b/src/modules/module_20500.c
@@ -0,0 +1,245 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#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_INSIDE_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_ARCHIVE;
+static const char *HASH_NAME      = "PKZIP Stream Cipher";
+static const u64   KERN_TYPE      = 20500;
+static const u32   OPTI_TYPE      = 0;
+static const u64   OPTS_TYPE      = 0;
+static const u32   SALT_TYPE      = SALT_TYPE_NONE;
+static const char *ST_PASS        = "hashcat";
+static const char *ST_HASH        = "f1eff5c0368d10311dcfc419";
+
+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;         }
+
+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;
+
+  token_t token;
+
+  token.token_cnt  = 1;
+
+  token.len_min[0] = 24;
+  token.len_max[0] = 24;
+  token.attr[0]    = 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 *hash_pos = token.buf[0];
+
+  digest[0] = byte_swap_32 (hex_to_u32 (hash_pos +  0));
+  digest[1] = byte_swap_32 (hex_to_u32 (hash_pos +  8));
+  digest[2] = byte_swap_32 (hex_to_u32 (hash_pos + 16));
+  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 u32 *digest = (const u32 *) digest_buf;
+
+  // we can not change anything in the original buffer, otherwise destroying sorting
+  // therefore create some local buffer
+
+  u32 tmp[3];
+
+  tmp[0] = byte_swap_32 (digest[0]);
+  tmp[1] = byte_swap_32 (digest[1]);
+  tmp[2] = byte_swap_32 (digest[2]);
+
+  u8 *out_buf = (u8 *) line_buf;
+
+  u32_to_hex (tmp[0], out_buf +  0);
+  u32_to_hex (tmp[1], out_buf +  8);
+  u32_to_hex (tmp[2], out_buf + 16);
+
+  const int out_len = 24;
+
+  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_DEFAULT;
+  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_hlfmt_disable            = 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_DEFAULT;
+  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_DEFAULT;
+  module_ctx->module_unstable_warning         = MODULE_DEFAULT;
+  module_ctx->module_warmup_disable           = MODULE_DEFAULT;
+}
diff --git a/src/modules/module_20510.c b/src/modules/module_20510.c
new file mode 100644
index 000000000..cd08b40dc
--- /dev/null
+++ b/src/modules/module_20510.c
@@ -0,0 +1,277 @@
+/*
+
+PKZIP Kernels for Hashcat (c) 2018, European Union
+
+PKZIP Kernels for Hashcat has been developed by the Joint Research Centre of the European Commission.
+It is released as open source software under the MIT License.
+
+PKZIP Kernels for Hashcat makes use of two primary external components, which continue to be subject
+to the terms and conditions stipulated in the respective licences they have been released under. These
+external components include, but are not necessarily limited to, the following:
+
+-----
+
+1. Hashcat: MIT License
+
+Copyright (c) 2015-2018 Jens Steube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+2. Miniz: MIT License
+
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----
+
+The European Union disclaims all liability related to or arising out of the use made by third parties of
+any external components and dependencies which may be included with PKZIP Kernels for Hashcat.
+
+-----
+
+The MIT License
+
+Copyright (c) 2018, EUROPEAN UNION
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Author:              Sein Coray
+Related publication: https://scitepress.org/PublicationsDetail.aspx?ID=KLPzPqStp5g=
+
+*/
+
+#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_INSIDE_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_ARCHIVE;
+static const char *HASH_NAME      = "PKZIP Stream Cipher (6 byte optimization)";
+static const u64   KERN_TYPE      = 20510;
+static const u32   OPTI_TYPE      = 0;
+static const u64   OPTS_TYPE      = OPTS_TYPE_COPY_TMPS;
+static const u32   SALT_TYPE      = SALT_TYPE_NONE;
+static const char *ST_PASS        = "t"; // actually "hashcat"
+static const char *ST_HASH        = "f1eff5c0368d10311dcfc419";
+
+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 pkzip_extra
+{
+  u32 buf[2];
+  u32 len;
+
+} pkzip_extra_t;
+
+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 (pkzip_extra_t);
+
+  return tmp_size;
+}
+
+int module_build_plain_postprocess (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const hashes_t *hashes, MAYBE_UNUSED const void *tmps, const u32 *src_buf, MAYBE_UNUSED const size_t src_sz, MAYBE_UNUSED const int src_len, u32 *dst_buf, MAYBE_UNUSED const size_t dst_sz)
+{
+  const pkzip_extra_t *pkzip_extra = (const pkzip_extra_t *) tmps;
+
+  if (pkzip_extra->len == 0)
+  {
+    return snprintf ((char *) dst_buf, dst_sz, "%s", (char *) src_buf);
+  }
+  else
+  {
+    char *dst_ptr = (char *) dst_buf;
+
+    memcpy (dst_ptr, pkzip_extra->buf, pkzip_extra->len);
+
+    return pkzip_extra->len + snprintf (dst_ptr + pkzip_extra->len, dst_sz - pkzip_extra->len, "%s", (char *) src_buf);
+  }
+}
+
+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;
+
+  token_t token;
+
+  token.token_cnt  = 1;
+
+  token.len_min[0] = 24;
+  token.len_max[0] = 24;
+  token.attr[0]    = 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 *hash_pos = token.buf[0];
+
+  digest[0] = hex_to_u32 (hash_pos +  0);
+  digest[1] = hex_to_u32 (hash_pos +  8);
+  digest[2] = hex_to_u32 (hash_pos + 16);
+  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 u32 *digest = (const u32 *) digest_buf;
+
+  // we can not change anything in the original buffer, otherwise destroying sorting
+  // therefore create some local buffer
+
+  u32 tmp[3];
+
+  tmp[0] = digest[0];
+  tmp[1] = digest[1];
+  tmp[2] = digest[2];
+
+  u8 *out_buf = (u8 *) line_buf;
+
+  u32_to_hex (tmp[0], out_buf +  0);
+  u32_to_hex (tmp[1], out_buf +  8);
+  u32_to_hex (tmp[2], out_buf + 16);
+
+  const int out_len = 24;
+
+  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_build_plain_postprocess;
+  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_DEFAULT;
+  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_hlfmt_disable            = 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_DEFAULT;
+  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/tools/test.sh b/tools/test.sh
index d0546a219..9d2cc90ae 100755
--- a/tools/test.sh
+++ b/tools/test.sh
@@ -26,7 +26,7 @@ LUKS_MODE="14600"
 
 # missing hash types: 5200
 
-HASH_TYPES=$(ls ${TDIR}/test_modules/*.pm | sed 's/.*m0*\([0-9]\+\)\.pm/\1/')
+HASH_TYPES=$(ls ${TDIR}/test_modules/*.pm | sed -E 's/.*m0*([0-9]+).pm/\1/')
 HASH_TYPES="${HASH_TYPES} ${TC_MODES} ${VC_MODES} ${LUKS_MODE}"
 HASH_TYPES="$(echo -n ${HASH_TYPES} | tr ' ' '\n' | sort -u -n | tr '\n' ' ')"
 
@@ -2547,7 +2547,7 @@ TYPE="null"
 VECTOR="default"
 HT=0
 PACKAGE=0
-OPTIMIZED=1
+OPTIMIZED=0
 
 while getopts "V:t:m:a:b:hcpd:x:o:d:D:F:POI:s:" opt; do
 
diff --git a/tools/test_modules/m20500.pm b/tools/test_modules/m20500.pm
new file mode 100644
index 000000000..14b5cb1ea
--- /dev/null
+++ b/tools/test_modules/m20500.pm
@@ -0,0 +1,136 @@
+#!/usr/bin/env perl
+
+##
+## Author......: See docs/credits.txt
+## License.....: MIT
+##
+
+use strict;
+use warnings;
+
+sub module_constraints { [[0, 256], [-1, -1], [-1, -1], [-1, -1], [-1, -1]] }
+
+my @crc32tab =
+(
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+);
+
+sub crc32
+{
+  my $a = shift;
+  my $b = shift;
+
+  return $crc32tab[($a ^ $b) & 0xff] ^ ($a >> 8);
+}
+
+sub pkzip_masterkey
+{
+  use integer;
+
+  my $word = shift;
+
+  my $k0 = 0x12345678;
+  my $k1 = 0x23456789;
+  my $k2 = 0x34567890;
+
+  my @chars = split "", $word;
+
+  for (my $i = 0; $i < scalar @chars; $i++)
+  {
+    $k0 = crc32 ($k0, unpack ("C", $chars[$i]));
+    $k1 = (($k1 + ($k0 & 0xff)) * 0x08088405 + 1) & 0xffffffff;
+    $k2 = crc32 ($k2, $k1 >> 24);
+  }
+
+  return sprintf ("%08x%08x%08x", $k0, $k1, $k2);
+}
+
+sub module_generate_hash
+{
+  my $word = shift;
+
+  my $hash = pkzip_masterkey ($word);
+
+  return $hash;
+}
+
+sub module_verify_hash
+{
+  my $line = shift;
+
+  my ($hash, $word) = split (':', $line);
+
+  return unless defined $hash;
+  return unless defined $word;
+
+  my $word_packed = pack_if_HEX_notation ($word);
+
+  my $new_hash = module_generate_hash ($word_packed);
+
+  return ($new_hash, $word);
+}
+
+1;
diff --git a/tools/test_modules/m20510.pm b/tools/test_modules/m20510.pm
new file mode 100644
index 000000000..2af8ca390
--- /dev/null
+++ b/tools/test_modules/m20510.pm
@@ -0,0 +1,136 @@
+#!/usr/bin/env perl
+
+##
+## Author......: See docs/credits.txt
+## License.....: MIT
+##
+
+use strict;
+use warnings;
+
+sub module_constraints { [[0, 250], [-1, -1], [-1, -1], [-1, -1], [-1, -1]] }
+
+my @crc32tab =
+(
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+  0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+  0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+  0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+  0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+  0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+  0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+  0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+  0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+  0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+  0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+  0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+  0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+  0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+  0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+  0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+  0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+  0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+  0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+  0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+  0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+  0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+  0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+  0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+  0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+  0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+  0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+  0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+  0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+  0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+  0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+  0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+  0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+  0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+  0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+  0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+  0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+  0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+  0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+  0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+  0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+  0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+  0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+);
+
+sub crc32
+{
+  my $a = shift;
+  my $b = shift;
+
+  return $crc32tab[($a ^ $b) & 0xff] ^ ($a >> 8);
+}
+
+sub pkzip_masterkey
+{
+  use integer;
+
+  my $word = shift;
+
+  my $k0 = 0x12345678;
+  my $k1 = 0x23456789;
+  my $k2 = 0x34567890;
+
+  my @chars = split "", $word;
+
+  for (my $i = 0; $i < scalar @chars; $i++)
+  {
+    $k0 = crc32 ($k0, unpack ("C", $chars[$i]));
+    $k1 = (($k1 + ($k0 & 0xff)) * 0x08088405 + 1) & 0xffffffff;
+    $k2 = crc32 ($k2, $k1 >> 24);
+  }
+
+  return sprintf ("%08x%08x%08x", $k0, $k1, $k2);
+}
+
+sub module_generate_hash
+{
+  my $word = shift;
+
+  my $hash = pkzip_masterkey ($word);
+
+  return $hash;
+}
+
+sub module_verify_hash
+{
+  my $line = shift;
+
+  my ($hash, $word) = split (':', $line);
+
+  return unless defined $hash;
+  return unless defined $word;
+
+  my $word_packed = pack_if_HEX_notation ($word);
+
+  my $new_hash = module_generate_hash ($word_packed);
+
+  return ($new_hash, $word);
+}
+
+1;