diff --git a/CHANGELOG.md b/CHANGELOG.md
index c1bda4ff5..3ddaf4801 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,8 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
  - Fix 'hf iclass wrbl' - dealing with tags in unsecured vs secured pagemode now is correct (@iceman1001)
  - Change many commands to cliparser (@iceman1001, @tcprst, @mwalker33,...)
  - ...
+ - Change `hf iclass chk/lookup/loclass` speedups (@iceman1001)
+ - Change - ongoing convertion to cliparser (@tcprst, @iceman1001)
  - Added compilation options for 256k Proxmark versions, see doc (@doegox)
  - Added support for 10b UID in `hf 14a sim` (@doegox)
  - Added `HF_TCPRST` standalone mode which read and emulate IKEA Rothult cards (@tcprst)
diff --git a/Makefile b/Makefile
index 89e5b4c98..8338a6959 100644
--- a/Makefile
+++ b/Makefile
@@ -169,6 +169,7 @@ help:
 	@echo "+ fpga_compress   - Make tools/fpga_compress"
 	@echo
 	@echo "+ style           - Apply some automated source code formatting rules"
+	@echo "+ cliparser       - Generate cliparser TODO
 	@echo "+ check           - Run offline tests. Set CHECKARGS to pass arguments to the test script"
 	@echo "+ .../check       - Run offline tests against specific target. See above."
 	@echo "+ miscchecks      - Detect various encoding issues in source code"
@@ -248,6 +249,14 @@ endif
 # easy printing of MAKE VARIABLES
 print-%: ; @echo $* = $($*)
 
+cliparser:
+	# Get list of all commands
+	cat doc/commands.md | grep -e ^\|\` | cut -f 2 -d "\`" | grep -v help | awk '{$$1=$$1};1' > cliparser_all_commands.tmp
+	# Get list of cliparserized commands
+	grep -r CLIParserInit ./client/src/ | cut -f 2 -d "\"" | awk '{$$1=$$1};1' > cliparser_done.tmp
+	# Determine commands that still need cliparser conversion
+	grep -xvf cliparser_done.tmp cliparser_all_commands.tmp > ./doc/cliparser_todo.txt
+
 style:
 	# Make sure astyle is installed
 	@which astyle >/dev/null || ( echo "Please install 'astyle' package first" ; exit 1 )
diff --git a/armsrc/felica.c b/armsrc/felica.c
index aafdae5d8..7aa524e62 100644
--- a/armsrc/felica.c
+++ b/armsrc/felica.c
@@ -620,7 +620,7 @@ void felica_sniff(uint32_t samplesToSkip, uint32_t triggersToSkip) {
     set_tracelen(numbts);
     set_tracelen(BigBuf_max_traceLen());
 
-    Dbprintf("Felica sniffing done, tracelen: %i, use hf list felica for annotations", BigBuf_get_traceLen());
+    Dbprintf("Felica sniffing done, tracelen: %i, use " _YELLOW_("`hf felica list`") " for annotations", BigBuf_get_traceLen());
     reply_mix(CMD_ACK, 1, numbts, 0, 0, 0);
     LED_D_OFF();
 }
diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index 806c63091..9852b15d5 100644
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -20,6 +20,7 @@
 #include "ticks.h"
 #include "dbprint.h"
 #include "util.h"
+#include "util.h"
 #include "parity.h"
 #include "mifareutil.h"
 #include "commonutil.h"
@@ -1979,9 +1980,11 @@ int EmGetCmd(uint8_t *received, uint16_t *len, uint8_t *par) {
     for (;;) {
         WDT_HIT();
 
-        if (check == 2000) {
-            if (BUTTON_PRESS())
+        if (check == 1000) {
+            if (BUTTON_PRESS() || data_available()) {
+                Dbprintf("----------- " _GREEN_("BREAKING") " ----------");
                 return 1;
+            }
             check = 0;
         }
         ++check;
diff --git a/armsrc/mifaresim.c b/armsrc/mifaresim.c
index 4eaf711b3..bba3132a7 100644
--- a/armsrc/mifaresim.c
+++ b/armsrc/mifaresim.c
@@ -535,8 +535,9 @@ void Mifare1ksim(uint16_t flags, uint8_t exitAfterNReads, uint8_t *datain, uint1
 
         WDT_HIT();
 
-        if (counter == 2000) {
+        if (counter == 1000) {
             if (data_available()) {
+                Dbprintf("----------- " _GREEN_("BREAKING") " ----------");
                 break;
             }
             counter = 0;
diff --git a/client/dictionaries/mfc_default_keys.dic b/client/dictionaries/mfc_default_keys.dic
index 38c6e2503..9f716608a 100644
--- a/client/dictionaries/mfc_default_keys.dic
+++ b/client/dictionaries/mfc_default_keys.dic
@@ -105,6 +105,11 @@ c934fe34d934
 cccccccccccc
 dddddddddddd
 eeeeeeeeeeee
+#
+# elevator
+# data from forum 
+FFFFFF545846
+#
 f1a97341a9fc
 44ab09010845 # hotel system
 85fed980ea5a # hotel system
diff --git a/client/dictionaries/t55xx_default_pwds.dic b/client/dictionaries/t55xx_default_pwds.dic
index 6e7a69583..afc00bddf 100644
--- a/client/dictionaries/t55xx_default_pwds.dic
+++ b/client/dictionaries/t55xx_default_pwds.dic
@@ -20,6 +20,11 @@ A5B4C3D2
 00434343
 44B44CAE
 88661858
+#
+# ZX-copy3  T55xx / EM4305
+# ref. http://www.proxmark.org/forum/viewtopic.php?pid=40662#p40662
+19920427
+84AC15E2
 # paxton bullit?
 575F4F4B
 #
diff --git a/client/src/cmdhffelica.c b/client/src/cmdhffelica.c
index 083e69b21..b051f58c0 100644
--- a/client/src/cmdhffelica.c
+++ b/client/src/cmdhffelica.c
@@ -49,7 +49,7 @@ static int usage_hf_felica_sim(void) {
 
 static int usage_hf_felica_sniff(void) {
     PrintAndLogEx(NORMAL, "\nInfo: It get data from the field and saves it into command buffer. ");
-    PrintAndLogEx(NORMAL, "        Buffer accessible from command 'hf list felica'");
+    PrintAndLogEx(NORMAL, "        Buffer accessible from command 'hf felica list'");
     PrintAndLogEx(NORMAL, "\nUsage:  hf felica sniff [-h] [-s] [-t]");
     PrintAndLogEx(NORMAL, "       -h    this help");
     PrintAndLogEx(NORMAL, "       -s    samples to skip (decimal) max 9999");
diff --git a/client/src/cmdhficlass.c b/client/src/cmdhficlass.c
index 49784c4f5..04382b7db 100644
--- a/client/src/cmdhficlass.c
+++ b/client/src/cmdhficlass.c
@@ -51,103 +51,6 @@ static uint8_t iClass_Key_Table[ICLASS_KEYS_MAX][8] = {
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
 };
 
-static int usage_hf_iclass_sim(void) {
-    PrintAndLogEx(NORMAL, "Simulate a iCLASS legacy/standard tag\n");
-    PrintAndLogEx(NORMAL, "Usage:  hf iCLASS sim [h] <option> [CSN]\n");
-    PrintAndLogEx(NORMAL, "Options");
-    PrintAndLogEx(NORMAL, "  h         : Show this help");
-    PrintAndLogEx(NORMAL, "  0 <CSN>   : simulate the given CSN");
-    PrintAndLogEx(NORMAL, "  1         : simulate default CSN");
-    PrintAndLogEx(NORMAL, "  2         : Reader-attack, gather reader responses to extract elite key");
-    PrintAndLogEx(NORMAL, "  3         : Full simulation using emulator memory (see 'hf iclass eload')");
-    PrintAndLogEx(NORMAL, "  4         : Reader-attack, adapted for KeyRoll mode, gather reader responses to extract elite key");
-    PrintAndLogEx(NORMAL, "Examples:");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass sim 0 031FEC8AF7FF12E0"));
-    PrintAndLogEx(NORMAL, "   -- execute loclass attack online part");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass sim 2"));
-    PrintAndLogEx(NORMAL, "   -- simulate full iCLASS 2k tag");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass eload -f hf-iclass-AA162D30F8FF12F1-dump.bin"));
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass sim 3"));
-    PrintAndLogEx(NORMAL, "");
-    return PM3_SUCCESS;
-}
-static int usage_hf_iclass_calc_newkey(void) {
-    PrintAndLogEx(NORMAL, "Calculate new key for updating\n");
-    PrintAndLogEx(NORMAL, "Usage:  hf iclass calc_newkey o <old key> n <new key> s [csn] e\n");
-    PrintAndLogEx(NORMAL, "Options:");
-    PrintAndLogEx(NORMAL, "  h           : Show this help");
-    PrintAndLogEx(NORMAL, "  o <old key> : *specify a key as 16 hex symbols or a key number as 1 symbol");
-    PrintAndLogEx(NORMAL, "  n <new key> : *specify a key as 16 hex symbols or a key number as 1 symbol");
-    PrintAndLogEx(NORMAL, "  s <csn>     : specify a card Serial number to diversify the key (if omitted will attempt to read a csn)");
-    PrintAndLogEx(NORMAL, "  e           : specify new key as elite calc");
-    PrintAndLogEx(NORMAL, "  ee          : specify old and new key as elite calc");
-    PrintAndLogEx(NORMAL, "Examples:");
-    PrintAndLogEx(NORMAL, "   -- e key to e key given csn");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass calcnewkey o 1122334455667788 n 2233445566778899 s deadbeafdeadbeaf ee"));
-    PrintAndLogEx(NORMAL, "   -- std key to e key read csn");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass calcnewkey o 1122334455667788 n 2233445566778899 e"));
-    PrintAndLogEx(NORMAL, "   -- std to std read csn");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass calcnewkey o 1122334455667788 n 2233445566778899"));
-    PrintAndLogEx(NORMAL, "\nNOTE: * = required");
-    PrintAndLogEx(NORMAL, "");
-    return PM3_SUCCESS;
-}
-static int usage_hf_iclass_managekeys(void) {
-    PrintAndLogEx(NORMAL, "Manage iCLASS Keys in client memory:\n");
-    PrintAndLogEx(NORMAL, "Usage:  hf iclass managekeys n [keynbr] k [key] f [filename] s l p\n");
-    PrintAndLogEx(NORMAL, "Options:");
-    PrintAndLogEx(NORMAL, "  h            : Show this help");
-    PrintAndLogEx(NORMAL, "  n <keynbr>   : specify the keyNbr to set in memory");
-    PrintAndLogEx(NORMAL, "  k <key>      : set a key in memory");
-    PrintAndLogEx(NORMAL, "  f <filename> : specify a filename to use with load or save operations");
-    PrintAndLogEx(NORMAL, "  s            : save keys in memory to file specified by filename");
-    PrintAndLogEx(NORMAL, "  l            : load keys to memory from file specified by filename");
-    PrintAndLogEx(NORMAL, "  p            : print keys loaded into memory\n");
-    PrintAndLogEx(NORMAL, "Examples:");
-    PrintAndLogEx(NORMAL, "   -- set key");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass managekeys n 0 k 1122334455667788"));
-    PrintAndLogEx(NORMAL, "   -- save key file");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass managekeys f mykeys.bin s"));
-    PrintAndLogEx(NORMAL, "   -- load key file");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass managekeys f mykeys.bin l"));
-    PrintAndLogEx(NORMAL, "   -- print keys");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass managekeys p"));
-    PrintAndLogEx(NORMAL, "");
-    return PM3_SUCCESS;
-}
-static int usage_hf_iclass_chk(void) {
-    PrintAndLogEx(NORMAL, "Checkkeys loads a dictionary text file with 8byte hex keys to test authenticating against a iClass tag\n");
-    PrintAndLogEx(NORMAL, "Usage: hf iclass chk [h|e|r] [f  (*.dic)]\n");
-    PrintAndLogEx(NORMAL, "Options:");
-    PrintAndLogEx(NORMAL, "  h             Show this help");
-    PrintAndLogEx(NORMAL, "  f <filename>  Dictionary file with default iclass keys");
-    PrintAndLogEx(NORMAL, "  r             raw");
-    PrintAndLogEx(NORMAL, "  e             elite");
-    PrintAndLogEx(NORMAL, "  c             credit key  (if not use, default is debit)");
-    PrintAndLogEx(NORMAL, "Examples:");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass chk f dictionaries/iclass_default_keys.dic"));
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass chk f dictionaries/iclass_default_keys.dic e"));
-    PrintAndLogEx(NORMAL, "");
-    return PM3_SUCCESS;
-}
-static int usage_hf_iclass_lookup(void) {
-    PrintAndLogEx(NORMAL, "Lookup keys takes some sniffed trace data and tries to verify what key was used against a dictionary file\n");
-    PrintAndLogEx(NORMAL, "Usage: hf iclass lookup [h|e|r] [f  (*.dic)] [u <csn>] [p <epurse>] [m <macs>]\n");
-    PrintAndLogEx(NORMAL, "Options:");
-    PrintAndLogEx(NORMAL, "  h             Show this help");
-    PrintAndLogEx(NORMAL, "  f <filename>  Dictionary file with default iclass keys");
-    PrintAndLogEx(NORMAL, "  u             CSN");
-    PrintAndLogEx(NORMAL, "  p             EPURSE");
-    PrintAndLogEx(NORMAL, "  m             macs");
-    PrintAndLogEx(NORMAL, "  r             raw");
-    PrintAndLogEx(NORMAL, "  e             elite");
-    PrintAndLogEx(NORMAL, "Examples:");
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass lookup u 9655a400f8ff12e0 p f0ffffffffffffff m 0000000089cb984b f dictionaries/iclass_default_keys.dic"));
-    PrintAndLogEx(NORMAL, _YELLOW_("\thf iclass lookup u 9655a400f8ff12e0 p f0ffffffffffffff m 0000000089cb984b f dictionaries/iclass_default_keys.dic e"));
-    PrintAndLogEx(NORMAL, "");
-    return PM3_SUCCESS;
-}
-
 static int cmp_uint32(const void *a, const void *b) {
 
     const iclass_prekey_t *x = (const iclass_prekey_t *)a;
@@ -392,6 +295,7 @@ static void print_picopass_info(const picopass_hdr *hdr) {
     fuse_config(hdr);
     mem_app_config(hdr);
 }
+
 static void print_picopass_header(const picopass_hdr *hdr) {
     PrintAndLogEx(INFO, "--------------------------- " _CYAN_("card") " ---------------------------");
     PrintAndLogEx(SUCCESS, "    CSN: " _GREEN_("%s") " uid", sprint_hex(hdr->csn, sizeof(hdr->csn)));
@@ -455,24 +359,48 @@ static int CmdHFiClassSniff(const char *Cmd) {
 }
 
 static int CmdHFiClassSim(const char *Cmd) {
+    CLIParserContext *ctx;
+    CLIParserInit(&ctx, "hf iclass sim",
+                  "Simulate a iCLASS legacy/standard tag",
+                  "hf iclass sim -t 0 --csn 031FEC8AF7FF12E0                -> simulate with specficied CSN\n"
+                  "hf iclass sim -t 1                                       -> simulate with default CSN\n"
+                  "hf iclass sim -t 2                                       -> execute loclass attack online part\n"
+                  "hf iclass eload -f hf-iclass-AA162D30F8FF12F1-dump.bin   -> simulate full iCLASS 2k tag\n"
+                  "hf iclass sim -t 3                                       -> simulate full iCLASS 2k tag\n"
+                  "hf iclass sim -t 4                                       -> Reader-attack, adapted for KeyRoll mode, gather reader responses to extract elite key");
 
-    char cmdp = tolower(param_getchar(Cmd, 0));
-    if (strlen(Cmd) < 1 || cmdp == 'h') return usage_hf_iclass_sim();
+    void *argtable[] = {
+        arg_param_begin,
+        arg_int1("t", "type", NULL, "Simulation type to use"),
+        arg_str0(NULL, "csn", "<hex>", "Specify CSN as 8 bytes (16 hex symbols) to use with sim type 0"),
+        arg_param_end
+    };
+    CLIExecWithReturn(ctx, Cmd, argtable, false);
 
-    uint8_t CSN[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-    uint8_t sim_type = param_get8ex(Cmd, 0, 0, 10);
+    int sim_type = arg_get_int(ctx, 1);
 
-    if (sim_type == 0) {
-        if (param_gethex(Cmd, 1, CSN, 16)) {
-            PrintAndLogEx(ERR, "A CSN should consist of 16 HEX symbols");
-            return usage_hf_iclass_sim();
+    int csn_len = 0;
+    uint8_t csn[8] = {0};
+    CLIGetHexWithReturn(ctx, 2, csn, &csn_len);
+
+    if (sim_type == 0 && csn_len > 0) {
+        if (csn_len != 8) {
+            PrintAndLogEx(ERR, "CSN is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
         }
-        PrintAndLogEx(INFO, " simtype: %02x CSN: %s", sim_type, sprint_hex(CSN, 8));
+        PrintAndLogEx(INFO, " simtype: %02x CSN: %s", sim_type, sprint_hex(csn, 8));
+    } else if (sim_type == 0 && csn_len == 0) {
+        PrintAndLogEx(ERR, "Simtype 0 requires CSN argument (--csn)");
+        CLIParserFree(ctx);
+        return PM3_EINVARG;
     }
 
+    CLIParserFree(ctx);
+
     if (sim_type > 4) {
         PrintAndLogEx(ERR, "Undefined simtype %d", sim_type);
-        return usage_hf_iclass_sim();
+        return PM3_EINVARG;
     }
 
     // remember to change the define NUM_CSNS to match.
@@ -626,10 +554,10 @@ static int CmdHFiClassSim(const char *Cmd) {
         case ICLASS_SIM_MODE_FULL:
         default: {
             PrintAndLogEx(INFO, "Starting iCLASS simulation");
-            PrintAndLogEx(INFO, "press " _YELLOW_("`enter`") " to cancel");
+            PrintAndLogEx(INFO, "press " _YELLOW_("`button`") " to cancel");
             uint8_t numberOfCSNs = 0;
             clearCommandBuffer();
-            SendCommandMIX(CMD_HF_ICLASS_SIMULATE, sim_type, numberOfCSNs, 1, CSN, 8);
+            SendCommandMIX(CMD_HF_ICLASS_SIMULATE, sim_type, numberOfCSNs, 1, csn, 8);
 
             if (sim_type == ICLASS_SIM_MODE_FULL)
                 PrintAndLogEx(HINT, "Try `" _YELLOW_("hf iclass esave -h") "` to save the emulator memory to file");
@@ -814,6 +742,7 @@ static int CmdHFiClassELoad(const char *Cmd) {
     PrintAndLogEx(SUCCESS, "sent %d bytes of data to device emulator memory", bytes_sent);
     return PM3_SUCCESS;
 }
+
 static int CmdHFiClassESave(const char *Cmd) {
     CLIParserContext *ctx;
     CLIParserInit(&ctx, "hf iclass esave",
@@ -931,6 +860,7 @@ static int CmdHFiClassEView(const char *Cmd) {
     free(dump);
     return PM3_SUCCESS;
 }
+
 static int CmdHFiClassDecrypt(const char *Cmd) {
     CLIParserContext *clictx;
     CLIParserInit(&clictx, "hf iclass decrypt",
@@ -1359,7 +1289,7 @@ static int CmdHFiClassDump(const char *Cmd) {
     if (credit_key_len > 0) {
         auth = true;
         have_credit_key = true;
-        if (key_len != 8) {
+        if (credit_key_len != 8) {
             PrintAndLogEx(ERR, "Credit key is incorrect length");
             CLIParserFree(ctx);
             return PM3_EINVARG;
@@ -2377,89 +2307,127 @@ static void HFiClassCalcNewKey(uint8_t *CSN, uint8_t *OLDKEY, uint8_t *NEWKEY, u
 }
 
 static int CmdHFiClassCalcNewKey(const char *Cmd) {
-    uint8_t OLDKEY[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-    uint8_t NEWKEY[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-    uint8_t xor_div_key[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-    uint8_t CSN[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-    uint8_t keyNbr = 0;
-    uint8_t dataLen = 0;
-    char tempStr[50] = {0};
-    bool givenCSN = false;
-    bool old_elite = false;
-    bool elite = false;
-    bool errors = false;
-    uint8_t cmdp = 0;
+    CLIParserContext *ctx;
+    CLIParserInit(&ctx, "hf iclass calcnewkey",
+                  "Calculate new keys for updating (blocks 3 & 4)",
+                  "hf iclass calcnewkey --old 1122334455667788 --new 2233445566778899 --csn deadbeafdeadbeaf --elite2 -> e key to e key given csn\n"
+                  "hf iclass calcnewkey --old 1122334455667788 --new 2233445566778899 --elite                         -> std key to e key read csn\n"
+                  "hf iclass calcnewkey --old 1122334455667788 --new 2233445566778899                                 -> std to std read csn");
 
-    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
-        switch (tolower(param_getchar(Cmd, cmdp))) {
-            case 'h':
-                return usage_hf_iclass_calc_newkey();
-            case 'e':
-                dataLen = param_getstr(Cmd, cmdp, tempStr, sizeof(tempStr));
-                if (dataLen == 2)
-                    old_elite = true;
-                elite = true;
-                cmdp++;
-                break;
-            case 'n':
-                dataLen = param_getstr(Cmd, cmdp + 1, tempStr, sizeof(tempStr));
-                if (dataLen == 16) {
-                    errors = param_gethex(tempStr, 0, NEWKEY, dataLen);
-                } else if (dataLen == 1) {
-                    keyNbr = param_get8(Cmd, cmdp + 1);
-                    if (keyNbr < ICLASS_KEYS_MAX) {
-                        memcpy(NEWKEY, iClass_Key_Table[keyNbr], 8);
-                    } else {
-                        PrintAndLogEx(WARNING, "\nERROR: NewKey Nbr is invalid\n");
-                        errors = true;
-                    }
-                } else {
-                    PrintAndLogEx(WARNING, "\nERROR: NewKey is incorrect length\n");
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'o':
-                dataLen = param_getstr(Cmd, cmdp + 1, tempStr, sizeof(tempStr));
-                if (dataLen == 16) {
-                    errors = param_gethex(tempStr, 0, OLDKEY, dataLen);
-                } else if (dataLen == 1) {
-                    keyNbr = param_get8(Cmd, cmdp + 1);
-                    if (keyNbr < ICLASS_KEYS_MAX) {
-                        memcpy(OLDKEY, iClass_Key_Table[keyNbr], 8);
-                    } else {
-                        PrintAndLogEx(WARNING, "\nERROR: Credit KeyNbr is invalid\n");
-                        errors = true;
-                    }
-                } else {
-                    PrintAndLogEx(WARNING, "\nERROR: Credit Key is incorrect length\n");
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 's':
-                givenCSN = true;
-                if (param_gethex(Cmd, cmdp + 1, CSN, 16))
-                    return usage_hf_iclass_calc_newkey();
-                cmdp += 2;
-                break;
-            default:
-                PrintAndLogEx(WARNING, "unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
-                errors = true;
-                break;
+    void *argtable[] = {
+        arg_param_begin,
+        arg_str0(NULL, "old", "<hex>", "Specify key as 8 bytes (16 hex symbols)"),
+        arg_int0(NULL, "oki", "<dec>", "Old key index to select key from memory 'hf iclass managekeys'"),
+        arg_str0(NULL, "new", "<hex>", "Specify key as 8 bytes (16 hex symbols)"),
+        arg_int0(NULL, "nki", "<dec>", "New key index to select key from memory 'hf iclass managekeys'"),
+        arg_str0(NULL, "csn", "<hex>", "Specify a Card Serial Number (CSN) to diversify the key (if omitted will attempt to read a CSN)"),
+        arg_lit0(NULL, "elite", "Elite computations applied to new key"),
+        arg_lit0(NULL, "elite2", "Elite computations applied to both old and new key"),
+        arg_param_end
+    };
+    CLIExecWithReturn(ctx, Cmd, argtable, false);
+
+    int old_key_len = 0;
+    uint8_t old_key[8] = {0};
+    CLIGetHexWithReturn(ctx, 1, old_key, &old_key_len);
+
+    int old_key_nr = arg_get_int_def(ctx, 2, -1);
+
+    if (old_key_len > 0 && old_key_nr >= 0) {
+        PrintAndLogEx(ERR, "Please specify old key or index, not both");
+        CLIParserFree(ctx);
+        return PM3_EINVARG;
+    }
+
+    if (old_key_len > 0) {
+        if (old_key_len != 8) {
+            PrintAndLogEx(ERR, "Old key is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    } else if (old_key_nr >= 0) {
+        if (old_key_nr < ICLASS_KEYS_MAX) {
+            memcpy(old_key, iClass_Key_Table[old_key_nr], 8);
+            PrintAndLogEx(SUCCESS, "Using old key[%d] " _GREEN_("%s"), old_key_nr, sprint_hex(iClass_Key_Table[old_key_nr], 8));
+        } else {
+            PrintAndLogEx(ERR, "Key number is invalid");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    } else {
+        PrintAndLogEx(ERR, "Please specify an old key or old key index");
+        CLIParserFree(ctx);
+        return PM3_EINVARG;
+    }
+
+    int new_key_len = 0;
+    uint8_t new_key[8] = {0};
+    CLIGetHexWithReturn(ctx, 3, new_key, &new_key_len);
+
+    int new_key_nr = arg_get_int_def(ctx, 4, -1);
+
+    if (new_key_len > 0 && new_key_nr >= 0) {
+        PrintAndLogEx(ERR, "Please specify new key or index, not both");
+        CLIParserFree(ctx);
+        return PM3_EINVARG;
+    }
+
+    if (new_key_len > 0) {
+        if (new_key_len != 8) {
+            PrintAndLogEx(ERR, "New key is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    } else if (new_key_nr >= 0) {
+        if (new_key_nr < ICLASS_KEYS_MAX) {
+            memcpy(new_key, iClass_Key_Table[new_key_nr], 8);
+            PrintAndLogEx(SUCCESS, "Using new key[%d] " _GREEN_("%s"), new_key_nr, sprint_hex(iClass_Key_Table[new_key_nr], 8));
+        } else {
+            PrintAndLogEx(ERR, "Key number is invalid");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    } else {
+        PrintAndLogEx(ERR, "Please specify an new key or old key index");
+        CLIParserFree(ctx);
+        return PM3_EINVARG;
+    }
+
+    int csn_len = 0;
+    uint8_t csn[8] = {0};
+    CLIGetHexWithReturn(ctx, 5, csn, &csn_len);
+    bool givenCSN = false;
+
+    if (csn_len > 0) {
+        givenCSN = true;
+        if (csn_len != 8) {
+            PrintAndLogEx(ERR, "CSN is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
         }
     }
-    if (errors || cmdp < 4) return usage_hf_iclass_calc_newkey();
+
+    bool elite = arg_get_lit(ctx, 6);
+    bool old_elite = false;
+
+    if (arg_get_lit(ctx, 7)) {
+        elite = true;
+        old_elite = true;
+    }
+
+    CLIParserFree(ctx);
+
+    uint8_t xor_div_key[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
     if (givenCSN == false) {
         uint8_t CCNR[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-        if (select_only(CSN, CCNR, true) == false) {
+        if (select_only(csn, CCNR, true) == false) {
             DropField();
             return PM3_ESOFT;
         }
     }
 
-    HFiClassCalcNewKey(CSN, OLDKEY, NEWKEY, xor_div_key, elite, old_elite, true);
+    HFiClassCalcNewKey(csn, old_key, new_key, xor_div_key, elite, old_elite, true);
 
     return PM3_SUCCESS;
 }
@@ -2520,83 +2488,89 @@ static int printKeys(void) {
 }
 
 static int CmdHFiClassManageKeys(const char *Cmd) {
-    uint8_t keyNbr = 0;
-    uint8_t dataLen = 0;
-    uint8_t KEY[8] = {0};
-    char filename[FILE_PATH_SIZE];
-    uint8_t fileNameLen = 0;
-    bool errors = false;
-    uint8_t operation = 0;
-    char tempStr[20];
-    uint8_t cmdp = 0;
+    CLIParserContext *ctx;
+    CLIParserInit(&ctx, "hf iclass managekeys",
+                  "Manage iCLASS Keys in client memory",
+                  "hf iclass managekeys --ki 0 -k 1122334455667788 -> set key\n"
+                  "hf iclass managekeys -f mykeys.bin --save       -> save key file\n"
+                  "hf iclass managekeys -f mykeys.bin --load       -> load key file\n"
+                  "hf iclass managekeys -p                         -> print keys");
 
-    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
-        switch (tolower(param_getchar(Cmd, cmdp))) {
-            case 'h':
-                return usage_hf_iclass_managekeys();
-            case 'f':
-                fileNameLen = param_getstr(Cmd, cmdp + 1, filename, sizeof(filename));
-                if (fileNameLen < 1) {
-                    PrintAndLogEx(ERR, "No filename found");
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'n':
-                keyNbr = param_get8(Cmd, cmdp + 1);
-                if (keyNbr >= ICLASS_KEYS_MAX) {
-                    PrintAndLogEx(ERR, "Invalid block number, MAX is " _YELLOW_("%d"), ICLASS_KEYS_MAX);
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'k':
-                operation += 3; //set key
-                dataLen = param_getstr(Cmd, cmdp + 1, tempStr, sizeof(tempStr));
-                if (dataLen == 16) { //ul-c or ev1/ntag key length
-                    errors = param_gethex(tempStr, 0, KEY, dataLen);
-                } else {
-                    PrintAndLogEx(WARNING, "\nERROR: Key is incorrect length\n");
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'p':
-                operation += 4; //print keys in memory
-                cmdp++;
-                break;
-            case 'l':
-                operation += 5; //load keys from file
-                cmdp++;
-                break;
-            case 's':
-                operation += 6; //save keys to file
-                cmdp++;
-                break;
-            default:
-                PrintAndLogEx(WARNING, "unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
-                errors = true;
-                break;
+    void *argtable[] = {
+        arg_param_begin,
+        arg_str0("f", "file", "<filename>", "Specify a filename to use with load or save operations"),
+        arg_str0("k", "key", "<hex>", "Access key as 16 hex symbols"),
+        arg_int0(NULL, "ki", "<dec>", "Specify key index to set key in memory"),
+        arg_lit0(NULL, "save", "Save keys in memory to file specified by filename"),
+        arg_lit0(NULL, "load", "Load keys to memory from file specified by filename"),
+        arg_lit0("p", "print", "Print keys loaded into memory"),
+        arg_param_end
+    };
+    CLIExecWithReturn(ctx, Cmd, argtable, false);
+
+    int fnlen = 0;
+    char filename[FILE_PATH_SIZE] = {0};
+    CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
+
+    int key_len = 0;
+    uint8_t key[8] = {0};
+    CLIGetHexWithReturn(ctx, 2, key, &key_len);
+    uint8_t operation = 0;
+
+    if (key_len > 0) {
+        operation += 3;
+        if (key_len != 8) {
+            PrintAndLogEx(ERR, "Key is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
         }
     }
-    if (errors) return usage_hf_iclass_managekeys();
+
+    int key_nr = arg_get_int_def(ctx, 3, -1);
+
+    if (key_nr >= 0) {
+        if (key_nr < ICLASS_KEYS_MAX) {
+            PrintAndLogEx(SUCCESS, "Current key[%d] " _YELLOW_("%s"), key_nr, sprint_hex_inrow(iClass_Key_Table[key_nr], 8));
+        } else {
+            PrintAndLogEx(ERR, "Key index is out-of-range");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    }
+
+    if (arg_get_lit(ctx, 4)) {  //save
+        operation += 6;
+    }
+    if (arg_get_lit(ctx, 5)) {  //load
+        operation += 5;
+    }
+    if (arg_get_lit(ctx, 6)) {  //print
+        operation += 4;
+    }
+
+    CLIParserFree(ctx);
 
     if (operation == 0) {
-        PrintAndLogEx(WARNING, "no operation specified (load, save, or print)\n");
-        return usage_hf_iclass_managekeys();
+        PrintAndLogEx(ERR, "No operation specified (load, save, or print)\n");
+        return PM3_EINVARG;
     }
     if (operation > 6) {
-        PrintAndLogEx(WARNING, "Too many operations specified\n");
-        return usage_hf_iclass_managekeys();
+        PrintAndLogEx(ERR, "Too many operations specified\n");
+        return PM3_EINVARG;
     }
-    if (operation > 4 && fileNameLen == 0) {
-        PrintAndLogEx(WARNING, "You must enter a filename when loading or saving\n");
-        return usage_hf_iclass_managekeys();
+    if (operation > 4 && fnlen == 0) {
+        PrintAndLogEx(ERR, "You must enter a filename when loading or saving\n");
+        return PM3_EINVARG;
+    }
+    if (key_len > 0 && key_nr == -1) {
+        PrintAndLogEx(ERR, "Please specify key index when specifying key");
+        return PM3_EINVARG;
     }
 
     switch (operation) {
         case 3:
-            memcpy(iClass_Key_Table[keyNbr], KEY, 8);
+            memcpy(iClass_Key_Table[key_nr], key, 8);
+            PrintAndLogEx(SUCCESS, "    New key[%d] " _GREEN_("%s"), key_nr, sprint_hex_inrow(iClass_Key_Table[key_nr], 8));
             return PM3_SUCCESS;
         case 4:
             return printKeys();
@@ -2628,7 +2602,7 @@ static void add_key(uint8_t *key) {
     if (i == ICLASS_KEYS_MAX) {
         PrintAndLogEx(INFO, "Couldn't find an empty keyslot");
     } else {
-        PrintAndLogEx(HINT, "Try " _YELLOW_("`hf iclass managekeys p`") " to view keys");
+        PrintAndLogEx(HINT, "Try " _YELLOW_("`hf iclass managekeys -p`") " to view keys");
     }
 }
 
@@ -2730,60 +2704,41 @@ static int iclass_chk_keys(uint8_t *keyBlock, uint32_t keycount) {
 */
 
 static int CmdHFiClassCheckKeys(const char *Cmd) {
+    CLIParserContext *ctx;
+    CLIParserInit(&ctx, "hf iclass chk",
+                  "Checkkeys loads a dictionary text file with 8byte hex keys to test authenticating against a iClass tag",
+                  "hf iclass chk -f iclass_default_keys.dic\n"
+                  "hf iclass chk -f iclass_default_keys.dic --elite");
 
-    // empty string
-    if (strlen(Cmd) == 0) return usage_hf_iclass_chk();
+    void *argtable[] = {
+        arg_param_begin,
+        arg_str1("f", "file", "<filename>", "Dictionary file with default iclass keys"),
+        arg_lit0(NULL, "credit", "key is assumed to be the credit key"),
+        arg_lit0(NULL, "elite", "elite computations applied to key"),
+        arg_lit0(NULL, "raw", "no computations applied to key (raw)"),
+        arg_param_end
+    };
+    CLIExecWithReturn(ctx, Cmd, argtable, false);
+
+    int fnlen = 0;
+    char filename[FILE_PATH_SIZE] = {0};
+    CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
+
+    bool use_credit_key = arg_get_lit(ctx, 2);
+    bool use_elite = arg_get_lit(ctx, 3);
+    bool use_raw = arg_get_lit(ctx, 4);
+
+    CLIParserFree(ctx);
 
     uint8_t CSN[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     uint8_t CCNR[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-    // elite key,  raw key, standard key
-    bool use_elite = false;
-    bool use_raw = false;
-    bool use_credit_key = false;
     bool found_key = false;
     //bool found_credit = false;
     bool got_csn = false;
-    bool errors = false;
-    uint8_t cmdp = 0x00;
-
-    char filename[FILE_PATH_SIZE] = {0};
-    uint8_t fileNameLen = 0;
 
     uint64_t t1 = msclock();
 
-    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
-        switch (tolower(param_getchar(Cmd, cmdp))) {
-            case 'h':
-                return usage_hf_iclass_chk();
-            case 'f':
-                fileNameLen = param_getstr(Cmd, cmdp + 1, filename, sizeof(filename));
-                if (fileNameLen < 1) {
-                    PrintAndLogEx(WARNING, _RED_("no filename found after f"));
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'e':
-                use_elite = true;
-                cmdp++;
-                break;
-            case 'c':
-                use_credit_key = true;
-                cmdp++;
-                break;
-            case 'r':
-                use_raw = true;
-                cmdp++;
-                break;
-            default:
-                PrintAndLogEx(WARNING, "unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
-                errors = true;
-                break;
-        }
-    }
-    if (errors) return usage_hf_iclass_chk();
-
     uint8_t *keyBlock = NULL;
     uint32_t keycount = 0;
 
@@ -2911,14 +2866,13 @@ static int CmdHFiClassCheckKeys(const char *Cmd) {
         if (found_key) {
             break;
         }
-
     }
 
 out:
     t1 = msclock() - t1;
 
     PrintAndLogEx(NORMAL, "");
-    PrintAndLogEx(SUCCESS, "time in iclass chk " _YELLOW_("%.0f") " seconds", (float)t1 / 1000.0);
+    PrintAndLogEx(SUCCESS, "time in iclass chk " _YELLOW_("%.3f") " seconds", (float)t1 / 1000.0);
     DropField();
 
     if (found_key) {
@@ -2932,95 +2886,90 @@ out:
     return PM3_SUCCESS;
 }
 
+
 // this method tries to identify in which configuration mode a iCLASS / iCLASS SE reader is in.
 // Standard or Elite / HighSecurity mode.  It uses a default key dictionary list in order to work.
 static int CmdHFiClassLookUp(const char *Cmd) {
+    CLIParserContext *ctx;
+    CLIParserInit(&ctx, "hf iclass lookup",
+                  "Lookup keys takes some sniffed trace data and tries to verify what key was used against a dictionary file",
+                  "hf iclass lookup --csn 9655a400f8ff12e0 --epurse f0ffffffffffffff --macs 0000000089cb984b -f iclass_default_keys.dic\n"
+                  "hf iclass lookup --csn 9655a400f8ff12e0 --epurse f0ffffffffffffff --macs 0000000089cb984b -f iclass_default_keys.dic --elite");
 
-    uint8_t CSN[8];
-    uint8_t EPURSE[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-    uint8_t MACS[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-    uint8_t CCNR[12];
-    uint8_t MAC_TAG[4] = { 0, 0, 0, 0 };
-
-    // elite key,  raw key, standard key
-    bool use_elite = false;
-    bool use_raw = false;
-    bool errors = false;
-    uint8_t cmdp = 0x00;
+    void *argtable[] = {
+        arg_param_begin,
+        arg_str1("f", "file", "<filename>", "Dictionary file with default iclass keys"),
+        arg_str1(NULL, "csn", "<hex>", "Specify CSN as 8 bytes (16 hex symbols)"),
+        arg_str1(NULL, "epurse", "<hex>", "Specify ePurse as 8 bytes (16 hex symbols)"),
+        arg_str1(NULL, "macs", "<hex>", "MACs"),
+        arg_lit0(NULL, "raw", "no computations applied to key (raw)"),
+        arg_lit0(NULL, "elite", "Elite computations applied to key"),
+        arg_param_end
+    };
+    CLIExecWithReturn(ctx, Cmd, argtable, false);
 
+    int fnlen = 0;
     char filename[FILE_PATH_SIZE] = {0};
+    CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
 
-    iclass_prekey_t *prekey = NULL;
-    int len = 0;
-    // if empty string
-    if (strlen(Cmd) == 0) errors = true;
-    // time
-    uint64_t t1 = msclock();
+    int csn_len = 0;
+    uint8_t csn[8] = {0};
+    CLIGetHexWithReturn(ctx, 2, csn, &csn_len);
 
-    while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
-        switch (tolower(param_getchar(Cmd, cmdp))) {
-            case 'h':
-                return usage_hf_iclass_lookup();
-            case 'f':
-                if (param_getstr(Cmd, cmdp + 1, filename, sizeof(filename)) < 1) {
-                    PrintAndLogEx(WARNING, "No filename found after f");
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'u':
-                param_gethex_ex(Cmd, cmdp + 1, CSN, &len);
-                if (len >> 1 != sizeof(CSN)) {
-                    PrintAndLogEx(WARNING, "Wrong CSN length, expected %zu got [%d]", sizeof(CSN), len >> 1);
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'm':
-                param_gethex_ex(Cmd, cmdp + 1, MACS, &len);
-                if (len >> 1 != sizeof(MACS)) {
-                    PrintAndLogEx(WARNING, "Wrong MACS length, expected %zu got [%d]  ", sizeof(MACS), len >> 1);
-                    errors = true;
-                } else {
-                    memcpy(MAC_TAG, MACS + 4, 4);
-                }
-                cmdp += 2;
-                break;
-            case 'p':
-                param_gethex_ex(Cmd, cmdp + 1, EPURSE, &len);
-                if (len >> 1 != sizeof(EPURSE)) {
-                    PrintAndLogEx(WARNING, "Wrong EPURSE length, expected %zu got [%d]  ", sizeof(EPURSE), len >> 1);
-                    errors = true;
-                }
-                cmdp += 2;
-                break;
-            case 'e':
-                use_elite = true;
-                cmdp++;
-                break;
-            case 'r':
-                use_raw = true;
-                cmdp++;
-                break;
-            default:
-                PrintAndLogEx(WARNING, "unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
-                errors = true;
-                break;
+    if (csn_len > 0) {
+        if (csn_len != 8) {
+            PrintAndLogEx(ERR, "CSN is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
         }
     }
 
-    if (errors) return usage_hf_iclass_lookup();
+    int epurse_len = 0;
+    uint8_t epurse[8] = {0};
+    CLIGetHexWithReturn(ctx, 3, epurse, &epurse_len);
+
+    if (epurse_len > 0) {
+        if (epurse_len != 8) {
+            PrintAndLogEx(ERR, "ePurse is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    }
+
+    int macs_len = 0;
+    uint8_t macs[8] = {0};
+    CLIGetHexWithReturn(ctx, 4, macs, &macs_len);
+
+    if (macs_len > 0) {
+        if (macs_len != 8) {
+            PrintAndLogEx(ERR, "MAC is incorrect length");
+            CLIParserFree(ctx);
+            return PM3_EINVARG;
+        }
+    }
+
+    bool use_elite = arg_get_lit(ctx, 5);
+    bool use_raw = arg_get_lit(ctx, 6);
+
+    CLIParserFree(ctx);
+
+    uint8_t CCNR[12];
+    uint8_t MAC_TAG[4] = { 0, 0, 0, 0 };
 
     // stupid copy.. CCNR is a combo of epurse and reader nonce
-    memcpy(CCNR, EPURSE, 8);
-    memcpy(CCNR + 8, MACS, 4);
+    memcpy(CCNR, epurse, 8);
+    memcpy(CCNR + 8, macs, 4);
+    memcpy(MAC_TAG, macs + 4, 4);
 
-    PrintAndLogEx(SUCCESS, "    CSN: " _GREEN_("%s"), sprint_hex(CSN, sizeof(CSN)));
-    PrintAndLogEx(SUCCESS, " Epurse: %s", sprint_hex(EPURSE, sizeof(EPURSE)));
-    PrintAndLogEx(SUCCESS, "   MACS: %s", sprint_hex(MACS, sizeof(MACS)));
+    PrintAndLogEx(SUCCESS, "    CSN: " _GREEN_("%s"), sprint_hex(csn, sizeof(csn)));
+    PrintAndLogEx(SUCCESS, " Epurse: %s", sprint_hex(epurse, sizeof(epurse)));
+    PrintAndLogEx(SUCCESS, "   MACS: %s", sprint_hex(macs, sizeof(macs)));
     PrintAndLogEx(SUCCESS, "   CCNR: " _GREEN_("%s"), sprint_hex(CCNR, sizeof(CCNR)));
     PrintAndLogEx(SUCCESS, "TAG MAC: %s", sprint_hex(MAC_TAG, sizeof(MAC_TAG)));
 
+    // run time
+    uint64_t t1 = msclock();
+
     uint8_t *keyBlock = NULL;
     uint32_t keycount = 0;
 
@@ -3032,14 +2981,14 @@ static int CmdHFiClassLookUp(const char *Cmd) {
     }
 
     //iclass_prekey_t
-    prekey = calloc(keycount, sizeof(iclass_prekey_t));
+    iclass_prekey_t *prekey = calloc(keycount, sizeof(iclass_prekey_t));
     if (!prekey) {
         free(keyBlock);
         return PM3_EMALLOC;
     }
 
     PrintAndLogEx(SUCCESS, "Generating diversified keys...");
-    GenerateMacKeyFrom(CSN, CCNR, use_raw, use_elite, keyBlock, keycount, prekey);
+    GenerateMacKeyFrom(csn, CCNR, use_raw, use_elite, keyBlock, keycount, prekey);
 
     if (use_elite)
         PrintAndLogEx(SUCCESS, "Using " _YELLOW_("elite algo"));
@@ -3065,7 +3014,7 @@ static int CmdHFiClassLookUp(const char *Cmd) {
     }
 
     t1 = msclock() - t1;
-    PrintAndLogEx(SUCCESS, "time in iclass lookup " _YELLOW_("%.0f") " seconds", (float)t1 / 1000.0);
+    PrintAndLogEx(SUCCESS, "time in iclass lookup " _YELLOW_("%.3f") " seconds", (float)t1 / 1000.0);
 
     free(prekey);
     free(keyBlock);
@@ -3073,43 +3022,150 @@ static int CmdHFiClassLookUp(const char *Cmd) {
     return PM3_SUCCESS;
 }
 
-// precalc diversified keys and their MAC
-void GenerateMacFrom(uint8_t *CSN, uint8_t *CCNR, bool use_raw, bool use_elite, uint8_t *keys, uint32_t keycnt, iclass_premac_t *list) {
+typedef struct {
+    uint8_t thread_idx;
+    uint8_t use_raw; 
+    uint8_t use_elite;
+    uint32_t keycnt;
+    uint8_t csn[8];
+    uint8_t cc_nr[12];
+    uint8_t *keys;
+    union {
+        iclass_premac_t *premac;
+        iclass_prekey_t *prekey;
+    } list;
+} PACKED iclass_thread_arg_t;
+
+static size_t iclass_tc = 1;
+
+static void* bf_generate_mac(void *thread_arg) {
+    
+    iclass_thread_arg_t *targ = (iclass_thread_arg_t *)thread_arg;
+    const uint8_t idx = targ->thread_idx;
+    const uint8_t use_raw = targ->use_raw;
+    const uint8_t use_elite = targ->use_elite;
+    const uint32_t keycnt = targ->keycnt;
+    
+    uint8_t *keys = targ->keys;
+    iclass_premac_t *list = targ->list.premac;
+    
+    uint8_t csn[8];
+    uint8_t cc_nr[12];
+    memcpy(csn, targ->csn, sizeof(csn));
+    memcpy(cc_nr, targ->cc_nr, sizeof(cc_nr));
+    
     uint8_t key[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     uint8_t div_key[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-//iceman: threading
-    for (uint32_t i = 0; i < keycnt; i++) {
+    
+    for (uint32_t i = idx; i < keycnt; i += iclass_tc) {
 
         memcpy(key, keys + 8 * i, 8);
 
         if (use_raw)
             memcpy(div_key, key, 8);
         else
-            HFiClassCalcDivKey(CSN, key, div_key, use_elite);
+            HFiClassCalcDivKey(csn, key, div_key, use_elite);
 
-        doMAC(CCNR, div_key, list[i].mac);
+        doMAC(cc_nr, div_key, list[i].mac);
     }
+    return NULL;
+}
+
+// precalc diversified keys and their MAC
+void GenerateMacFrom(uint8_t *CSN, uint8_t *CCNR, bool use_raw, bool use_elite, uint8_t *keys, uint32_t keycnt, iclass_premac_t *list) {
+
+    iclass_tc = num_CPUs();
+    pthread_t threads[iclass_tc];
+    iclass_thread_arg_t args[iclass_tc];
+    // init thread arguments
+    for (uint8_t i = 0; i < iclass_tc; i++) {
+        args[i].thread_idx = i;
+        args[i].use_raw = use_raw; 
+        args[i].use_elite = use_elite;
+        args[i].keycnt = keycnt;
+        args[i].keys = keys;
+        args[i].list.premac = list;
+        
+        memcpy(args[i].csn, CSN, sizeof(args[i].csn) );
+        memcpy(args[i].cc_nr, CCNR, sizeof(args[i].cc_nr) );
+    }
+
+    for (int i = 0; i < iclass_tc; i++) {
+        int res = pthread_create(&threads[i], NULL, bf_generate_mac, (void *)&args[i]);
+        if (res) {
+            PrintAndLogEx(NORMAL, "");
+            PrintAndLogEx(WARNING, "Failed to create pthreads. Quitting");
+            return;
+        }
+    }
+
+    for (int i = 0; i < iclass_tc; i++)
+        pthread_join(threads[i], NULL);
+}
+
+static void* bf_generate_mackey(void *thread_arg) {
+    
+    iclass_thread_arg_t *targ = (iclass_thread_arg_t *)thread_arg;
+    const uint8_t idx = targ->thread_idx;
+    const uint8_t use_raw = targ->use_raw;
+    const uint8_t use_elite = targ->use_elite;
+    const uint32_t keycnt = targ->keycnt;
+    
+    uint8_t *keys = targ->keys;
+    iclass_prekey_t *list = targ->list.prekey;
+    
+    uint8_t csn[8];
+    uint8_t cc_nr[12];
+    memcpy(csn, targ->csn, sizeof(csn));
+    memcpy(cc_nr, targ->cc_nr, sizeof(cc_nr));
+   
+    uint8_t div_key[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+    for (uint32_t i = idx; i < keycnt; i += iclass_tc) {
+
+        memcpy(list[i].key, keys + 8 * i, 8);
+
+        if (use_raw)
+            memcpy(div_key, list[i].key, 8);
+        else
+            HFiClassCalcDivKey(csn, list[i].key, div_key, use_elite);
+
+        doMAC(cc_nr, div_key, list[i].mac);
+    }
+    return NULL;
 }
 
 void GenerateMacKeyFrom(uint8_t *CSN, uint8_t *CCNR, bool use_raw, bool use_elite, uint8_t *keys, uint32_t keycnt, iclass_prekey_t *list) {
 
-    uint8_t div_key[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-//iceman: threading
-    for (uint32_t i = 0; i < keycnt; i++) {
-
-        memcpy(list[i].key, keys + 8 * i, 8);
-
-        // generate diversifed key
-        if (use_raw)
-            memcpy(div_key, list[i].key, 8);
-        else
-            HFiClassCalcDivKey(CSN, list[i].key, div_key, use_elite);
-
-        // generate MAC
-        doMAC(CCNR, div_key, list[i].mac);
+    iclass_tc = num_CPUs();
+    pthread_t threads[iclass_tc];
+    iclass_thread_arg_t args[iclass_tc];
+    // init thread arguments
+    for (uint8_t i = 0; i < iclass_tc; i++) {
+        args[i].thread_idx = i;
+        args[i].use_raw = use_raw; 
+        args[i].use_elite = use_elite;
+        args[i].keycnt = keycnt;
+        args[i].keys = keys;
+        args[i].list.prekey = list;
+        
+        memcpy(args[i].csn, CSN, sizeof(args[i].csn) );
+        memcpy(args[i].cc_nr, CCNR, sizeof(args[i].cc_nr) );
     }
+
+    for (int i = 0; i < iclass_tc; i++) {
+        int res = pthread_create(&threads[i], NULL, bf_generate_mackey, (void *)&args[i]);
+        if (res) {
+            PrintAndLogEx(NORMAL, "");
+            PrintAndLogEx(WARNING, "Failed to create pthreads. Quitting");
+            return;
+        }
+    }
+
+    for (int i = 0; i < iclass_tc; i++)
+        pthread_join(threads[i], NULL);
+    
+    PrintAndLogEx(NORMAL, "");
 }
 
 // print diversified keys
@@ -3304,7 +3360,7 @@ static command_t CommandTable[] = {
     {"encrypt",     CmdHFiClassEncryptBlk,      AlwaysAvailable, "[options..] Encrypt given block data"},
     {"decrypt",     CmdHFiClassDecrypt,         AlwaysAvailable, "[options..] Decrypt given block data or tag dump file" },
     {"managekeys",  CmdHFiClassManageKeys,      AlwaysAvailable, "[options..] Manage keys to use with iclass commands"},
-    {"permute",     CmdHFiClassPermuteKey,      IfPm3Iclass,     "            Permute function from 'heart of darkness' paper"},
+    {"permutekey",  CmdHFiClassPermuteKey,      IfPm3Iclass,     "            Permute function from 'heart of darkness' paper"},
     {"view",        CmdHFiClassView,            AlwaysAvailable, "[options..] Display content from tag dump file"},
 
     {NULL, NULL, NULL, NULL}
diff --git a/client/src/cmdlfsecurakey.c b/client/src/cmdlfsecurakey.c
index 9e8158c82..04bdb3445 100644
--- a/client/src/cmdlfsecurakey.c
+++ b/client/src/cmdlfsecurakey.c
@@ -154,7 +154,7 @@ static int CmdSecurakeyClone(const char *Cmd) {
 
     void *argtable[] = {
         arg_param_begin,
-        arg_str0("r", "raw", "<hex>", "raw hex data. 12 bytes"),
+        arg_str1("r", "raw", "<hex>", "raw hex data. 12 bytes"),
         arg_lit0(NULL, "q5", "optional - specify writing to Q5/T5555 tag"),
         arg_lit0(NULL, "em", "optional - specify writing to EM4305/4469 tag"),
         arg_param_end
diff --git a/client/src/cmdlfvisa2000.c b/client/src/cmdlfvisa2000.c
index ee145e2b9..2e57202c2 100644
--- a/client/src/cmdlfvisa2000.c
+++ b/client/src/cmdlfvisa2000.c
@@ -207,7 +207,7 @@ static int CmdVisa2kClone(const char *Cmd) {
     blocks[2] = id;
     blocks[3] = (visa_parity(id) << 4) | visa_chksum(id);
 
-    PrintAndLogEx(INFO, "Preparing to clone Visa2000 to " _YELLOW_("%s") " with CardId: %"PRIu32, cardtype, id);
+    PrintAndLogEx(INFO, "Preparing to clone Visa2000 to " _YELLOW_("%s") " with CardId: " _GREEN_("%"PRIu32), cardtype, id);
     print_blocks(blocks,  ARRAYLEN(blocks));
 
     int res;
diff --git a/client/src/loclass/elite_crack.c b/client/src/loclass/elite_crack.c
index 3defe5560..250fdc2ad 100644
--- a/client/src/loclass/elite_crack.c
+++ b/client/src/loclass/elite_crack.c
@@ -39,13 +39,14 @@
 #include <stdbool.h>
 #include <string.h>
 #include <stdio.h>
+#include <pthread.h>
 #include <time.h>
 #include "cipherutils.h"
 #include "cipher.h"
 #include "ikeys.h"
 #include "elite_crack.h"
 #include "fileutils.h"
-#include "des.h"
+#include "mbedtls/des.h"
 #include "util_posix.h"
 
 /**
@@ -70,8 +71,7 @@
  * @param dest
  */
 void permutekey(uint8_t key[8], uint8_t dest[8]) {
-    int i;
-    for (i = 0 ; i < 8 ; i++) {
+    for (uint8_t i = 0 ; i < 8 ; i++) {
         dest[i] = (((key[7] & (0x80 >> i)) >> (7 - i)) << 7) |
                   (((key[6] & (0x80 >> i)) >> (7 - i)) << 6) |
                   (((key[5] & (0x80 >> i)) >> (7 - i)) << 5) |
@@ -164,12 +164,16 @@ rk(x [0] . . . x [7] , n + 1) = rk(rl(x [0] ) . . . rl(x [7] ), n)
 **/
 static void rk(uint8_t *key, uint8_t n, uint8_t *outp_key) {
     memcpy(outp_key, key, 8);
-    uint8_t j;
     while (n-- > 0) {
-        for (j = 0; j < 8 ; j++)
-            outp_key[j] = rl(outp_key[j]);
+        outp_key[0] = rl(outp_key[0]);
+        outp_key[1] = rl(outp_key[1]);
+        outp_key[2] = rl(outp_key[2]);
+        outp_key[3] = rl(outp_key[3]);
+        outp_key[4] = rl(outp_key[4]);
+        outp_key[5] = rl(outp_key[5]);
+        outp_key[6] = rl(outp_key[6]);
+        outp_key[7] = rl(outp_key[7]);
     }
-    return;
 }
 
 static mbedtls_des_context ctx_enc;
@@ -214,16 +218,22 @@ void hash2(uint8_t *key64, uint8_t *outp_keytable) {
     uint8_t z[8][8] = {{0}, {0}};
     uint8_t temp_output[8] = {0};
     //calculate complement of key
-    int i;
-    for (i = 0; i < 8; i++)
-        key64_negated[i] = ~key64[i];
+    key64_negated[0] = ~key64[0];
+    key64_negated[1] = ~key64[1];
+    key64_negated[2] = ~key64[2];
+    key64_negated[3] = ~key64[3];
+    key64_negated[4] = ~key64[4];
+    key64_negated[5] = ~key64[5];
+    key64_negated[6] = ~key64[6];
+    key64_negated[7] = ~key64[7];
 
     // Once again, key is on iclass-format
     desencrypt_iclass(key64, key64_negated, z[0]);
 
-//    PrintAndLogEx(NORMAL, "");
-//    PrintAndLogEx(INFO, "High security custom key (Kcus):");
-//    PrintAndLogEx(INFO, "z0  %s", sprint_hex(z[0],8));
+    if (g_debugMode > 0) {
+        PrintAndLogEx(DEBUG, "High security custom key (Kcus):");
+        PrintAndLogEx(DEBUG, "z0  %s", sprint_hex(z[0],8));
+    }
 
     uint8_t y[8][8] = {{0}, {0}};
 
@@ -232,7 +242,7 @@ void hash2(uint8_t *key64, uint8_t *outp_keytable) {
     desdecrypt_iclass(z[0], key64_negated, y[0]);
 //    PrintAndLogEx(INFO, "y0  %s",  sprint_hex(y[0],8));
 
-    for (i = 1; i < 8; i++) {
+    for (uint8_t i = 1; i < 8; i++) {
         // z [i] = DES dec (rk(K cus , i), z [i−1] )
         rk(key64, i, temp_output);
         //y [i] = DES enc (rk(K cus , i), y [i−1] )
@@ -242,7 +252,7 @@ void hash2(uint8_t *key64, uint8_t *outp_keytable) {
     }
 
     if (outp_keytable != NULL) {
-        for (i = 0 ; i < 8 ; i++) {
+        for (uint8_t i = 0 ; i < 8 ; i++) {
             memcpy(outp_keytable + i * 16, y[i], 8);
             memcpy(outp_keytable + 8 + i * 16, z[i], 8);
         }
@@ -280,25 +290,121 @@ static int _readFromDump(uint8_t dump[], dumpdata *item, uint8_t i) {
     return 0;
 }
 */
-//static uint32_t startvalue = 0;
-/**
- * @brief Performs brute force attack against a dump-data item, containing csn, cc_nr and mac.
- *This method calculates the hash1 for the CSN, and determines what bytes need to be bruteforced
- *on the fly. If it finds that more than three bytes need to be bruteforced, it aborts.
- *It updates the keytable with the findings, also using the upper half of the 16-bit ints
- *to signal if the particular byte has been cracked or not.
- *
- * @param dump The dumpdata from iclass reader attack.
- * @param keytable where to write found values.
- * @return
- */
-int bruteforceItem(dumpdata item, uint16_t keytable[]) {
 
-    int found = false;
-    uint8_t key_sel_p[8] = {0};
-    uint8_t div_key[8] = {0};
-    uint8_t key_sel[8] = {0};
-    uint8_t calculated_MAC[4] = {0};
+typedef struct {
+    int thread_idx;
+    uint32_t endmask;
+    uint8_t numbytes_to_recover;
+    uint8_t bytes_to_recover[3];
+    uint8_t key_index[8];
+    uint16_t keytable[128];
+    loclass_dumpdata_t item;
+} loclass_thread_arg_t;
+
+typedef struct {
+    uint8_t values[3];
+} loclass_thread_ret_t;
+
+static size_t loclass_tc = 1;
+static int loclass_found = 0;
+
+static void* bf_thread(void* thread_arg) {
+
+    loclass_thread_arg_t *targ = (loclass_thread_arg_t *)thread_arg;
+    const uint32_t endmask = targ->endmask;
+    const uint8_t numbytes_to_recover = targ->numbytes_to_recover;
+    uint32_t brute = targ->thread_idx;
+
+    uint8_t csn[8];
+    uint8_t cc_nr[12];
+    uint8_t mac[4];
+    uint8_t key_index[8];
+    uint8_t bytes_to_recover[3];
+    uint16_t keytable[128];
+
+    memcpy(csn, targ->item.csn, sizeof(csn));
+    memcpy(cc_nr, targ->item.cc_nr, sizeof(cc_nr));
+    memcpy(mac, targ->item.mac, sizeof(mac));
+    memcpy(key_index, targ->key_index, sizeof(key_index));
+    memcpy(bytes_to_recover, targ->bytes_to_recover, sizeof(bytes_to_recover));
+    memcpy(keytable, targ->keytable, sizeof(keytable));
+
+    int found;
+    while (!(brute & endmask)) {
+
+        found = __atomic_load_n (&loclass_found, __ATOMIC_SEQ_CST);
+
+        if (found != 0xFF) return NULL;
+
+        //Update the keytable with the brute-values
+        for (uint8_t i = 0; i < numbytes_to_recover; i++) {
+            keytable[bytes_to_recover[i]] &= 0xFF00;
+            keytable[bytes_to_recover[i]] |= (brute >> (i * 8) & 0xFF);
+        }
+
+        uint8_t key_sel[8] = {0};
+
+        // Piece together the key
+        key_sel[0] = keytable[key_index[0]] & 0xFF;
+        key_sel[1] = keytable[key_index[1]] & 0xFF;
+        key_sel[2] = keytable[key_index[2]] & 0xFF;
+        key_sel[3] = keytable[key_index[3]] & 0xFF;
+        key_sel[4] = keytable[key_index[4]] & 0xFF;
+        key_sel[5] = keytable[key_index[5]] & 0xFF;
+        key_sel[6] = keytable[key_index[6]] & 0xFF;
+        key_sel[7] = keytable[key_index[7]] & 0xFF;
+
+        // Permute from iclass format to standard format
+
+        uint8_t key_sel_p[8] = {0};
+        permutekey_rev(key_sel, key_sel_p);
+
+        // Diversify
+        uint8_t div_key[8] = {0};
+        diversifyKey(csn, key_sel_p, div_key);
+
+        // Calc mac
+        uint8_t calculated_MAC[4] = {0};
+        doMAC(cc_nr, div_key, calculated_MAC);
+
+        // success
+        if (memcmp(calculated_MAC, mac, 4) == 0) {
+
+            loclass_thread_ret_t *r = (loclass_thread_ret_t*)malloc(sizeof(loclass_thread_ret_t));
+
+            for (uint8_t i = 0 ; i < numbytes_to_recover; i++) {
+                r->values[i] = keytable[bytes_to_recover[i]] & 0xFF;
+            }
+            __atomic_store_n(&loclass_found, targ->thread_idx, __ATOMIC_SEQ_CST);
+            pthread_exit ((void*)r);
+        }
+
+        brute += loclass_tc;
+
+#define _CLR_ "\x1b[0K"
+
+        if (numbytes_to_recover == 3) {
+            if ((brute > 0) && ((brute & 0xFFFF) == 0)) {
+                PrintAndLogEx(INPLACE, "[ %02x %02x %02x ] %8u / %u", bytes_to_recover[0], bytes_to_recover[1], bytes_to_recover[2] , brute, 0xFFFFFF);
+            }
+        } else if (numbytes_to_recover == 2) {
+            if ((brute > 0) && ((brute & 0x3F) == 0))
+                PrintAndLogEx(INPLACE, "[ %02x %02x ] %5u / %u" _CLR_ , bytes_to_recover[0], bytes_to_recover[1], brute, 0xFFFF);
+        } else {
+            if ((brute > 0) && ((brute & 0x1F) == 0))
+                PrintAndLogEx(INPLACE, "[ %02x ] %3u / %u" _CLR_, bytes_to_recover[0], brute, 0xFF);
+        }
+    }
+    pthread_exit(NULL);
+    
+    void* dummyptr = NULL;
+    return dummyptr;
+}
+
+int bruteforceItem(loclass_dumpdata_t item, uint16_t keytable[]) {
+
+    // reset thread signals
+    loclass_found = 0xFF;
 
     //Get the key index (hash1)
     uint8_t key_index[8] = {0};
@@ -317,13 +423,12 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
      * Only the lower eight bits correspond to the (hopefully cracked) key-value.
      **/
     uint8_t bytes_to_recover[3] = {0};
-    uint8_t numbytes_to_recover = 0 ;
-    int i;
-    for (i = 0; i < 8; i++) {
-        if (keytable[key_index[i]] & (CRACKED | BEING_CRACKED)) continue;
+    uint8_t numbytes_to_recover = 0;
+    for (uint8_t i = 0; i < 8; i++) {
+        if (keytable[key_index[i]] & (LOCLASS_CRACKED | LOCLASS_BEING_CRACKED)) continue;
 
         bytes_to_recover[numbytes_to_recover++] = key_index[i];
-        keytable[key_index[i]] |= BEING_CRACKED;
+        keytable[key_index[i]] |= LOCLASS_BEING_CRACKED;
 
         if (numbytes_to_recover > 3) {
             PrintAndLogEx(FAILED, "The CSN requires > 3 byte bruteforce, not supported");
@@ -331,18 +436,141 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
             PrintAndLogEx(INFO, "HASH1 %s", sprint_hex(key_index, 8));
             PrintAndLogEx(NORMAL, "");
             //Before we exit, reset the 'BEING_CRACKED' to zero
-            keytable[bytes_to_recover[0]]  &= ~BEING_CRACKED;
-            keytable[bytes_to_recover[1]]  &= ~BEING_CRACKED;
-            keytable[bytes_to_recover[2]]  &= ~BEING_CRACKED;
+            keytable[bytes_to_recover[0]]  &= ~LOCLASS_BEING_CRACKED;
+            keytable[bytes_to_recover[1]]  &= ~LOCLASS_BEING_CRACKED;
+            keytable[bytes_to_recover[2]]  &= ~LOCLASS_BEING_CRACKED;
             return PM3_ESOFT;
         }
     }
 
+    if (numbytes_to_recover == 0) {
+        PrintAndLogEx(INFO, "No bytes to recover, exiting");
+        return PM3_ESOFT;
+    }
+
+    loclass_thread_arg_t args[loclass_tc];
+    // init thread arguments
+    for (int i = 0; i < loclass_tc; i++) {
+        args[i].thread_idx = i;
+        args[i].numbytes_to_recover = numbytes_to_recover;
+        args[i].endmask = 1 << 8 * numbytes_to_recover;
+
+        memcpy((void*)&args[i].item, (void*)&item, sizeof(loclass_dumpdata_t));
+        memcpy(args[i].bytes_to_recover, bytes_to_recover, sizeof(args[i].bytes_to_recover) );
+        memcpy(args[i].key_index, key_index, sizeof(args[i].key_index) );
+        memcpy(args[i].keytable, keytable, sizeof(args[i].keytable));
+    }
+
+    pthread_t threads[loclass_tc];
+    // create threads
+    for (int i = 0; i < loclass_tc; i++) {
+        int res = pthread_create(&threads[i], NULL, bf_thread, (void *)&args[i]);
+        if (res) {
+            PrintAndLogEx(NORMAL, "");
+            PrintAndLogEx(WARNING, "Failed to create pthreads. Quitting");
+            return PM3_ESOFT;
+        }
+    }
+    // wait for threads to terminate:
+    void* ptrs[loclass_tc];
+    for (int i = 0; i < loclass_tc; i++)
+        pthread_join(threads[i], &ptrs[i]);
+
+    // was it a success?
+    int res = PM3_SUCCESS;
+    if (loclass_found == 0xFF) {
+        res = PM3_ESOFT;
+        PrintAndLogEx(NORMAL, "");
+        PrintAndLogEx(WARNING, "Failed to recover %d bytes using the following CSN", numbytes_to_recover);
+        PrintAndLogEx(INFO, "CSN  %s", sprint_hex(item.csn, 8));
+
+        //Before we exit, reset the 'BEING_CRACKED' to zero
+        for (uint8_t i = 0; i < numbytes_to_recover; i++) {
+            keytable[bytes_to_recover[i]] &= 0xFF;
+            keytable[bytes_to_recover[i]] |= LOCLASS_CRACK_FAILED;
+        }
+
+    } else {
+        loclass_thread_ret_t ice = *((loclass_thread_ret_t *)ptrs[loclass_found]);
+
+        for (uint8_t i = 0; i < numbytes_to_recover; i++) {
+            keytable[bytes_to_recover[i]] = ice.values[i];
+            keytable[bytes_to_recover[i]] &= 0xFF;
+            keytable[bytes_to_recover[i]] |= LOCLASS_CRACKED;
+        }
+        for (uint8_t i = 0; i < loclass_tc; i++) {
+            free(ptrs[i]);
+        }
+    }
+
+    memset(args, 0x00, sizeof(args));
+    memset(threads, 0x00, sizeof(threads));
+    return res;
+}
+
+/**
+ * @brief Performs brute force attack against a dump-data item, containing csn, cc_nr and mac.
+ *This method calculates the hash1 for the CSN, and determines what bytes need to be bruteforced
+ *on the fly. If it finds that more than three bytes need to be bruteforced, it aborts.
+ *It updates the keytable with the findings, also using the upper half of the 16-bit ints
+ *to signal if the particular byte has been cracked or not.
+ *
+ * @param dump The dumpdata from iclass reader attack.
+ * @param keytable where to write found values.
+ * @return
+ */
+/*
+int bruteforceItem(loclass_dumpdata_t item, uint16_t keytable[]) {
+
+    //Get the key index (hash1)
+    uint8_t key_index[8] = {0};
+    hash1(item.csn, key_index);
+*/
     /*
-     *A uint32 has room for 4 bytes, we'll only need 24 of those bits to bruteforce up to three bytes,
-     */
-    //uint32_t brute = startvalue;
+     * Determine which bytes to retrieve. A hash is typically
+     * 01010000454501
+     * We go through that hash, and in the corresponding keytable, we put markers
+     * on what state that particular index is:
+     * - CRACKED (this has already been cracked)
+     * - BEING_CRACKED (this is being bruteforced now)
+     * - CRACK_FAILED (self-explaining...)
+     *
+     * The markers are placed in the high area of the 16 bit key-table.
+     * Only the lower eight bits correspond to the (hopefully cracked) key-value.
+     **/
+
+
+/*
+    uint8_t bytes_to_recover[3] = {0};
+    uint8_t numbytes_to_recover = 0 ;
+    for (uint8_t i = 0; i < 8; i++) {
+        if (keytable[key_index[i]] & (LOCLASS_CRACKED | LOCLASS_BEING_CRACKED)) continue;
+
+        bytes_to_recover[numbytes_to_recover++] = key_index[i];
+        keytable[key_index[i]] |= LOCLASS_BEING_CRACKED;
+
+        if (numbytes_to_recover > 3) {
+            PrintAndLogEx(FAILED, "The CSN requires > 3 byte bruteforce, not supported");
+            PrintAndLogEx(INFO, "CSN   %s", sprint_hex(item.csn, 8));
+            PrintAndLogEx(INFO, "HASH1 %s", sprint_hex(key_index, 8));
+            PrintAndLogEx(NORMAL, "");
+            //Before we exit, reset the 'BEING_CRACKED' to zero
+            keytable[bytes_to_recover[0]]  &= ~LOCLASS_BEING_CRACKED;
+            keytable[bytes_to_recover[1]]  &= ~LOCLASS_BEING_CRACKED;
+            keytable[bytes_to_recover[2]]  &= ~LOCLASS_BEING_CRACKED;
+            return PM3_ESOFT;
+        }
+    }
+
+    uint8_t key_sel_p[8] = {0};
+    uint8_t div_key[8] = {0};
+    uint8_t key_sel[8] = {0};
+    uint8_t calculated_MAC[4] = {0};
+
+
+    //A uint32 has room for 4 bytes, we'll only need 24 of those bits to bruteforce up to three bytes,
     uint32_t brute = 0;
+*/
     /*
        Determine where to stop the bruteforce. A 1-byte attack stops after 256 tries,
        (when brute reaches 0x100). And so on...
@@ -350,16 +578,17 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
        bytes_to_recover = 2 --> endmask = 0x000010000
        bytes_to_recover = 3 --> endmask = 0x001000000
     */
-
+/*
     uint32_t endmask =  1 << 8 * numbytes_to_recover;
     PrintAndLogEx(NORMAL, "----------------------------");
-    for (i = 0 ; i < numbytes_to_recover && numbytes_to_recover > 1; i++)
-        PrintAndLogEx(INFO, "Bruteforcing byte %d", bytes_to_recover[i]);
+    for (uint8_t i = 0 ; i < numbytes_to_recover && numbytes_to_recover > 1; i++)
+        PrintAndLogEx(INFO, "Bruteforcing %d", bytes_to_recover[i]);
 
+    bool found = false;
     while (!found && !(brute & endmask)) {
 
         //Update the keytable with the brute-values
-        for (i = 0; i < numbytes_to_recover; i++) {
+        for (uint8_t i = 0; i < numbytes_to_recover; i++) {
             keytable[bytes_to_recover[i]] &= 0xFF00;
             keytable[bytes_to_recover[i]] |= (brute >> (i * 8) & 0xFF);
         }
@@ -376,16 +605,15 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
 
         //Permute from iclass format to standard format
         permutekey_rev(key_sel, key_sel_p);
-        //Diversify
+
         diversifyKey(item.csn, key_sel_p, div_key);
-        //Calc mac
         doMAC(item.cc_nr, div_key, calculated_MAC);
 
         // success
         if (memcmp(calculated_MAC, item.mac, 4) == 0) {
             PrintAndLogEx(NORMAL, "");
-            for (i = 0 ; i < numbytes_to_recover; i++) {
-                PrintAndLogEx(INFO, "%d: 0x%02x", bytes_to_recover[i], 0xFF & keytable[bytes_to_recover[i]]);
+            for (uint8_t i = 0 ; i < numbytes_to_recover; i++) {
+                PrintAndLogEx(SUCCESS, "%d: 0x%02x", bytes_to_recover[i], keytable[bytes_to_recover[i]] & 0xFF);
             }
             found = true;
             break;
@@ -393,9 +621,7 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
 
         brute++;
         if ((brute & 0xFFFF) == 0) {
-            PrintAndLogEx(NORMAL, "%3d," NOLF, (brute >> 16) & 0xFF);
-            if (((brute >> 16) % 0x10) == 0)
-                PrintAndLogEx(NORMAL, "");
+            PrintAndLogEx(INPLACE, "%3d", (brute >> 16) & 0xFF);
         }
     }
 
@@ -408,19 +634,20 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
         errors = PM3_ESOFT;
 
         //Before we exit, reset the 'BEING_CRACKED' to zero
-        for (i = 0; i < numbytes_to_recover; i++) {
+        for (uint8_t i = 0; i < numbytes_to_recover; i++) {
             keytable[bytes_to_recover[i]]  &= 0xFF;
-            keytable[bytes_to_recover[i]]  |= CRACK_FAILED;
+            keytable[bytes_to_recover[i]]  |= LOCLASS_CRACK_FAILED;
         }
     } else {
         //PrintAndLogEx(SUCCESS, "DES calcs: %u", brute);
-        for (i = 0; i < numbytes_to_recover; i++) {
+        for (uint8_t i = 0; i < numbytes_to_recover; i++) {
             keytable[bytes_to_recover[i]]  &= 0xFF;
-            keytable[bytes_to_recover[i]]  |= CRACKED;
+            keytable[bytes_to_recover[i]]  |= LOCLASS_CRACKED;
         }
     }
     return errors;
 }
+*/
 
 /**
  * From dismantling iclass-paper:
@@ -434,7 +661,7 @@ int bruteforceItem(dumpdata item, uint16_t keytable[]) {
  * @param master_key where to put the master key
  * @return 0 for ok, 1 for failz
  */
-int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[]) {
+int calculateMasterKey(uint8_t first16bytes[], uint8_t kcus[]) {
     mbedtls_des_context ctx_e;
 
     uint8_t z_0[8] = {0};
@@ -457,9 +684,14 @@ int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[]) {
     mbedtls_des_setkey_enc(&ctx_e, z_0_rev);
     mbedtls_des_crypt_ecb(&ctx_e, y_0, key64_negated);
 
-    int i;
-    for (i = 0; i < 8 ; i++)
-        key64[i] = ~key64_negated[i];
+    key64[0] = ~key64_negated[0];
+    key64[1] = ~key64_negated[1];
+    key64[2] = ~key64_negated[2];
+    key64[3] = ~key64_negated[3];
+    key64[4] = ~key64_negated[4];
+    key64[5] = ~key64_negated[5];
+    key64[6] = ~key64_negated[6];
+    key64[7] = ~key64_negated[7];
 
     // Can we verify that the  key is correct?
     // Once again, key is on iclass-format
@@ -468,21 +700,20 @@ int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[]) {
 
     mbedtls_des_setkey_enc(&ctx_e, key64_stdformat);
     mbedtls_des_crypt_ecb(&ctx_e, key64_negated, result);
-    PrintAndLogEx(NORMAL, "");
-    PrintAndLogEx(SUCCESS, "-- High security custom key (Kcus) --");
-    PrintAndLogEx(SUCCESS, "Standard format  " _GREEN_("%s"), sprint_hex(key64_stdformat, 8));
-    PrintAndLogEx(SUCCESS, "iClass format    %s", sprint_hex(key64, 8));
 
-    if (master_key != NULL)
-        memcpy(master_key, key64, 8);
+    if (kcus != NULL)
+        memcpy(kcus, key64, 8);
 
-    PrintAndLogEx(NORMAL, "\n");
     if (memcmp(z_0, result, 4) != 0) {
         PrintAndLogEx(WARNING, _RED_("Failed to verify") " calculated master key (k_cus)! Something is wrong.");
         return PM3_ESOFT;
     }
 
-    PrintAndLogEx(SUCCESS, _GREEN_("Key verified ok!"));
+    PrintAndLogEx(SUCCESS, "-----  " _CYAN_("High security custom key (Kcus)") " -----");
+    PrintAndLogEx(SUCCESS, "Standard format  %s", sprint_hex(key64_stdformat, 8));
+    PrintAndLogEx(SUCCESS, "iCLASS format    " _GREEN_("%s"), sprint_hex(key64, 8));
+    PrintAndLogEx(SUCCESS, "Key verified (" _GREEN_("ok") ")");
+    PrintAndLogEx(NORMAL, "");
     return PM3_SUCCESS;
 }
 /**
@@ -494,28 +725,32 @@ int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[]) {
  */
 int bruteforceDump(uint8_t dump[], size_t dumpsize, uint16_t keytable[]) {
     uint8_t i;
-    size_t itemsize = sizeof(dumpdata);
-    uint64_t t1 = msclock();
-
-    dumpdata *attack = (dumpdata *) calloc(itemsize, sizeof(uint8_t));
+    size_t itemsize = sizeof(loclass_dumpdata_t);
+    loclass_dumpdata_t *attack = (loclass_dumpdata_t *) calloc(itemsize, sizeof(uint8_t));
     if (attack == NULL) {
         PrintAndLogEx(WARNING, "failed to allocate memory");
         return PM3_EMALLOC;
     }
 
+    loclass_tc = num_CPUs();
+    PrintAndLogEx(INFO, "bruteforce using " _YELLOW_("%zu") " threads", loclass_tc);
+
     int res = 0;
+
+    uint64_t t1 = msclock();
     for (i = 0 ; i * itemsize < dumpsize ; i++) {
         memcpy(attack, dump + i * itemsize, itemsize);
-        res += bruteforceItem(*attack, keytable);
+        res = bruteforceItem(*attack, keytable);
         if (res != PM3_SUCCESS)
             break;
     }
     free(attack);
     t1 = msclock() - t1;
-    PrintAndLogEx(SUCCESS, "time: %" PRIu64 " seconds", t1 / 1000);
+    PrintAndLogEx(NORMAL, "");
+    PrintAndLogEx(SUCCESS, "time " _YELLOW_("%" PRIu64) " seconds", t1 / 1000);
 
     if (res != PM3_SUCCESS) {
-        PrintAndLogEx(ERR, "loclass exiting. Try run " _YELLOW_("`hf iclass sim 2`") " again and collect new data");
+        PrintAndLogEx(ERR, "loclass exiting. Try run " _YELLOW_("`hf iclass sim -t 2`") " again and collect new data");
         return PM3_ESOFT;
     }
 
@@ -524,11 +759,10 @@ int bruteforceDump(uint8_t dump[], size_t dumpsize, uint16_t keytable[]) {
     // indicate crack-status. Those must be discarded for the
     // master key calculation
     uint8_t first16bytes[16] = {0};
-
     for (i = 0 ; i < 16 ; i++) {
         first16bytes[i] = keytable[i] & 0xFF;
 
-        if (!(keytable[i] & CRACKED)) {
+        if ((keytable[i] & LOCLASS_CRACKED) != LOCLASS_CRACKED) {
             PrintAndLogEx(WARNING, "Warning: we are missing byte %d, custom key calculation will fail...", i);
             return PM3_ESOFT;
         }
@@ -620,7 +854,7 @@ static int _test_iclass_key_permutation(void) {
         return PM3_ESOFT;
     }
 
-    PrintAndLogEx(SUCCESS, "Iclass key permutation (%s)", _GREEN_("OK"));
+    PrintAndLogEx(SUCCESS, "    Iclass key permutation (%s)", _GREEN_("ok"));
     return PM3_SUCCESS;
 }
 
@@ -640,8 +874,8 @@ static int _testHash1(void) {
 }
 
 int testElite(bool slowtests) {
-    PrintAndLogEx(INFO, "Testing iClass Elite functinality...");
-    PrintAndLogEx(INFO, "Testing hash2");
+    PrintAndLogEx(INFO, "Testing iClass Elite functionality");
+    PrintAndLogEx(INFO, "Testing hash2...");
     uint8_t k_cus[8] = {0x5B, 0x7C, 0x62, 0xC4, 0x91, 0xC1, 0x1B, 0x39};
 
     /**
@@ -661,20 +895,19 @@ int testElite(bool slowtests) {
      */
     uint8_t keytable[128] = {0};
     hash2(k_cus, keytable);
-    printarr_human_readable("Hash2", keytable, 128);
+    printarr_human_readable("---------------------- Hash2 ----------------------", keytable, sizeof(keytable));
     if (keytable[3] == 0xA1 && keytable[0x30] == 0xA3 && keytable[0x6F] == 0x95) {
-        PrintAndLogEx(SUCCESS, "    Hash2 (%s)", _GREEN_("ok"));
+        PrintAndLogEx(SUCCESS, "    hash2 (%s)", _GREEN_("ok"));
     }
 
     int res = PM3_SUCCESS;
     PrintAndLogEx(INFO, "Testing hash1...");
     res += _testHash1();
-    PrintAndLogEx(INFO, "    hash1 (%s)", (res == PM3_SUCCESS) ? _GREEN_("ok") : _RED_("fail"));
+    PrintAndLogEx((res == PM3_SUCCESS) ? SUCCESS : WARNING, "    hash1 (%s)", (res == PM3_SUCCESS) ? _GREEN_("ok") : _RED_("fail") );
 
     PrintAndLogEx(INFO, "Testing key diversification...");
     res += _test_iclass_key_permutation();
-    if (res == PM3_SUCCESS)
-        PrintAndLogEx(INFO, "    key diversification (%s)", (res == PM3_SUCCESS) ? _GREEN_("ok") : _RED_("fail"));
+    PrintAndLogEx((res == PM3_SUCCESS) ? SUCCESS : WARNING, "    key diversification (%s)", (res == PM3_SUCCESS) ? _GREEN_("ok") : _RED_("fail") );
 
     if (slowtests)
         res += _testBruteforce();
diff --git a/client/src/loclass/elite_crack.h b/client/src/loclass/elite_crack.h
index a9de5dbd1..8f48dac8a 100644
--- a/client/src/loclass/elite_crack.h
+++ b/client/src/loclass/elite_crack.h
@@ -38,6 +38,22 @@
 
 #ifndef ELITE_CRACK_H
 #define ELITE_CRACK_H
+
+//Crack status, see below
+#define LOCLASS_CRACKED         0x0100
+#define LOCLASS_BEING_CRACKED   0x0200
+#define LOCLASS_CRACK_FAILED    0x0400
+
+/**
+  This is how we expect each 'entry' in a dumpfile to look
+**/
+typedef struct {
+    uint8_t csn[8];
+    uint8_t cc_nr[12];
+    uint8_t mac[4];
+} loclass_dumpdata_t;
+
+
 void permutekey(uint8_t key[8], uint8_t dest[8]);
 /**
  * Permutes  a key from iclass specific format to NIST format
@@ -46,10 +62,6 @@ void permutekey(uint8_t key[8], uint8_t dest[8]);
  * @param dest
  */
 void permutekey_rev(uint8_t key[8], uint8_t dest[8]);
-//Crack status, see below
-#define CRACKED         0x0100
-#define BEING_CRACKED   0x0200
-#define CRACK_FAILED    0x0400
 
 /**
  * Perform a bruteforce against a file which has been saved by pm3
@@ -69,7 +81,7 @@ int bruteforceFile(const char *filename, uint16_t keytable[]);
  */
 int bruteforceFileNoKeys(const char *filename);
 /**
- * @brief Same as bruteforcefile, but uses a an array of dumpdata instead
+ * @brief Same as bruteforcefile, but uses a an array of loclass_dumpdata_t instead
  * @param dump
  * @param dumpsize
  * @param keytable
@@ -77,15 +89,6 @@ int bruteforceFileNoKeys(const char *filename);
  */
 int bruteforceDump(uint8_t dump[], size_t dumpsize, uint16_t keytable[]);
 
-/**
-  This is how we expect each 'entry' in a dumpfile to look
-**/
-typedef struct {
-    uint8_t csn[8];
-    uint8_t cc_nr[12];
-    uint8_t mac[4];
-} dumpdata;
-
 /**
  * @brief Performs brute force attack against a dump-data item, containing csn, cc_nr and mac.
  *This method calculates the hash1 for the CSN, and determines what bytes need to be bruteforced
@@ -93,11 +96,11 @@ typedef struct {
  *It updates the keytable with the findings, also using the upper half of the 16-bit ints
  *to signal if the particular byte has been cracked or not.
  *
- * @param dump The dumpdata from iclass reader attack.
+ * @param loclass_dumpdata_t The dumpdata from iclass reader attack.
  * @param keytable where to write found values.
  * @return
  */
-int bruteforceItem(dumpdata item, uint16_t keytable[]);
+int bruteforceItem(loclass_dumpdata_t item, uint16_t keytable[]);
 /**
  * Hash1 takes CSN as input, and determines what bytes in the keytable will be used
  * when constructing the K_sel.
@@ -118,7 +121,7 @@ void hash2(uint8_t *key64, uint8_t *outp_keytable);
  * @param master_key where to put the master key
  * @return 0 for ok, 1 for failz
  */
-int calculateMasterKey(uint8_t first16bytes[], uint64_t master_key[]);
+int calculateMasterKey(uint8_t first16bytes[], uint8_t master_key[]);
 
 /**
  * @brief Test function
@@ -141,5 +144,4 @@ int testElite(bool slowtests);
 
 **/
 
-
 #endif
diff --git a/client/src/loclass/ikeys.c b/client/src/loclass/ikeys.c
index 181f23db1..38adc04b0 100644
--- a/client/src/loclass/ikeys.c
+++ b/client/src/loclass/ikeys.c
@@ -70,7 +70,7 @@ From "Dismantling iclass":
 
 #include "fileutils.h"
 #include "cipherutils.h"
-#include "des.h"
+#include "mbedtls/des.h"
 
 uint8_t pi[35] = {
     0x0F, 0x17, 0x1B, 0x1D, 0x1E, 0x27, 0x2B, 0x2D,
@@ -80,9 +80,6 @@ uint8_t pi[35] = {
     0x72, 0x74, 0x78
 };
 
-static mbedtls_des_context ctx_enc;
-static mbedtls_des_context ctx_dec;
-
 /**
  * @brief The key diversification algorithm uses 6-bit bytes.
  * This implementation uses 64 bit uint to pack seven of them into one
@@ -94,16 +91,19 @@ static mbedtls_des_context ctx_dec;
  * @param n bitnumber
  * @return
  */
-static uint8_t getSixBitByte(uint64_t c, int n) {
+#define getSixBitByte(c, n)  ((uint8_t)(((c) >> (42 - 6 * (n))) & 0x3F))
+/*
+static inline uint8_t getSixBitByte(uint64_t c, int n) {
     return (c >> (42 - 6 * n)) & 0x3F;
 }
-
+*/
 /**
  * @brief Puts back a six-bit 'byte' into a uint64_t.
  * @param c buffer
  * @param z the value to place there
  * @param n bitnumber.
  */
+
 static void pushbackSixBitByte(uint64_t *c, uint8_t z, int n) {
     //0x XXXX YYYY ZZZZ ZZZZ ZZZZ
     //             ^z0         ^z7
@@ -210,14 +210,14 @@ static void permute(BitstreamIn *p_in, uint64_t z, int l, int r, BitstreamOut *o
         return;
 
     bool pn = tailBit(p_in);
-    if (pn) { // pn = 1
+    if (pn) { 
+        // pn = 1
         uint8_t zl = getSixBitByte(z, l);
-
         push6bits(out, zl + 1);
         permute(p_in, z, l + 1, r, out);
-    } else { // otherwise
+    } else { 
+        // otherwise
         uint8_t zr = getSixBitByte(z, r);
-
         push6bits(out, zr);
         permute(p_in, z, l, r + 1, out);
     }
@@ -226,6 +226,7 @@ static void permute(BitstreamIn *p_in, uint64_t z, int l, int r, BitstreamOut *o
 static void printState(const char *desc, uint64_t c) {
     if (g_debugMode == 0)
         return;
+
     char s[60] = {0};
     snprintf(s, sizeof(s), "%s : ", desc);
 
@@ -254,8 +255,10 @@ static void printState(const char *desc, uint64_t c) {
 void hash0(uint64_t c, uint8_t k[8]) {
     c = swapZvalues(c);
 
+    if (g_debugMode > 0) {
     PrintAndLogEx(DEBUG, "          | x| y|z0|z1|z2|z3|z4|z5|z6|z7|");
     printState("origin", c);
+    }
     //These 64 bits are divided as c = x, y, z [0] , . . . , z [7]
     // x = 8 bits
     // y = 8 bits
@@ -266,9 +269,7 @@ void hash0(uint64_t c, uint8_t k[8]) {
 
     for (int n = 0;  n < 4 ; n++) {
         uint8_t zn = getSixBitByte(c, n);
-
         uint8_t zn4 = getSixBitByte(c, n + 4);
-
         uint8_t _zn = (zn % (63 - n)) + n;
         uint8_t _zn4 = (zn4 % (64 - n)) + n;
 
@@ -276,17 +277,18 @@ void hash0(uint64_t c, uint8_t k[8]) {
         pushbackSixBitByte(&zP, _zn4, n + 4);
     }
 
-    printState("0|0|z'", zP);
+    if (g_debugMode > 0) printState("0|0|z'", zP);
 
     uint64_t zCaret = check(zP);
-    printState("0|0|z^", zP);
+
+    if (g_debugMode > 0) printState("0|0|z^", zP);
 
     uint8_t p = pi[x % 35];
 
     if (x & 1) //Check if x7 is 1
         p = ~p;
 
-    PrintAndLogEx(DEBUG, "p: %02x", p);
+    if (g_debugMode > 0) PrintAndLogEx(DEBUG, "     p : %02x", p);
 
     BitstreamIn p_in = { &p, 8, 0 };
     uint8_t outbuffer[] = {0, 0, 0, 0, 0, 0, 0, 0};
@@ -301,9 +303,8 @@ void hash0(uint64_t c, uint8_t k[8]) {
 
     zTilde >>= 16;
 
-    printState("0|0|z~", zTilde);
+    if (g_debugMode > 0) printState("0|0|z~", zTilde);
 
-//    int zerocounter = 0 ;
     for (int i = 0; i < 8; i++) {
         // the key on index i is first a bit from y
         // then six bits from z,
@@ -317,8 +318,6 @@ void hash0(uint64_t c, uint8_t k[8]) {
         // First, place y(7-i) leftmost in k
         k[i] |= (y  << (7 - i)) & 0x80 ;
 
-
-
         uint8_t zTilde_i = getSixBitByte(zTilde, i);
         // zTildeI is now on the form 00XXXXXX
         // with one leftshift, it'll be
@@ -342,9 +341,6 @@ void hash0(uint64_t c, uint8_t k[8]) {
             k[i] |= zTilde_i & 0x7E;
             k[i] |= (~p_i) & 1;
         }
-//        if ((k[i] & 1) == 0) {
-//            zerocounter++;
-//        }
     }
 }
 /**
@@ -354,18 +350,17 @@ void hash0(uint64_t c, uint8_t k[8]) {
  * @param div_key
  */
 void diversifyKey(uint8_t *csn, uint8_t *key, uint8_t *div_key) {
-    // Prepare the DES key
-    mbedtls_des_setkey_enc(&ctx_enc, key);
 
     uint8_t crypted_csn[8] = {0};
 
     // Calculate DES(CSN, KEY)
+    mbedtls_des_context ctx_enc;
+    mbedtls_des_setkey_enc(&ctx_enc, key);
     mbedtls_des_crypt_ecb(&ctx_enc, csn, crypted_csn);
+    mbedtls_des_free(&ctx_enc);
 
     //Calculate HASH0(DES))
     uint64_t c_csn = x_bytes_to_num(crypted_csn, sizeof(crypted_csn));
-    //uint64_t crypted_csn_swapped = swapZvalues(crypt_csn);
-
     hash0(c_csn, div_key);
 }
 /*
@@ -420,28 +415,38 @@ typedef struct {
     uint8_t uid[8];
     uint8_t t_key[8];
     uint8_t div_key[8];
-} Testcase;
+} testcase_t;
 
-static int testDES(Testcase testcase) {
+static int testDES(uint8_t *key, testcase_t testcase) {
     uint8_t des_encrypted_csn[8] = {0};
     uint8_t decrypted[8] = {0};
     uint8_t div_key[8] = {0};
+    
+    mbedtls_des_context ctx_enc;
+    mbedtls_des_context ctx_dec;
+
+    mbedtls_des_setkey_enc(&ctx_enc, key);
+    mbedtls_des_setkey_dec(&ctx_dec, key);
+
     int retval = mbedtls_des_crypt_ecb(&ctx_enc, testcase.uid, des_encrypted_csn);
     retval |= mbedtls_des_crypt_ecb(&ctx_dec, des_encrypted_csn, decrypted);
 
+    mbedtls_des_free(&ctx_enc);
+    mbedtls_des_free(&ctx_dec);
+
     if (memcmp(testcase.uid, decrypted, 8) != 0) {
         //Decryption fail
         PrintAndLogEx(FAILED, "Encryption <-> Decryption FAIL");
-        printarr("Input", testcase.uid, 8);
-        printarr("Decrypted", decrypted, 8);
+        printarr("    input", testcase.uid, 8);
+        printarr("    decrypted", decrypted, 8);
         retval = 1;
     }
 
     if (memcmp(des_encrypted_csn, testcase.t_key, 8) != 0) {
         //Encryption fail
         PrintAndLogEx(FAILED, "Encryption != Expected result");
-        printarr("Output", des_encrypted_csn, 8);
-        printarr("Expected", testcase.t_key, 8);
+        printarr("    output", des_encrypted_csn, 8);
+        printarr("    expected", testcase.t_key, 8);
         retval = 1;
     }
     uint64_t crypted_csn = x_bytes_to_num(des_encrypted_csn, 8);
@@ -453,7 +458,7 @@ static int testDES(Testcase testcase) {
         printarr("  csn   ", testcase.uid, 8);
         printarr("{csn}   ", des_encrypted_csn, 8);
         printarr("hash0   ", div_key, 8);
-        printarr("Expected", testcase.div_key, 8);
+        printarr("    expected", testcase.div_key, 8);
         retval = 1;
     }
     return retval;
@@ -461,9 +466,12 @@ static int testDES(Testcase testcase) {
 static bool des_getParityBitFromKey(uint8_t key) {
     // The top 7 bits is used
     bool parity = ((key & 0x80) >> 7)
-                  ^ ((key & 0x40) >> 6) ^ ((key & 0x20) >> 5)
-                  ^ ((key & 0x10) >> 4) ^ ((key & 0x08) >> 3)
-                  ^ ((key & 0x04) >> 2) ^ ((key & 0x02) >> 1);
+                ^ ((key & 0x40) >> 6)
+                ^ ((key & 0x20) >> 5)
+                ^ ((key & 0x10) >> 4)
+                ^ ((key & 0x08) >> 3)
+                ^ ((key & 0x04) >> 2)
+                ^ ((key & 0x02) >> 1);
     return !parity;
 }
 
@@ -480,11 +488,11 @@ static void des_checkParity(uint8_t *key) {
     if (fails) {
         PrintAndLogEx(FAILED, "parity fails: %d", fails);
     } else {
-        PrintAndLogEx(SUCCESS, "Key syntax is with parity bits inside each byte");
+        PrintAndLogEx(SUCCESS, "    Key syntax is with parity bits inside each byte (%s)", _GREEN_("ok"));
     }
 }
 
-Testcase testcases[] = {
+testcase_t testcases[] = {
 
     {{0x8B, 0xAC, 0x60, 0x1F, 0x53, 0xB8, 0xED, 0x11}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x02, 0x04, 0x06, 0x08, 0x01, 0x03, 0x05, 0x07}},
     {{0xAE, 0x51, 0xE5, 0x62, 0xE7, 0x9A, 0x99, 0x39}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, {0x04, 0x02, 0x06, 0x08, 0x01, 0x03, 0x05, 0x07}},
@@ -555,14 +563,14 @@ Testcase testcases[] = {
     {{0}, {0}, {0}}
 };
 
-static int testKeyDiversificationWithMasterkeyTestcases(void) {
+static int testKeyDiversificationWithMasterkeyTestcases(uint8_t *key) {
     int i, error = 0;
     uint8_t empty[8] = {0};
 
     PrintAndLogEx(INFO, "Testing encryption/decryption");
 
     for (i = 0; memcmp(testcases + i, empty, 8); i++)
-        error += testDES(testcases[i]);
+        error += testDES(key, testcases[i]);
 
     if (error)
         PrintAndLogEx(FAILED, "%d errors occurred (%d testcases)", error, i);
@@ -581,7 +589,7 @@ static int testCryptedCSN(uint64_t crypted_csn, uint64_t expected) {
     PrintAndLogEx(DEBUG, "");
     PrintAndLogEx(DEBUG, "    {csn}      %"PRIx64, crypted_csn);
     PrintAndLogEx(DEBUG, "    {csn-revz} %"PRIx64, crypted_csn_swapped);
-    PrintAndLogEx(DEBUG, "    hash0      %"PRIx64 "   (%s)", resultbyte, (resultbyte == expected) ?  _GREEN_("OK") : _RED_("FAIL"));
+    PrintAndLogEx(DEBUG, "    hash0      %"PRIx64 "   (%s)", resultbyte, (resultbyte == expected) ? _GREEN_("ok") : _RED_("fail"));
 
     if (resultbyte != expected) {
         PrintAndLogEx(DEBUG, "    expected       " _YELLOW_("%"PRIx64),  expected);
@@ -590,19 +598,22 @@ static int testCryptedCSN(uint64_t crypted_csn, uint64_t expected) {
     return PM3_SUCCESS;
 }
 
-static int testDES2(uint64_t csn, uint64_t expected) {
+static int testDES2(uint8_t *key, uint64_t csn, uint64_t expected) {
     uint8_t result[8] = {0};
     uint8_t input[8] = {0};
 
     PrintAndLogEx(DEBUG, "   csn      %"PRIx64, csn);
     x_num_to_bytes(csn, 8, input);
 
+    mbedtls_des_context ctx_enc;
+    mbedtls_des_setkey_enc(&ctx_enc, key);
     mbedtls_des_crypt_ecb(&ctx_enc, input, result);
+    mbedtls_des_free(&ctx_enc);
 
     uint64_t crypt_csn = x_bytes_to_num(result, 8);
 
     PrintAndLogEx(DEBUG, "   {csn}    %"PRIx64, crypt_csn);
-    PrintAndLogEx(DEBUG, "   expected %"PRIx64 "    (%s)", expected, (expected == crypt_csn) ? _GREEN_("OK") : _RED_("FAIL"));
+    PrintAndLogEx(DEBUG, "   expected %"PRIx64 "    (%s)", expected, (expected == crypt_csn) ? _GREEN_("ok") : _RED_("fail") );
 
     if (expected != crypt_csn)
         return PM3_ESOFT;
@@ -619,8 +630,7 @@ static int doTestsWithKnownInputs(void) {
     PrintAndLogEx(INFO, "Testing DES encryption");
     uint8_t key[8] = {0x6c, 0x8d, 0x44, 0xf9, 0x2a, 0x2d, 0x01, 0xbf};
 
-    mbedtls_des_setkey_enc(&ctx_enc, key);
-    testDES2(0xbbbbaaaabbbbeeee, 0xd6ad3ca619659e6b);
+    testDES2(key, 0xbbbbaaaabbbbeeee, 0xd6ad3ca619659e6b);
 
     PrintAndLogEx(INFO, "Testing hashing algorithm");
 
@@ -681,11 +691,10 @@ int doKeyTests(void) {
             PrintAndLogEx(SUCCESS, "Key present");
             PrintAndLogEx(SUCCESS, "Checking key parity...");
             des_checkParity(key);
-            mbedtls_des_setkey_enc(&ctx_enc, key);
-            mbedtls_des_setkey_dec(&ctx_dec, key);
+
             // Test hashing functions
             PrintAndLogEx(SUCCESS, "The following tests require the correct 8-byte master key");
-            testKeyDiversificationWithMasterkeyTestcases();
+            testKeyDiversificationWithMasterkeyTestcases(key);
         }
     }
     PrintAndLogEx(INFO, "Testing key diversification with non-sensitive keys...");
diff --git a/client/src/scripting.c b/client/src/scripting.c
index f594bd3aa..6ac012199 100644
--- a/client/src/scripting.c
+++ b/client/src/scripting.c
@@ -1347,7 +1347,7 @@ int set_pm3_libraries(lua_State *L) {
         {"WaitForResponseTimeout",      l_WaitForResponseTimeout},
         {"mfDarkside",                  l_mfDarkside},
         {"foobar",                      l_foobar},
-        {"kbd_enter_pressed",               l_kbd_enter_pressed},
+        {"kbd_enter_pressed",           l_kbd_enter_pressed},
         {"clearCommandBuffer",          l_clearCommandBuffer},
         {"console",                     l_CmdConsole},
         {"iso15693_crc",                l_iso15693_crc},
diff --git a/doc/cheatsheet.md b/doc/cheatsheet.md
index e725d8d25..3a19dd553 100644
--- a/doc/cheatsheet.md
+++ b/doc/cheatsheet.md
@@ -109,19 +109,20 @@ Print keystore
 ```
 Options
 ---
-p           : print keys loaded into memory
+-p, --print                    Print keys loaded into memory
 
-pm3 --> hf iclass managekeys p
+
+pm3 --> hf iclass managekeys -p
 ```
 
 Add key to keystore [0-7]
 ```
 Options
 ---
-n <keynbr>    : specify the keyNbr to set in memory
-k <key>       : set a key in memory
+-f, --file <filename>          Specify a filename to use with load or save operations
+    --ki <dec>                 Specify key index to set key in memory
 
-pm3 --> hf iclass managekeys n 3 k AFA785A7DAB33378
+pm3 --> hf iclass managekeys --ki 3 -k AFA785A7DAB33378
 ```
 
 Encrypt iCLASS Block
@@ -167,20 +168,23 @@ Simulate iCLASS
 ```
 Options
 ---
-0 <CSN>     simulate the given CSN
+-t, --type <int>               Simulation type to use
+    --csn <hex>                Specify CSN as 8 bytes (16 hex symbols) to use with sim type 0
+Types:
+0           simulate the given CSN
 1           simulate default CSN
 2           Runs online part of LOCLASS attack
 3           Full simulation using emulator memory (see 'hf iclass eload')
 4           Runs online part of LOCLASS attack against reader in keyroll mode
 
-pm3 --> hf iclass sim 3
+pm3 --> hf iclass sim -t 3
 ```
 
 Simulate iCLASS Sequence
 ```
 pm3 --> hf iclass dump --ki 0
 pm3 --> hf iclass eload -f hf-iclass-db883702f8ff12e0.bin
-pm3 --> hf iclass sim 3
+pm3 --> hf iclass sim -t 3
 ```
 
 Extract custom iCLASS key (loclass attack)
@@ -189,11 +193,11 @@ Options
 ---
 f <filename>   : specify a filename to clone from
 k <key>        : Access Key as 16 hex symbols or 1 hex to select key from memory
-e              : If 'e' is specified, elite computations applied to key
+--elite        : Elite computations applied to key
 
-pm3 --> hf iclass sim 2
+pm3 --> hf iclass sim -t 2
 pm3 --> hf iclass loclass -f iclass_mac_attack.bin
-pm3 --> hf iclass managekeys n 7 k <Kcus>
+pm3 --> hf iclass managekeys --ki 7 -k <Kcus>
 pm3 --> hf iclass dump --ki 7 --elite
 ```
 
@@ -201,13 +205,14 @@ Verify custom iCLASS key
 ```
 Options
 ---
-f <filename> : Dictionary file with default iCLASS keys
-u            : CSN
-p            : EPURSE
-m            : macs
-e            : elite
+-f, --file <filename>          Dictionary file with default iclass keys
+    --csn <hex>                Specify CSN as 8 bytes (16 hex symbols)
+    --epurse <hex>             Specify ePurse as 8 bytes (16 hex symbols)
+    --macs <hex>               MACs
+    --raw                      no computations applied to key (raw)
+    --elite                    Elite computations applied to key
 
-pm3 --> hf iclass lookup u 010a0ffff7ff12e0 p feffffffffffffff m 66348979153c41b9 f iclass_default_keys e
+pm3 --> hf iclass lookup --csn 010a0ffff7ff12e0 --epurse feffffffffffffff --macs 66348979153c41b9 -f iclass_default_keys --elite
 ```
 
 ## MIFARE
diff --git a/doc/cliparser_todo.txt b/doc/cliparser_todo.txt
new file mode 100644
index 000000000..4e8c4e36b
--- /dev/null
+++ b/doc/cliparser_todo.txt
@@ -0,0 +1,329 @@
+clear
+pref
+rem
+quit
+exit
+analyse lcr
+analyse crc
+analyse chksum
+analyse dates
+analyse tea
+analyse lfsr
+analyse a
+analyse nuid
+analyse demodbuff
+analyse freq
+data biphaserawdecode
+data detectclock
+data fsktonrz
+data manrawdecode
+data rawdemod
+data askedgedetect
+data autocorr
+data dirthreshold
+data hide
+data hpf
+data iir
+data grid
+data ltrim
+data mtrim
+data norm
+data plot
+data rtrim
+data setgraphmarkers
+data shiftgraphzero
+data zerocrossings
+data convertbitstream
+data getbitstream
+data bin2hex
+data bitsamples
+data clear
+data hexsamples
+data hex2bin
+data print
+data samples
+data setdebugmode
+data tune
+emv list
+hf list
+hf tune
+hf search
+hf sniff
+hf 14a list
+hf 14a reader
+hf 14a cuids
+hf 14a sim
+hf 14a sniff
+hf 14a config
+hf 14b list
+hf 14b sriwrite
+hf 15 list
+hf 15 dump
+hf 15 info
+hf 15 raw
+hf 15 rdbl
+hf 15 readmulti
+hf 15 restore
+hf 15 wrbl
+hf 15 writeafi
+hf 15 writedsfid
+hf epa cnonces
+hf epa preplay
+hf felica list
+hf felica reader
+hf felica sniff
+hf felica raw
+hf felica rdunencrypted
+hf felica wrunencrypted
+hf felica rqservice
+hf felica rqresponse
+hf felica scsvcode
+hf felica rqsyscode
+hf felica auth1
+hf felica auth2
+hf felica rqspecver
+hf felica resetmode
+hf felica litesim
+hf felica litedump
+hf fido list
+hf fido info
+hf iclass info
+hf iclass list
+hf legic list
+hf legic reader
+hf legic info
+hf legic dump
+hf legic restore
+hf legic rdbl
+hf legic sim
+hf legic wrbl
+hf legic crc
+hf legic eload
+hf legic esave
+hf legic wipe
+hf lto dump
+hf lto restore
+hf lto info
+hf lto rdbl
+hf lto wrbl
+hf lto list
+hf mf list
+hf mf darkside
+hf mf nested
+hf mf hardnested
+hf mf staticnested
+hf mf autopwn
+hf mf nack
+hf mf chk
+hf mf fchk
+hf mf decrypt
+hf mf dump
+hf mf rdbl
+hf mf rdsc
+hf mf restore
+hf mf setmod
+hf mf wrbl
+hf mf sim
+hf mf ecfill
+hf mf eclr
+hf mf egetblk
+hf mf egetsc
+hf mf ekeyprn
+hf mf eload
+hf mf esave
+hf mf eset
+hf mf eview
+hf mf cgetblk
+hf mf cgetsc
+hf mf cload
+hf mf csave
+hf mf csetblk
+hf mf csetuid
+hf mf cview
+hf mf gen3uid
+hf mf gen3blk
+hf mf gen3freeze
+hf mf ice
+hf mfp info
+hf mfu info
+hf mfu dump
+hf mfu restore
+hf mfu eload
+hf mfu rdbl
+hf mfu wrbl
+hf mfu cauth
+hf mfu setpwd
+hf mfu setuid
+hf mfu sim
+hf mfu gen
+hf mfu pwdgen
+hf mfu otptear
+hf mfdes enum
+hf mfdes getuid
+hf mfdes info
+hf mfdes list
+hf st list
+hf thinfilm info
+hf thinfilm list
+hf thinfilm sim
+hf topaz list
+hf topaz info
+hf topaz reader
+hf topaz sim
+hf topaz sniff
+hf topaz raw
+hw connect
+hw dbg
+hw detectreader
+hw fpgaoff
+hw lcd
+hw lcdreset
+hw ping
+hw readmem
+hw reset
+hw setlfdivisor
+hw setmux
+hw standalone
+hw status
+hw tia
+hw tune
+hw version
+lf config
+lf cmdread
+lf read
+lf search
+lf sim
+lf simask
+lf simfsk
+lf simpsk
+lf simbidir
+lf sniff
+lf tune
+lf awid demod
+lf awid read
+lf awid clone
+lf awid sim
+lf awid brute
+lf awid watch
+lf cotag demod
+lf cotag read
+lf destron demod
+lf destron read
+lf destron sim
+lf em 410x_demod
+lf em 410x_read
+lf em 410x_sim
+lf em 410x_brute
+lf em 410x_watch
+lf em 410x_spoof
+lf em 410x_clone
+lf em 4x05_demod
+lf em 4x05_dump
+lf em 4x05_wipe
+lf em 4x05_info
+lf em 4x05_read
+lf em 4x05_write
+lf em 4x50_dump
+lf em 4x50_info
+lf em 4x50_write
+lf em 4x50_write_password
+lf em 4x50_read
+lf em 4x50_wipe
+lf fdxb demod
+lf fdxb read
+lf fdxb clone
+lf fdxb sim
+lf gallagher demod
+lf gallagher read
+lf gallagher clone
+lf gallagher sim
+lf gproxii demod
+lf gproxii read
+lf gproxii clone
+lf gproxii sim
+lf hid demod
+lf hid read
+lf hitag list
+lf hitag info
+lf hitag reader
+lf hitag sim
+lf hitag sniff
+lf hitag writer
+lf hitag dump
+lf hitag cc
+lf idteck demod
+lf idteck read
+lf indala demod
+lf indala altdemod
+lf indala read
+lf indala sim
+lf io demod
+lf io read
+lf io clone
+lf io sim
+lf io watch
+lf jablotron demod
+lf jablotron read
+lf jablotron clone
+lf jablotron sim
+lf keri demod
+lf motorola demod
+lf motorola sim
+lf nedap demod
+lf nedap generate
+lf nedap read
+lf nedap clone
+lf nedap sim
+lf nexwatch demod
+lf noralsy demod
+lf pac demod
+lf paradox demod
+lf pcf7931 read
+lf pcf7931 write
+lf pcf7931 config
+lf presco demod
+lf pyramid demod
+lf securakey demod
+lf ti demod
+lf ti write
+lf t55xx config
+lf t55xx dangerraw
+lf t55xx detect
+lf t55xx deviceconfig
+lf t55xx dump
+lf t55xx info
+lf t55xx p1detect
+lf t55xx read
+lf t55xx resetread
+lf t55xx restore
+lf t55xx trace
+lf t55xx wakeup
+lf t55xx write
+lf t55xx bruteforce
+lf t55xx chk
+lf t55xx protect
+lf t55xx recoverpw
+lf t55xx sniff
+lf t55xx special
+lf t55xx wipe
+lf viking demod
+lf visa2000 demod
+mem spiffs
+smart list
+smart info
+smart reader
+smart raw
+smart upgrade
+smart setclock
+smart brute
+script list
+script run
+usart btpin
+usart btfactory
+usart tx
+usart rx
+usart txrx
+usart txhex
+usart rxhex
+usart config
+wiegand list
diff --git a/doc/commands.md b/doc/commands.md
index bc0855668..57038cbba 100644
--- a/doc/commands.md
+++ b/doc/commands.md
@@ -38,7 +38,6 @@ Check column "offline" for their availability.
 |`analyse nuid           `|Y       |`create NUID from 7byte UID`
 |`analyse demodbuff      `|Y       |`Load binary string to demodbuffer`
 |`analyse freq           `|Y       |`Calc wave lengths`
-|`analyse foo            `|Y       |`muxer`
 
 
 ### data
@@ -733,7 +732,7 @@ Check column "offline" for their availability.
 |-------                  |------- |-----------
 |`lf keri help           `|Y       |`This help`
 |`lf keri demod          `|Y       |`Demodulate an KERI tag from the GraphBuffer`
-|`lf keri read           `|N       |`Attempt to read and extract tag data from the antenna`
+|`lf keri reader         `|N       |`Attempt to read and extract tag data from the antenna`
 |`lf keri clone          `|N       |`clone KERI tag to T55x7 or Q5/T5555`
 |`lf keri sim            `|N       |`simulate KERI tag`
 
@@ -746,7 +745,7 @@ Check column "offline" for their availability.
 |-------                  |------- |-----------
 |`lf motorola help       `|Y       |`This help`
 |`lf motorola demod      `|Y       |`Demodulate an MOTOROLA tag from the GraphBuffer`
-|`lf motorola read       `|N       |`Attempt to read and extract tag data from the antenna`
+|`lf motorola reader     `|N       |`Attempt to read and extract tag data from the antenna`
 |`lf motorola clone      `|N       |`clone MOTOROLA tag to T55x7`
 |`lf motorola sim        `|N       |`simulate MOTOROLA tag`
 
diff --git a/doc/loclass_notes.md b/doc/loclass_notes.md
index f9280119b..741a81023 100644
--- a/doc/loclass_notes.md
+++ b/doc/loclass_notes.md
@@ -4,7 +4,7 @@ This document is primarily intended for understanding `hf iclass loclass` and fi
 
 LOCLASS aim is to recover the used masterkey for that specific reader configured in Elite mode / High Security mode.
 
-LOCLASS, is a two part attack. First is the online part where you gather needed information from the reader by presenting a carefully selected CSN and save the responses to file.  For the first part you run `hf iclass sim 2` and take notice of the saved filename.
+LOCLASS, is a two part attack. First is the online part where you gather needed information from the reader by presenting a carefully selected CSN and save the responses to file.  For the first part you run `hf iclass sim -t 2` and take notice of the saved filename.
 
 The second part is offline,  where the information gathered from the first step is used in a series of DES operations to figure out the used 
 masterkey.
@@ -21,6 +21,6 @@ run `hf iclass loclass --test`.
 This test mode uses two files. 
 
 - `iclass_dump.bin`
-   this is a sample file from `hf iclass sim 2`, with complete keytable recovery, using 128 carefully selected CSN and the file contains the MAC results from reader. 
+   this is a sample file from `hf iclass sim -t 2`, with complete keytable recovery, using 128 carefully selected CSN and the file contains the MAC results from reader. 
 - `iclass_key.bin`
    this is file shall contain the legacy masterkey, AA1 key. loclass uses it to verify that permutation / reversing / generation of key is correct.
\ No newline at end of file
diff --git a/tools/pm3_tests.sh b/tools/pm3_tests.sh
index de3a50c5e..6edfc80ea 100755
--- a/tools/pm3_tests.sh
+++ b/tools/pm3_tests.sh
@@ -433,7 +433,7 @@ while true; do
                                                                      "Paradox - ID: 004209dea FC: 96 Card: 40426, Checksum: b2, Raw: 0f55555695596a6a9999a59a"; then break; fi
       if ! CheckExecute slow "lf T55 presco test"                "$CLIENTBIN -c 'data load -f traces/lf_ATA5577_presco.pm3; lf search 1'" "Presco ID found"; then break; fi
       if ! CheckExecute slow "lf T55 presco test2"               "$CLIENTBIN -c 'data load -f traces/lf_ATA5577_presco.pm3; lf presco demod'" \
-                                                                     "Presco - Card: 1E8021D9, Raw: 10D0000000000000000000001E8021D9"; then break; fi
+                                                                     "Presco Site code: 30 User code: 8665 Full code: 1E8021D9 Raw: 10D0000000000000000000001E8021D9"; then break; fi
       if ! CheckExecute slow "lf T55 pyramid test"               "$CLIENTBIN -c 'data load -f traces/lf_ATA5577_pyramid.pm3; lf search 1'" "Pyramid ID found"; then break; fi
       if ! CheckExecute slow "lf T55 pyramid test2"              "$CLIENTBIN -c 'data load -f traces/lf_ATA5577_pyramid.pm3; lf pyramid demod'" \
                                                                      "Pyramid - len: 26, FC: 123 Card: 11223 - Wiegand: 2f657ae, Raw: 00010101010101010101016eb35e5da4"; then break; fi
@@ -450,7 +450,7 @@ while true; do
       echo -e "\n${C_BLUE}Testing HF:${C_NC}"
       if ! CheckExecute "hf mf offline text"               "$CLIENTBIN -c 'hf mf'" "at_enc"; then break; fi
       if ! CheckExecute slow retry ignore "hf mf hardnested long test"  "$CLIENTBIN -c 'hf mf hardnested t 1 000000000000'" "found:"; then break; fi
-      if ! CheckExecute slow "hf iclass long test"         "$CLIENTBIN -c 'hf iclass loclass --long'" "verified ok"; then break; fi
+      if ! CheckExecute slow "hf iclass long test"         "$CLIENTBIN -c 'hf iclass loclass --long'" "verified (ok)"; then break; fi
       if ! CheckExecute slow "emv long test"               "$CLIENTBIN -c 'emv test -l'" "Test(s) \[ ok"; then break; fi
       if ! $SLOWTESTS; then
         if ! CheckExecute "hf iclass test"                 "$CLIENTBIN -c 'hf iclass loclass --test'" "key diversification (ok)"; then break; fi