diff --git a/client/cmdhf14a.c b/client/cmdhf14a.c
index 219fb7c0c..1468d5b65 100644
--- a/client/cmdhf14a.c
+++ b/client/cmdhf14a.c
@@ -106,80 +106,80 @@ char* getTagInfo(uint8_t uid) {
 }
 
 int usage_hf_14a_sim(void) {
-//	PrintAndLog("\n Emulating ISO/IEC 14443 type A tag with 4,7 or 10 byte UID\n");
-	PrintAndLog("\n Emulating ISO/IEC 14443 type A tag with 4,7 byte UID\n");
-	PrintAndLog("Usage: hf 14a sim [h] t <type> u <uid> [x] [e] [v]");
-	PrintAndLog("Options:");
-	PrintAndLog("    h     : This help");
-	PrintAndLog("    t     : 1 = MIFARE Classic 1k");
-	PrintAndLog("            2 = MIFARE Ultralight");
-	PrintAndLog("            3 = MIFARE Desfire");
-	PrintAndLog("            4 = ISO/IEC 14443-4");
-	PrintAndLog("            5 = MIFARE Tnp3xxx");
-	PrintAndLog("            6 = MIFARE Mini");
-	PrintAndLog("            7 = AMIIBO (NTAG 215),  pack 0x8080");
-	PrintAndLog("            8 = MIFARE Classic 4k");
-//	PrintAndLog("    u     : 4, 7 or 10 byte UID");
-	PrintAndLog("    u     : 4, 7 byte UID");
-	PrintAndLog("    x     : (Optional) Performs the 'reader attack', nr/ar attack against a reader");
-	PrintAndLog("    e     : (Optional) Fill simulator keys from found keys");	
-	PrintAndLog("    v     : (Optional) Verbose");
-	PrintAndLog("Examples:");
-	PrintAndLog("          hf 14a sim t 1 u 11223344 x");
-	PrintAndLog("          hf 14a sim t 1 u 11223344");
-	PrintAndLog("          hf 14a sim t 1 u 11223344556677");
-//	PrintAndLog("          hf 14a sim t 1 u 11223445566778899AA\n");
+//	PrintAndLogEx(NORMAL, "\n Emulating ISO/IEC 14443 type A tag with 4,7 or 10 byte UID\n");
+	PrintAndLogEx(NORMAL, "\n Emulating ISO/IEC 14443 type A tag with 4,7 byte UID\n");
+	PrintAndLogEx(NORMAL, "Usage: hf 14a sim [h] t <type> u <uid> [x] [e] [v]");
+	PrintAndLogEx(NORMAL, "Options:");
+	PrintAndLogEx(NORMAL, "    h     : This help");
+	PrintAndLogEx(NORMAL, "    t     : 1 = MIFARE Classic 1k");
+	PrintAndLogEx(NORMAL, "            2 = MIFARE Ultralight");
+	PrintAndLogEx(NORMAL, "            3 = MIFARE Desfire");
+	PrintAndLogEx(NORMAL, "            4 = ISO/IEC 14443-4");
+	PrintAndLogEx(NORMAL, "            5 = MIFARE Tnp3xxx");
+	PrintAndLogEx(NORMAL, "            6 = MIFARE Mini");
+	PrintAndLogEx(NORMAL, "            7 = AMIIBO (NTAG 215),  pack 0x8080");
+	PrintAndLogEx(NORMAL, "            8 = MIFARE Classic 4k");
+//	PrintAndLogEx(NORMAL, "    u     : 4, 7 or 10 byte UID");
+	PrintAndLogEx(NORMAL, "    u     : 4, 7 byte UID");
+	PrintAndLogEx(NORMAL, "    x     : (Optional) Performs the 'reader attack', nr/ar attack against a reader");
+	PrintAndLogEx(NORMAL, "    e     : (Optional) Fill simulator keys from found keys");	
+	PrintAndLogEx(NORMAL, "    v     : (Optional) Verbose");
+	PrintAndLogEx(NORMAL, "Examples:");
+	PrintAndLogEx(NORMAL, "          hf 14a sim t 1 u 11223344 x");
+	PrintAndLogEx(NORMAL, "          hf 14a sim t 1 u 11223344");
+	PrintAndLogEx(NORMAL, "          hf 14a sim t 1 u 11223344556677");
+//	PrintAndLogEx(NORMAL, "          hf 14a sim t 1 u 11223445566778899AA\n");
 	return 0;
 }
 int usage_hf_14a_sniff(void) {
-	PrintAndLog("It get data from the field and saves it into command buffer.");
-	PrintAndLog("Buffer accessible from command 'hf list 14a'");
-	PrintAndLog("Usage:  hf 14a sniff [c][r]");
-	PrintAndLog("c - triggered by first data from card");
-	PrintAndLog("r - triggered by first 7-bit request from reader (REQ,WUP,...)");
-	PrintAndLog("Examples:");
-	PrintAndLog("        hf 14a sniff c r");
+	PrintAndLogEx(NORMAL, "It get data from the field and saves it into command buffer.");
+	PrintAndLogEx(NORMAL, "Buffer accessible from command 'hf list 14a'");
+	PrintAndLogEx(NORMAL, "Usage:  hf 14a sniff [c][r]");
+	PrintAndLogEx(NORMAL, "c - triggered by first data from card");
+	PrintAndLogEx(NORMAL, "r - triggered by first 7-bit request from reader (REQ,WUP,...)");
+	PrintAndLogEx(NORMAL, "Examples:");
+	PrintAndLogEx(NORMAL, "        hf 14a sniff c r");
 	return 0;
 }
 int usage_hf_14a_raw(void) {
-	PrintAndLog("Usage: hf 14a raw [-h] [-r] [-c] [-p] [-a] [-T] [-t] <milliseconds> [-b] <number of bits>  <0A 0B 0C ... hex>");
-	PrintAndLog("       -h    this help");
-	PrintAndLog("       -r    do not read response");
-	PrintAndLog("       -c    calculate and append CRC");
-	PrintAndLog("       -p    leave the signal field ON after receive");
-	PrintAndLog("       -a    active signal field ON without select");
-	PrintAndLog("       -s    active signal field ON with select");
-	PrintAndLog("       -b    number of bits to send. Useful for send partial byte");
-	PrintAndLog("       -t    timeout in ms");
-	PrintAndLog("       -T    use Topaz protocol to send command");
-	PrintAndLog("       -3    ISO14443-3 select only (skip RATS)");
+	PrintAndLogEx(NORMAL, "Usage: hf 14a raw [-h] [-r] [-c] [-p] [-a] [-T] [-t] <milliseconds> [-b] <number of bits>  <0A 0B 0C ... hex>");
+	PrintAndLogEx(NORMAL, "       -h    this help");
+	PrintAndLogEx(NORMAL, "       -r    do not read response");
+	PrintAndLogEx(NORMAL, "       -c    calculate and append CRC");
+	PrintAndLogEx(NORMAL, "       -p    leave the signal field ON after receive");
+	PrintAndLogEx(NORMAL, "       -a    active signal field ON without select");
+	PrintAndLogEx(NORMAL, "       -s    active signal field ON with select");
+	PrintAndLogEx(NORMAL, "       -b    number of bits to send. Useful for send partial byte");
+	PrintAndLogEx(NORMAL, "       -t    timeout in ms");
+	PrintAndLogEx(NORMAL, "       -T    use Topaz protocol to send command");
+	PrintAndLogEx(NORMAL, "       -3    ISO14443-3 select only (skip RATS)");
 	return 0;
 }
 int usage_hf_14a_reader(void) {
-	PrintAndLog("Usage: hf 14a reader [k|s|x] [3]");
-	PrintAndLog("       k    keep the field active after command executed");
-	PrintAndLog("       s    silent (no messages)");
-	PrintAndLog("       x    just drop the signal field");
-	PrintAndLog("       3    ISO14443-3 select only (skip RATS)");
+	PrintAndLogEx(NORMAL, "Usage: hf 14a reader [k|s|x] [3]");
+	PrintAndLogEx(NORMAL, "       k    keep the field active after command executed");
+	PrintAndLogEx(NORMAL, "       s    silent (no messages)");
+	PrintAndLogEx(NORMAL, "       x    just drop the signal field");
+	PrintAndLogEx(NORMAL, "       3    ISO14443-3 select only (skip RATS)");
 	return 0;
 }
 int usage_hf_14a_info(void){
-	PrintAndLog("This command makes more extensive tests against a ISO14443a tag in order to collect information");
-	PrintAndLog("Usage: hf 14a info [h|s]");
-	PrintAndLog("       s    silent (no messages)");
-	PrintAndLog("       n    test for nack bug");
+	PrintAndLogEx(NORMAL, "This command makes more extensive tests against a ISO14443a tag in order to collect information");
+	PrintAndLogEx(NORMAL, "Usage: hf 14a info [h|s]");
+	PrintAndLogEx(NORMAL, "       s    silent (no messages)");
+	PrintAndLogEx(NORMAL, "       n    test for nack bug");
 	return 0;
 }
 int usage_hf_14a_apdu(void) {
-	PrintAndLog("Usage: hf 14a apdu [-s] [-k] [-t] <APDU (hex)>");
-	PrintAndLog("       -s    activate field and select card");
-	PrintAndLog("       -k    leave the signal field ON after receive response");
-	PrintAndLog("       -t    executes TLV decoder if it possible. TODO!!!!");
+	PrintAndLogEx(NORMAL, "Usage: hf 14a apdu [-s] [-k] [-t] <APDU (hex)>");
+	PrintAndLogEx(NORMAL, "       -s    activate field and select card");
+	PrintAndLogEx(NORMAL, "       -k    leave the signal field ON after receive response");
+	PrintAndLogEx(NORMAL, "       -t    executes TLV decoder if it possible. TODO!!!!");
 	return 0;
 }
 
 int CmdHF14AList(const char *Cmd) {
-	//PrintAndLog("Deprecated command, use 'hf list 14a' instead");
+	//PrintAndLogEx(NORMAL, "Deprecated command, use 'hf list 14a' instead");
 	CmdHFList("14a");
 	return 0;
 }
@@ -212,7 +212,7 @@ int CmdHF14AReader(const char *Cmd) {
 			cm &= ~ISO14A_CONNECT;
 			break;
 		default:
-			PrintAndLog("[!] Unknown command.");
+			PrintAndLogEx(WARNING, "Unknown command.");
 			return 1;
 		}	
 		
@@ -230,7 +230,7 @@ int CmdHF14AReader(const char *Cmd) {
 	if (ISO14A_CONNECT & cm) {
 	UsbCommand resp;
 	if (!WaitForResponseTimeout(CMD_ACK, &resp, 2500)) {
-		if (!silent) PrintAndLog("[!] iso14443a card select failed");
+		if (!silent) PrintAndLogEx(WARNING, "iso14443a card select failed");
 		DropField();
 		return 1;
 	}
@@ -247,32 +247,32 @@ int CmdHF14AReader(const char *Cmd) {
 	uint64_t select_status = resp.arg[0];
 	
 	if (select_status == 0) {
-		if (!silent) PrintAndLog("[!] iso14443a card select failed");
+		if (!silent) PrintAndLogEx(WARNING, "iso14443a card select failed");
 		DropField();
 		return 1;
 	}
 
 	if (select_status == 3) {
-		PrintAndLog("Card doesn't support standard iso14443-3 anticollision");
-		PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
+		PrintAndLogEx(NORMAL, "Card doesn't support standard iso14443-3 anticollision");
+		PrintAndLogEx(NORMAL, "ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
 		DropField();
 		return 1;
 	}
 
-	PrintAndLog(" UID : %s", sprint_hex(card.uid, card.uidlen));
-	PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
-	PrintAndLog(" SAK : %02x [%" PRIu64 "]", card.sak, resp.arg[0]);
+	PrintAndLogEx(NORMAL, " UID : %s", sprint_hex(card.uid, card.uidlen));
+	PrintAndLogEx(NORMAL, "ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
+	PrintAndLogEx(NORMAL, " SAK : %02x [%" PRIu64 "]", card.sak, resp.arg[0]);
 
 	if(card.ats_len >= 3) {			// a valid ATS consists of at least the length byte (TL) and 2 CRC bytes
-		PrintAndLog(" ATS : %s", sprint_hex(card.ats, card.ats_len));
+		PrintAndLogEx(NORMAL, " ATS : %s", sprint_hex(card.ats, card.ats_len));
 	}
 		if (!disconnectAfter) {
-			if (!silent) PrintAndLog("[+] Card is selected. You can now start sending commands");
+			if (!silent) PrintAndLogEx(SUCCESS, "Card is selected. You can now start sending commands");
 		}
 	}
 
 	if (disconnectAfter) {
-		if (!silent)  PrintAndLog("[+] field dropped.");
+		if (!silent)  PrintAndLogEx(SUCCESS, "field dropped.");
 	}
 
 	return 0;
@@ -290,7 +290,7 @@ int CmdHF14AInfo(const char *Cmd) {
 	SendCommand(&c);
 	UsbCommand resp;
 	if (!WaitForResponseTimeout(CMD_ACK, &resp, 2500)) {
-		if (!silent) PrintAndLog("[!] iso14443a card select failed");
+		if (!silent) PrintAndLogEx(WARNING, "iso14443a card select failed");
 		DropField();
 		return 0;
 	}
@@ -307,21 +307,21 @@ int CmdHF14AInfo(const char *Cmd) {
 	uint64_t select_status = resp.arg[0];
 	
 	if (select_status == 0) {
-		if (!silent) PrintAndLog("[!] iso14443a card select failed");
+		if (!silent) PrintAndLogEx(WARNING, "iso14443a card select failed");
 		DropField();
 		return 0;
 	}
 
 	if (select_status == 3) {
-		PrintAndLog("Card doesn't support standard iso14443-3 anticollision");
-		PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
+		PrintAndLogEx(NORMAL, "Card doesn't support standard iso14443-3 anticollision");
+		PrintAndLogEx(NORMAL, "ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
 		DropField();
 		return select_status;
 	}
 
-	PrintAndLog(" UID : %s", sprint_hex(card.uid, card.uidlen));
-	PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
-	PrintAndLog(" SAK : %02x [%" PRIu64 "]", card.sak, resp.arg[0]);
+	PrintAndLogEx(NORMAL, " UID : %s", sprint_hex(card.uid, card.uidlen));
+	PrintAndLogEx(NORMAL, "ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
+	PrintAndLogEx(NORMAL, " SAK : %02x [%" PRIu64 "]", card.sak, resp.arg[0]);
 
 	bool isMifareClassic = true;
 	switch (card.sak) {
@@ -335,7 +335,7 @@ int CmdHF14AInfo(const char *Cmd) {
 			if (tagT != UL_ERROR)
 				ul_print_type(tagT, 0);
 			else 
-				PrintAndLog("TYPE: Possible AZTEK (iso14443a compliant)");
+				PrintAndLogEx(NORMAL, "TYPE: Possible AZTEK (iso14443a compliant)");
 
 			// reconnect for further tests
 			c.arg[0] = ISO14A_CONNECT | ISO14A_NO_DISCONNECT;
@@ -355,25 +355,25 @@ int CmdHF14AInfo(const char *Cmd) {
 				return 0;
 			}
 			break;
-		case 0x01: PrintAndLog("TYPE : NXP TNP3xxx Activision Game Appliance"); break;
-		case 0x04: PrintAndLog("TYPE : NXP MIFARE (various !DESFire !DESFire EV1)"); isMifareClassic = false; break;
-		case 0x08: PrintAndLog("TYPE : NXP MIFARE CLASSIC 1k | Plus 2k SL1 | 1k Ev1"); break;
-		case 0x09: PrintAndLog("TYPE : NXP MIFARE Mini 0.3k"); break;
-		case 0x10: PrintAndLog("TYPE : NXP MIFARE Plus 2k SL2"); break;
-		case 0x11: PrintAndLog("TYPE : NXP MIFARE Plus 4k SL2"); break;
-		case 0x18: PrintAndLog("TYPE : NXP MIFARE Classic 4k | Plus 4k SL1 | 4k Ev1"); break;
-		case 0x20: PrintAndLog("TYPE : NXP MIFARE DESFire 4k | DESFire EV1 2k/4k/8k | Plus 2k/4k SL3 | JCOP 31/41"); isMifareClassic = false; break;
-		case 0x24: PrintAndLog("TYPE : NXP MIFARE DESFire | DESFire EV1"); isMifareClassic = false; break;
-		case 0x28: PrintAndLog("TYPE : JCOP31 or JCOP41 v2.3.1"); break;
-		case 0x38: PrintAndLog("TYPE : Nokia 6212 or 6131 MIFARE CLASSIC 4K"); break;
-		case 0x88: PrintAndLog("TYPE : Infineon MIFARE CLASSIC 1K"); break;
-		case 0x98: PrintAndLog("TYPE : Gemplus MPCOS"); break;
+		case 0x01: PrintAndLogEx(NORMAL, "TYPE : NXP TNP3xxx Activision Game Appliance"); break;
+		case 0x04: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE (various !DESFire !DESFire EV1)"); isMifareClassic = false; break;
+		case 0x08: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE CLASSIC 1k | Plus 2k SL1 | 1k Ev1"); break;
+		case 0x09: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE Mini 0.3k"); break;
+		case 0x10: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE Plus 2k SL2"); break;
+		case 0x11: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE Plus 4k SL2"); break;
+		case 0x18: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE Classic 4k | Plus 4k SL1 | 4k Ev1"); break;
+		case 0x20: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE DESFire 4k | DESFire EV1 2k/4k/8k | Plus 2k/4k SL3 | JCOP 31/41"); isMifareClassic = false; break;
+		case 0x24: PrintAndLogEx(NORMAL, "TYPE : NXP MIFARE DESFire | DESFire EV1"); isMifareClassic = false; break;
+		case 0x28: PrintAndLogEx(NORMAL, "TYPE : JCOP31 or JCOP41 v2.3.1"); break;
+		case 0x38: PrintAndLogEx(NORMAL, "TYPE : Nokia 6212 or 6131 MIFARE CLASSIC 4K"); break;
+		case 0x88: PrintAndLogEx(NORMAL, "TYPE : Infineon MIFARE CLASSIC 1K"); break;
+		case 0x98: PrintAndLogEx(NORMAL, "TYPE : Gemplus MPCOS"); break;
 		default: ;
 	}
 
 	// Double & triple sized UID, can be mapped to a manufacturer.
 	if ( card.uidlen > 4 ) {
-		PrintAndLog("MANUFACTURER : %s", getTagInfo(card.uid[0]));
+		PrintAndLogEx(NORMAL, "MANUFACTURER : %s", getTagInfo(card.uid[0]));
 	}
 	
 	// try to request ATS even if tag claims not to support it
@@ -396,12 +396,12 @@ int CmdHF14AInfo(const char *Cmd) {
 		int pos;
 
 		if (select_status == 2) {
-			PrintAndLog("SAK incorrectly claims that card doesn't support RATS");
+			PrintAndLogEx(NORMAL, "SAK incorrectly claims that card doesn't support RATS");
 		}
-		PrintAndLog(" ATS : %s", sprint_hex(card.ats, card.ats_len));
-		PrintAndLog("       -  TL : length is %d bytes", card.ats[0]);
+		PrintAndLogEx(NORMAL, " ATS : %s", sprint_hex(card.ats, card.ats_len));
+		PrintAndLogEx(NORMAL, "       -  TL : length is %d bytes", card.ats[0]);
 		if (card.ats[0] != card.ats_len - 2) {
-			PrintAndLog("ATS may be corrupted. Length of ATS (%d bytes incl. 2 Bytes CRC) doesn't match TL", card.ats_len);
+			PrintAndLogEx(NORMAL, "ATS may be corrupted. Length of ATS (%d bytes incl. 2 Bytes CRC) doesn't match TL", card.ats_len);
 		}
 		
 		if (card.ats[0] > 1) {		// there is a format byte (T0)
@@ -409,7 +409,7 @@ int CmdHF14AInfo(const char *Cmd) {
 			tb1 = (card.ats[1] & 0x20) == 0x20;
 			tc1 = (card.ats[1] & 0x40) == 0x40;
 			int16_t fsci = card.ats[1] & 0x0f;
-			PrintAndLog("       -  T0 : TA1 is%s present, TB1 is%s present, "
+			PrintAndLogEx(NORMAL, "       -  T0 : TA1 is%s present, TB1 is%s present, "
 					"TC1 is%s present, FSCI is %d (FSC = %ld)",
 				(ta1 ? "" : " NOT"), (tb1 ? "" : " NOT"), (tc1 ? "" : " NOT"),
 				fsci,
@@ -431,7 +431,7 @@ int CmdHF14AInfo(const char *Cmd) {
 			if (card.ats[pos] & 0x04) strcat(dr, "8, ");
 			if (strlen(ds) != 0) ds[strlen(ds) - 2] = '\0';
 			if (strlen(dr) != 0) dr[strlen(dr) - 2] = '\0';
-			PrintAndLog("       - TA1 : different divisors are%s supported, "
+			PrintAndLogEx(NORMAL, "       - TA1 : different divisors are%s supported, "
 					"DR: [%s], DS: [%s]",
 					(card.ats[pos] & 0x80 ? " NOT" : ""), dr, ds);
 			pos++;
@@ -439,7 +439,7 @@ int CmdHF14AInfo(const char *Cmd) {
 		if (tb1) {
 			uint32_t sfgi = card.ats[pos] & 0x0F;
 			uint32_t fwi = card.ats[pos] >> 4;
-			PrintAndLog("       - TB1 : SFGI = %d (SFGT = %s%ld/fc), FWI = %d (FWT = %ld/fc)",
+			PrintAndLogEx(NORMAL, "       - TB1 : SFGI = %d (SFGT = %s%ld/fc), FWI = %d (FWT = %ld/fc)",
 					(sfgi),
 					sfgi ? "" : "(not needed) ",
 					sfgi ? (1 << 12) << sfgi : 0,
@@ -449,7 +449,7 @@ int CmdHF14AInfo(const char *Cmd) {
 			pos++;
 		}
 		if (tc1) {
-			PrintAndLog("       - TC1 : NAD is%s supported, CID is%s supported",
+			PrintAndLogEx(NORMAL, "       - TC1 : NAD is%s supported, CID is%s supported",
 					(card.ats[pos] & 0x01) ? "" : " NOT",
 					(card.ats[pos] & 0x02) ? "" : " NOT");
 			pos++;
@@ -463,40 +463,40 @@ int CmdHF14AInfo(const char *Cmd) {
 					tip = "-> MIFARE Plus S 2K or 4K";
 				}
 			} 
-			PrintAndLog("       -  HB : %s%s", sprint_hex(card.ats + pos, card.ats[0] - pos), tip);
+			PrintAndLogEx(NORMAL, "       -  HB : %s%s", sprint_hex(card.ats + pos, card.ats[0] - pos), tip);
 			if (card.ats[pos] == 0xC1) {
-				PrintAndLog("               c1 -> Mifare or (multiple) virtual cards of various type");
-				PrintAndLog("                  %02x -> Length is %d bytes",
+				PrintAndLogEx(NORMAL, "               c1 -> Mifare or (multiple) virtual cards of various type");
+				PrintAndLogEx(NORMAL, "                  %02x -> Length is %d bytes",
 						card.ats[pos + 1], card.ats[pos + 1]);
 				switch (card.ats[pos + 2] & 0xf0) {
-					case 0x10: PrintAndLog("                     1x -> MIFARE DESFire"); break;
-					case 0x20: PrintAndLog("                     2x -> MIFARE Plus"); break;
+					case 0x10: PrintAndLogEx(NORMAL, "                     1x -> MIFARE DESFire"); break;
+					case 0x20: PrintAndLogEx(NORMAL, "                     2x -> MIFARE Plus"); break;
 				}
 				switch (card.ats[pos + 2] & 0x0f) {
-					case 0x00: PrintAndLog("                     x0 -> <1 kByte"); break;
-					case 0x01: PrintAndLog("                     x1 -> 1 kByte"); break;
-					case 0x02: PrintAndLog("                     x2 -> 2 kByte"); break;
-					case 0x03: PrintAndLog("                     x3 -> 4 kByte"); break;
-					case 0x04: PrintAndLog("                     x4 -> 8 kByte"); break;
+					case 0x00: PrintAndLogEx(NORMAL, "                     x0 -> <1 kByte"); break;
+					case 0x01: PrintAndLogEx(NORMAL, "                     x1 -> 1 kByte"); break;
+					case 0x02: PrintAndLogEx(NORMAL, "                     x2 -> 2 kByte"); break;
+					case 0x03: PrintAndLogEx(NORMAL, "                     x3 -> 4 kByte"); break;
+					case 0x04: PrintAndLogEx(NORMAL, "                     x4 -> 8 kByte"); break;
 				}
 				switch (card.ats[pos + 3] & 0xf0) {
-					case 0x00: PrintAndLog("                        0x -> Engineering sample"); break;
-					case 0x20: PrintAndLog("                        2x -> Released"); break;
+					case 0x00: PrintAndLogEx(NORMAL, "                        0x -> Engineering sample"); break;
+					case 0x20: PrintAndLogEx(NORMAL, "                        2x -> Released"); break;
 				}
 				switch (card.ats[pos + 3] & 0x0f) {
-					case 0x00: PrintAndLog("                        x0 -> Generation 1"); break;
-					case 0x01: PrintAndLog("                        x1 -> Generation 2"); break;
-					case 0x02: PrintAndLog("                        x2 -> Generation 3"); break;
+					case 0x00: PrintAndLogEx(NORMAL, "                        x0 -> Generation 1"); break;
+					case 0x01: PrintAndLogEx(NORMAL, "                        x1 -> Generation 2"); break;
+					case 0x02: PrintAndLogEx(NORMAL, "                        x2 -> Generation 3"); break;
 				}
 				switch (card.ats[pos + 4] & 0x0f) {
-					case 0x00: PrintAndLog("                           x0 -> Only VCSL supported");	break;
-					case 0x01: PrintAndLog("                           x1 -> VCS, VCSL, and SVC supported"); break;
-					case 0x0E: PrintAndLog("                           xE -> no VCS command supported"); break;
+					case 0x00: PrintAndLogEx(NORMAL, "                           x0 -> Only VCSL supported");	break;
+					case 0x01: PrintAndLogEx(NORMAL, "                           x1 -> VCS, VCSL, and SVC supported"); break;
+					case 0x0E: PrintAndLogEx(NORMAL, "                           xE -> no VCS command supported"); break;
 				}
 			}
 		}
 	} else {
-		PrintAndLog("proprietary non iso14443-4 card found, RATS not supported");
+		PrintAndLogEx(NORMAL, "proprietary non iso14443-4 card found, RATS not supported");
 	}
 	
 	detect_classic_magic();
@@ -504,11 +504,11 @@ int CmdHF14AInfo(const char *Cmd) {
 	if (isMifareClassic) {
 		int res = detect_classic_prng();
 		if ( res == 1 )
-			PrintAndLog("[+] prng detection: WEAK");
+			PrintAndLogEx(SUCCESS, "Prng detection: WEAK");
 		else if (res == 0 )
-			PrintAndLog("[+] prng detection: HARDEND (hardnested)");
+			PrintAndLogEx(SUCCESS, "Prng detection: WEAK");
 		else
-			PrintAndLog("[-] prng detection: failed");
+			PrintAndLogEx(FAILED, "prng detection: failed");
 		
 		if ( do_nack_test )
 			detect_classic_nackbug(silent);
@@ -525,14 +525,14 @@ int CmdHF14ACUIDs(const char *Cmd) {
 	n = n > 0 ? n : 1;
 
 	uint64_t t1 =  msclock();
-	PrintAndLog("[+] collecting %d UIDs", n);
+	PrintAndLogEx(SUCCESS, "collecting %d UIDs", n);
 
 	// repeat n times
 	for (int i = 0; i < n; i++) {
 
 		if (ukbhit()) {
 			int gc = getchar(); (void)gc;
-			printf("\n[!] aborted via keyboard!\n");
+			PrintAndLogEx(NORMAL, "\n[!] aborted via keyboard!\n");
 			break;
 		}
 		
@@ -547,16 +547,16 @@ int CmdHF14ACUIDs(const char *Cmd) {
 
 		// check if command failed
 		if (resp.arg[0] == 0) {
-			PrintAndLog("[!] card select failed.");
+			PrintAndLogEx(WARNING, "card select failed.");
 		} else {
 			char uid_string[20];
 			for (uint16_t i = 0; i < card->uidlen; i++) {
 				sprintf(&uid_string[2*i], "%02X", card->uid[i]);
 			}
-			PrintAndLog("%s", uid_string);
+			PrintAndLogEx(NORMAL, "%s", uid_string);
 		}
 	}
-	PrintAndLog("[+] end: %" PRIu64 " seconds", (msclock()-t1)/1000);
+	PrintAndLogEx(SUCCESS, "end: %" PRIu64 " seconds", (msclock()-t1)/1000);
 	return 1;
 }
 
@@ -598,7 +598,7 @@ int CmdHF14ASim(const char *Cmd) {
 					default: errors = true;	break;
 				}				
 				if (!errors) {
-					PrintAndLog("[+] Emulating ISO/IEC 14443 type A tag with %d byte UID (%s)", uidlen>>1, sprint_hex(uid, uidlen>>1));
+					PrintAndLogEx(SUCCESS, "Emulating ISO/IEC 14443 type A tag with %d byte UID (%s)", uidlen>>1, sprint_hex(uid, uidlen>>1));
 					useUIDfromEML = false;
 				}
 				cmdp += 2;
@@ -619,7 +619,7 @@ int CmdHF14ASim(const char *Cmd) {
 				cmdp++;
 				break;				
 			default:
-				PrintAndLog("[!]Unknown parameter '%c'", param_getchar(Cmd, cmdp));
+				PrintAndLogEx(WARNING, "Unknown parameter '%c'", param_getchar(Cmd, cmdp));
 				errors = true;
 				break;
 			}
@@ -637,7 +637,7 @@ int CmdHF14ASim(const char *Cmd) {
 	SendCommand(&c);	
 	UsbCommand resp;
 	
-	PrintAndLog("[+] press pm3-button to abort simulation");
+	PrintAndLogEx(SUCCESS, "press pm3-button to abort simulation");
 	
 	while( !ukbhit() ){
 		if (!WaitForResponseTimeout(CMD_ACK, &resp, 1500) ) continue;
@@ -688,11 +688,11 @@ int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool lea
 
 	if (activateField) {
 		if (!WaitForResponseTimeout(CMD_ACK, &resp, 1500)) {
-			PrintAndLog("APDU ERROR: Proxmark connection timeout.");
+			PrintAndLogEx(NORMAL, "APDU ERROR: Proxmark connection timeout.");
 			return 1;
 		}
 		if (resp.arg[0] != 1) {
-			PrintAndLog("APDU ERROR: Proxmark error %d.", resp.arg[0]);
+			PrintAndLogEx(NORMAL, "APDU ERROR: Proxmark error %d.", resp.arg[0]);
 			return 1;
 		}
 	}
@@ -706,37 +706,37 @@ int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool lea
 			*dataoutlen = 0;
 		
 		if (maxdataoutlen && *dataoutlen > maxdataoutlen) {
-			PrintAndLog("APDU ERROR: Buffer too small(%d). Needs %d bytes", *dataoutlen, maxdataoutlen);
+			PrintAndLogEx(NORMAL, "APDU ERROR: Buffer too small(%d). Needs %d bytes", *dataoutlen, maxdataoutlen);
 			return 2;
 		}
 		
 		memcpy(dataout, recv, *dataoutlen);
 		
         if(!iLen) {
-			PrintAndLog("APDU ERROR: No APDU response.");
+			PrintAndLogEx(NORMAL, "APDU ERROR: No APDU response.");
             return 1;
 		}
 
 		// check block TODO
 		if (iLen == -2) {
-			PrintAndLog("APDU ERROR: Block type mismatch.");
+			PrintAndLogEx(NORMAL, "APDU ERROR: Block type mismatch.");
 			return 2;
 		}
 		
 		// CRC Check
 		if (iLen == -1) {
-			PrintAndLog("APDU ERROR: ISO 14443A CRC error.");
+			PrintAndLogEx(NORMAL, "APDU ERROR: ISO 14443A CRC error.");
 			return 3;
 		}
 
 		// check apdu length
 		if (iLen < 4) {
-			PrintAndLog("APDU ERROR: Small APDU response. Len=%d", iLen);
+			PrintAndLogEx(NORMAL, "APDU ERROR: Small APDU response. Len=%d", iLen);
 			return 2;
 		}
 		
     } else {
-        PrintAndLog("APDU ERROR: Reply timeout.");
+        PrintAndLogEx(NORMAL, "APDU ERROR: Reply timeout.");
 		return 4;
     }
 	
@@ -773,7 +773,7 @@ int CmdHF14AAPDU(const char *cmd) {
 					decodeTLV = true;
 					break;
 				default:
-					PrintAndLog("[!] Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
+					PrintAndLogEx(WARNING, "Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
 					return 1;
 			}
 			
@@ -781,13 +781,13 @@ int CmdHF14AAPDU(const char *cmd) {
 			// len = data + PCB(1b) + CRC(2b)
 			switch(param_gethex_to_eol(cmd, cmdp, data, sizeof(data) - 1 - 2, &datalen)) {
 			case 1:
-				PrintAndLog("[!] invalid HEX value.");
+				PrintAndLogEx(WARNING, "invalid HEX value.");
 				return 1;
 			case 2:
-				PrintAndLog("[!] APDU too large.");
+				PrintAndLogEx(WARNING, "APDU too large.");
 				return 1;
 			case 3:
-				PrintAndLog("[!] hex must have even number of digits.");
+				PrintAndLogEx(WARNING, "hex must have even number of digits.");
 				return 1;
 			}
 			
@@ -798,16 +798,16 @@ int CmdHF14AAPDU(const char *cmd) {
 		cmdp++;
 	}
 
-	PrintAndLog(">>>>[%s%s%s] %s", activateField ? "sel ": "", leaveSignalON ? "keep ": "", decodeTLV ? "TLV": "", sprint_hex(data, datalen));
+	PrintAndLogEx(NORMAL, ">>>>[%s%s%s] %s", activateField ? "sel ": "", leaveSignalON ? "keep ": "", decodeTLV ? "TLV": "", sprint_hex(data, datalen));
 	
 	int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, USB_CMD_DATA_SIZE, &datalen);
 
 	if (res)
 		return res;
 
-	PrintAndLog("<<<< %s", sprint_hex(data, datalen));
+	PrintAndLogEx(NORMAL, "<<<< %s", sprint_hex(data, datalen));
 	
-	PrintAndLog("[+] APDU response: %02x %02x - %s", data[datalen - 2], data[datalen - 1], GetAPDUCodeDescription(data[datalen - 2], data[datalen - 1])); 
+	PrintAndLogEx(SUCCESS, "APDU response: %02x %02x - %s", data[datalen - 2], data[datalen - 1], GetAPDUCodeDescription(data[datalen - 2], data[datalen - 1])); 
 
 	// TLV decoder
 	if (decodeTLV && datalen > 4) {
@@ -902,13 +902,13 @@ int CmdHF14ACmdRaw(const char *cmd) {
                 *buf=0;
 				if (++datalen >= sizeof(data)){
 					if (crc)
-						PrintAndLog("Buffer is full, we can't add CRC to your data");
+						PrintAndLogEx(NORMAL, "Buffer is full, we can't add CRC to your data");
 					break;
 				}
             }
             continue;
         }
-        PrintAndLog("Invalid char on input");
+        PrintAndLogEx(NORMAL, "Invalid char on input");
         return 0;
     }
 
@@ -934,7 +934,7 @@ int CmdHF14ACmdRaw(const char *cmd) {
         c.arg[0] |= ISO14A_SET_TIMEOUT;
         if(timeout > MAX_TIMEOUT) {
             timeout = MAX_TIMEOUT;
-            PrintAndLog("Set timeout to 40542 seconds (11.26 hours). The max we can wait for response");
+            PrintAndLogEx(NORMAL, "Set timeout to 40542 seconds (11.26 hours). The max we can wait for response");
         }
 		c.arg[2] = 13560000 / 1000 / (8*16) * timeout; // timeout in ETUs (time to transfer 1 bit, approx. 9.4 us)
 	}
@@ -982,20 +982,20 @@ static int waitCmd(uint8_t iSelect) {
 		if (iSelect){
 			len = (resp.arg[1] & 0xFFFF);
 			if (len){
-				PrintAndLog("Card selected. UID[%i]:", len);
+				PrintAndLogEx(NORMAL, "Card selected. UID[%i]:", len);
 			} else {
-				PrintAndLog("Can't select card.");
+				PrintAndLogEx(NORMAL, "Can't select card.");
 			}
 		} else {
-			PrintAndLog("received %i bytes:", len);
+			PrintAndLogEx(NORMAL, "received %i bytes:", len);
 		}
 		
         if (!len)
             return 1;
 		
-		PrintAndLog("%s", sprint_hex(resp.d.asBytes, len) );
+		PrintAndLogEx(NORMAL, "%s", sprint_hex(resp.d.asBytes, len) );
     } else {
-        PrintAndLog("timeout while waiting for reply.");
+        PrintAndLogEx(NORMAL, "timeout while waiting for reply.");
 		return 3;
     }
 	return 0;