+//this function strictly converts >1 to 1 and <1 to 0 for each sample in the graphbuffer
+int CmdGetBitStream(const char *Cmd)
+{
+ int i;
+ CmdHpf(Cmd);
+ for (i = 0; i < GraphTraceLen; i++) {
+ if (GraphBuffer[i] >= 1) {
+ GraphBuffer[i] = 1;
+ } else {
+ GraphBuffer[i] = 0;
+ }
+ }
+ RepaintGraphWindow();
+ return 0;
+}
+
+
+//by marshmellow
+void printBitStream(uint8_t BitStream[], uint32_t bitLen)
+{
+ uint32_t i = 0;
+ if (bitLen<16) {
+ PrintAndLog("Too few bits found: %d",bitLen);
+ return;
+ }
+ if (bitLen>512) bitLen=512;
+
+ // ensure equally divided by 16
+ bitLen &= 0xfff0;
+
+
+ for (i = 0; i <= (bitLen-16); i+=16) {
+ PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
+ BitStream[i],
+ BitStream[i+1],
+ BitStream[i+2],
+ BitStream[i+3],
+ BitStream[i+4],
+ BitStream[i+5],
+ BitStream[i+6],
+ BitStream[i+7],
+ BitStream[i+8],
+ BitStream[i+9],
+ BitStream[i+10],
+ BitStream[i+11],
+ BitStream[i+12],
+ BitStream[i+13],
+ BitStream[i+14],
+ BitStream[i+15]);
+ }
+ return;
+}
+//by marshmellow
+//print 64 bit EM410x ID in multiple formats
+void printEM410x(uint64_t id)
+{
+ if (id !=0){
+ uint64_t iii=1;
+ uint64_t id2lo=0;
+ uint32_t ii=0;
+ uint32_t i=0;
+ for (ii=5; ii>0;ii--){
+ for (i=0;i<8;i++){
+ id2lo=(id2lo<<1LL) | ((id & (iii << (i+((ii-1)*8)))) >> (i+((ii-1)*8)));
+ }
+ }
+ //output em id
+ PrintAndLog("EM TAG ID : %010llx", id);
+ PrintAndLog("Unique TAG ID: %010llx", id2lo);
+ PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF);
+ PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF);
+ PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
+ PrintAndLog("DEZ 3.5A : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
+ PrintAndLog("DEZ 14/IK2 : %014lld",id);
+ PrintAndLog("DEZ 15/IK3 : %015lld",id2lo);
+ PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
+ }
+ return;
+}
+
+//by marshmellow
+//takes 3 arguments - clock, invert and maxErr as integers
+//attempts to demodulate ask while decoding manchester
+//prints binary found and saves in graphbuffer for further commands
+int CmdAskEM410xDemod(const char *Cmd)
+{
+ int invert=0;
+ int clk=0;
+ int maxErr=100;
+ char cmdp = param_getchar(Cmd, 0);
+ if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
+ PrintAndLog("Usage: data askem410xdemod [clock] <0|1> [maxError]");
+ PrintAndLog(" [set clock as integer] optional, if not set, autodetect.");
+ PrintAndLog(" <invert>, 1 for invert output");
+ PrintAndLog(" [set maximum allowed errors], default = 100.");
+ PrintAndLog("");
+ PrintAndLog(" sample: data askem410xdemod = demod an EM410x Tag ID from GraphBuffer");
+ PrintAndLog(" : data askem410xdemod 32 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32");
+ PrintAndLog(" : data askem410xdemod 32 1 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32 and inverting data");
+ PrintAndLog(" : data askem410xdemod 1 = demod an EM410x Tag ID from GraphBuffer while inverting data");
+ PrintAndLog(" : data askem410xdemod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors");
+
+ return 0;
+ }
+
+
+ uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+ sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
+ if (invert != 0 && invert != 1) {
+ PrintAndLog("Invalid argument: %s", Cmd);
+ return 0;
+ }
+ size_t BitLen = getFromGraphBuf(BitStream);
+
+ if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
+ if (BitLen==0) return 0;
+ int errCnt=0;
+ errCnt = askmandemod(BitStream, &BitLen, &clk, &invert, maxErr);
+ if (errCnt<0||BitLen<16){ //if fatal error (or -1)
+ if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
+ return 0;
+ }
+ PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
+
+ //output
+ if (errCnt>0){
+ PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+ }
+ //PrintAndLog("ASK/Manchester decoded bitstream:");
+ // Now output the bitstream to the scrollback by line of 16 bits
+ setDemodBuf(BitStream,BitLen,0);
+ //printDemodBuff();
+ uint64_t lo =0;
+ size_t idx=0;
+ lo = Em410xDecode(BitStream, &BitLen, &idx);
+ if (lo>0){
+ //set GraphBuffer for clone or sim command
+ setDemodBuf(BitStream, BitLen, idx);
+ if (g_debugMode){
+ PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
+ printDemodBuff();
+ }
+ PrintAndLog("EM410x pattern found: ");
+ if (BitLen > 64) PrintAndLog("\nWarning! Length not what is expected - Length: %d bits\n",BitLen);
+ printEM410x(lo);
+ return 1;
+ }
+ return 0;
+}
+
+int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch)
+{
+ int invert=0;
+ int clk=0;
+ int maxErr=100;
+
+ uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+ sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
+ if (invert != 0 && invert != 1) {
+ PrintAndLog("Invalid argument: %s", Cmd);
+ return 0;
+ }
+ if (clk==1){
+ invert=1;
+ clk=0;
+ }
+ size_t BitLen = getFromGraphBuf(BitStream);
+ if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
+ if (BitLen==0) return 0;
+ int errCnt=0;
+ errCnt = askmandemod(BitStream, &BitLen, &clk, &invert, maxErr);
+ if (errCnt<0||BitLen<16){ //if fatal error (or -1)
+ if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
+ return 0;
+ }
+ if (verbose) PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
+
+ //output
+ if (errCnt>0){
+ if (verbose) PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
+ }
+ if (verbose) PrintAndLog("ASK/Manchester decoded bitstream:");
+ // Now output the bitstream to the scrollback by line of 16 bits
+ setDemodBuf(BitStream,BitLen,0);
+ if (verbose) printDemodBuff();
+ uint64_t lo =0;
+ size_t idx=0;
+ if (emSearch){
+ lo = Em410xDecode(BitStream, &BitLen, &idx);
+ if (lo>0){
+ //set GraphBuffer for clone or sim command
+ setDemodBuf(BitStream, BitLen, idx);
+ if (g_debugMode){
+ PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
+ printDemodBuff();
+ }
+ if (verbose) PrintAndLog("EM410x pattern found: ");
+ if (verbose) printEM410x(lo);
+ return 1;
+ }
+ }
+ return 1;
+}
+
+//by marshmellow
+//takes 3 arguments - clock, invert, maxErr as integers
+//attempts to demodulate ask while decoding manchester
+//prints binary found and saves in graphbuffer for further commands
+int Cmdaskmandemod(const char *Cmd)
+{
+ char cmdp = param_getchar(Cmd, 0);
+ if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
+ PrintAndLog("Usage: data rawdemod am [clock] <0|1> [maxError]");
+ PrintAndLog(" [set clock as integer] optional, if not set, autodetect.");
+ PrintAndLog(" <invert>, 1 for invert output");
+ PrintAndLog(" [set maximum allowed errors], default = 100.");
+ PrintAndLog("");
+ PrintAndLog(" sample: data rawdemod am = demod an ask/manchester tag from GraphBuffer");
+ PrintAndLog(" : data rawdemod am 32 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32");
+ PrintAndLog(" : data rawdemod am 32 1 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32 and inverting data");
+ PrintAndLog(" : data rawdemod am 1 = demod an ask/manchester tag from GraphBuffer while inverting data");
+ PrintAndLog(" : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
+ return 0;
+ }
+ return ASKmanDemod(Cmd, TRUE, TRUE);
+}
+
+//by marshmellow
+//manchester decode
+//stricktly take 10 and 01 and convert to 0 and 1
+int Cmdmandecoderaw(const char *Cmd)
+{
+ int i =0;
+ int errCnt=0;
+ size_t size=0;
+ size_t maxErr = 20;
+ char cmdp = param_getchar(Cmd, 0);
+ if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
+ PrintAndLog("Usage: data manrawdecode");
+ PrintAndLog(" Takes 10 and 01 and converts to 0 and 1 respectively");
+ PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)");
+ PrintAndLog("");
+ PrintAndLog(" sample: data manrawdecode = decode manchester bitstream from the demodbuffer");
+ return 0;
+ }
+ if (DemodBufferLen==0) return 0;
+ uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+ int high=0,low=0;
+ for (;i<DemodBufferLen;++i){
+ if (DemodBuffer[i]>high) high=DemodBuffer[i];
+ else if(DemodBuffer[i]<low) low=DemodBuffer[i];
+ BitStream[i]=DemodBuffer[i];
+ }
+ if (high>1 || low <0 ){
+ PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
+ return 0;
+ }
+ size=i;
+ errCnt=manrawdecode(BitStream, &size);
+ if (errCnt>=maxErr){
+ PrintAndLog("Too many errors: %d",errCnt);
+ return 0;
+ }
+ PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
+ printBitStream(BitStream, size);
+ if (errCnt==0){
+ uint64_t id = 0;
+ size_t idx=0;
+ id = Em410xDecode(BitStream, &size, &idx);
+ if (id>0){
+ //need to adjust to set bitstream back to manchester encoded data
+ //setDemodBuf(BitStream, size, idx);
+
+ printEM410x(id);
+ }
+ }
+ return 1;
+}
+
+//by marshmellow
+//biphase decode
+//take 01 or 10 = 0 and 11 or 00 = 1
+//takes 2 arguments "offset" default = 0 if 1 it will shift the decode by one bit
+// and "invert" default = 0 if 1 it will invert output
+// since it is not like manchester and doesn't have an incorrect bit pattern we
+// cannot determine if our decode is correct or if it should be shifted by one bit
+// the argument offset allows us to manually shift if the output is incorrect
+// (better would be to demod and decode at the same time so we can distinguish large
+// width waves vs small width waves to help the decode positioning) or askbiphdemod
+int CmdBiphaseDecodeRaw(const char *Cmd)
+{
+ int i = 0;
+ int errCnt=0;
+ size_t size=0;
+ int offset=0;
+ int invert=0;
+ int high=0, low=0;
+ char cmdp = param_getchar(Cmd, 0);
+ if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
+ PrintAndLog("Usage: data biphaserawdecode [offset] <invert>");
+ PrintAndLog(" Converts 10 or 01 to 0 and 11 or 00 to 1");
+ PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)");
+ PrintAndLog("");
+ PrintAndLog(" [offset <0|1>], set to 0 not to adjust start position or to 1 to adjust decode start position");
+ PrintAndLog(" [invert <0|1>], set to 1 to invert output");
+ PrintAndLog("");
+ PrintAndLog(" sample: data biphaserawdecode = decode biphase bitstream from the demodbuffer");
+ PrintAndLog(" sample: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output");
+ return 0;
+ }
+ sscanf(Cmd, "%i %i", &offset, &invert);
+ if (DemodBufferLen==0) return 0;
+ uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+ //get graphbuffer & high and low
+ for (;i<DemodBufferLen;++i){
+ if(DemodBuffer[i]>high)high=DemodBuffer[i];
+ else if(DemodBuffer[i]<low)low=DemodBuffer[i];
+ BitStream[i]=DemodBuffer[i];
+ }
+ if (high>1 || low <0){
+ PrintAndLog("Error: please raw demod the wave first then decode");
+ return 0;
+ }
+ size=i;
+ errCnt=BiphaseRawDecode(BitStream, &size, offset, invert);
+ if (errCnt>=20){
+ PrintAndLog("Too many errors attempting to decode: %d",errCnt);
+ return 0;
+ }
+ PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
+ printBitStream(BitStream, size);
+ PrintAndLog("\nif bitstream does not look right try offset=1");
+ if (offset == 1) setDemodBuf(DemodBuffer,DemodBufferLen-1,1); //remove first bit from raw demod
+ return 1;
+}
+
+// set demod buffer back to raw after biphase demod
+void setBiphaseDemodBuf(uint8_t *BitStream, size_t size)
+{
+ uint8_t rawStream[512]={0x00};
+ size_t i=0;
+ uint8_t curPhase=0;
+ if (size > 256) {
+ PrintAndLog("ERROR - Biphase Demod Buffer overrun");
+ return;
+ }
+ for (size_t idx=0; idx<size; idx++){
+ if(!BitStream[idx]){
+ rawStream[i++] = curPhase;
+ rawStream[i++] = curPhase;
+ curPhase ^= 1;
+ } else {
+ rawStream[i++] = curPhase;
+ rawStream[i++] = curPhase ^ 1;
+ }
+ }
+ setDemodBuf(rawStream,i,0);
+ return;
+}
+//by marshmellow
+//takes 4 arguments - clock, invert, maxErr as integers and amplify as char
+//attempts to demodulate ask only
+//prints binary found and saves in graphbuffer for further commands
+int ASKrawDemod(const char *Cmd, bool verbose)
+{
+ int invert=0;
+ int clk=0;
+ int maxErr=100;
+ uint8_t askAmp = 0;
+ char amp = param_getchar(Cmd, 0);
+ uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
+ sscanf(Cmd, "%i %i %i %c", &clk, &invert, &maxErr, &);
+ if (invert != 0 && invert != 1) {
+ if (verbose) PrintAndLog("Invalid argument: %s", Cmd);
+ return 0;
+ }
+ if (clk==1){
+ invert=1;
+ clk=0;
+ }
+ if (amp == 'a' || amp == 'A') askAmp=1;
+ size_t BitLen = getFromGraphBuf(BitStream);
+ if (BitLen==0) return 0;
+ int errCnt=0;
+ errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp);
+ if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
+ if (verbose) PrintAndLog("no data found");
+ if (g_debugMode==1 && verbose) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
+ return 0;
+ }
+ if (verbose) PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, BitLen);
+
+ //move BitStream back to DemodBuffer
+ setDemodBuf(BitStream,BitLen,0);
+
+ //output
+ if (errCnt>0 && verbose){
+ PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d", errCnt);
+ }
+ if (verbose){
+ PrintAndLog("ASK demoded bitstream:");
+ // Now output the bitstream to the scrollback by line of 16 bits
+ printBitStream(BitStream,BitLen);
+ }
+ return 1;
+}
+
+//by marshmellow
+//attempts to demodulate and identify a G_Prox_II verex/chubb card
+//WARNING: if it fails during some points it will destroy the DemodBuffer data
+// but will leave the GraphBuffer intact.
+//if successful it will push askraw data back to demod buffer ready for emulation
+int CmdG_Prox_II_Demod(const char *Cmd)
+{
+ int ans = ASKrawDemod(Cmd, FALSE);
+ if (ans <= 0) {
+ if (g_debugMode) PrintAndLog("Error AskrawDemod: %d",ans);
+ return ans;
+ }
+ size_t size = DemodBufferLen;
+ ans = BiphaseRawDecode(DemodBuffer, &size, 0, 0);
+ if (ans !=0) {
+ if (g_debugMode) PrintAndLog("Error BiphaseRawDecode: %d",ans);
+ return ans;
+ }
+ //call lfdemod.c demod for gProxII
+ ans = gProxII_Demod(DemodBuffer, &size);
+ if (ans < 0){
+ if (g_debugMode) PrintAndLog("Error gProxII_Demod 1st Try: %d",ans);
+ //try biphase again
+ ans = BiphaseRawDecode(DemodBuffer, &size, 1, 0);
+ if (ans != 0) {
+ if (g_debugMode) PrintAndLog("Error BiphaseRawDecode: %d",ans);
+ return ans;
+ }
+ ans = gProxII_Demod(DemodBuffer, &size);
+ if (ans < 0) {
+ if (g_debugMode) PrintAndLog("Error gProxII_Demod 1st Try: %d",ans);
+ return ans;
+ }
+ }
+ //got a good demod
+ uint32_t ByteStream[65] = {0x00};
+ uint8_t xorKey=0;
+ uint8_t keyCnt=0;
+ uint8_t bitCnt=0;
+ uint8_t ByteCnt=0;
+ size_t startIdx = ans + 6; //start after preamble
+ for (size_t idx = 0; idx<size-6; idx++){
+ if ((idx+1) % 5 == 0){
+ //spacer bit - should be 0
+ if (DemodBuffer[startIdx+idx] != 0) {
+ if (g_debugMode) PrintAndLog("Error spacer not 0: %d, pos: %d",DemodBuffer[startIdx+idx],startIdx+idx);
+ return -1;
+ }
+ continue;
+ }
+ if (keyCnt<8){ //lsb first
+ xorKey = xorKey | (DemodBuffer[startIdx+idx]<<keyCnt);
+ keyCnt++;
+ if (keyCnt==8 && g_debugMode) PrintAndLog("xorKey Found: %02x", xorKey);
+ continue;
+ }
+ //lsb first
+ ByteStream[ByteCnt] = ByteStream[ByteCnt] | (DemodBuffer[startIdx+idx]<<bitCnt);
+ bitCnt++;
+ if (bitCnt % 8 == 0){
+ if (g_debugMode) PrintAndLog("byte %d: %02x",ByteCnt,ByteStream[ByteCnt]);
+ bitCnt=0;
+ ByteCnt++;
+ }
+ }
+ for (uint8_t i = 0; i < ByteCnt; i++){
+ ByteStream[i] ^= xorKey; //xor
+ if (g_debugMode) PrintAndLog("byte %d after xor: %02x", i, ByteStream[i]);
+ }
+ //now ByteStream contains 64 bytes of decrypted raw tag data
+ //
+ uint8_t fmtLen = ByteStream[0]>>2;
+ uint32_t FC = 0;
+ uint32_t Card = 0;
+ uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans,32);
+ uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
+ uint32_t raw3 = bytebits_to_byte(DemodBuffer+ans+64, 32);
+
+ if (fmtLen==36){
+ FC = ((ByteStream[3] & 0x7F)<<7) | (ByteStream[4]>>1);
+ Card = ((ByteStream[4]&1)<<19) | (ByteStream[5]<<11) | (ByteStream[6]<<3) | (ByteStream[7]>>5);
+ PrintAndLog("G-Prox-II Found: FmtLen %d, FC %d, Card %d",fmtLen,FC,Card);
+ } else if(fmtLen==26){
+ FC = ((ByteStream[3] & 0x7F)<<1) | (ByteStream[4]>>7);
+ Card = ((ByteStream[4]&0x7F)<<9) | (ByteStream[5]<<1) | (ByteStream[6]>>7);
+ PrintAndLog("G-Prox-II Found: FmtLen %d, FC %d, Card %d",fmtLen,FC,Card);
+ } else {
+ PrintAndLog("Unknown G-Prox-II Fmt Found: FmtLen %d",fmtLen);
+ }
+ PrintAndLog("Raw: %08x%08x%08x", raw1,raw2,raw3);
+ setBiphaseDemodBuf(DemodBuffer+ans, 96);
+ return 1;
+}
+
+//by marshmellow - see ASKrawDemod
+int Cmdaskrawdemod(const char *Cmd)
+{
+ char cmdp = param_getchar(Cmd, 0);
+ if (strlen(Cmd) > 12 || cmdp == 'h' || cmdp == 'H') {
+ PrintAndLog("Usage: data rawdemod ar [clock] <invert> [maxError] [amplify]");
+ PrintAndLog(" [set clock as integer] optional, if not set, autodetect");
+ PrintAndLog(" <invert>, 1 to invert output");
+ PrintAndLog(" [set maximum allowed errors], default = 100");
+ PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
+ PrintAndLog("");
+ PrintAndLog(" sample: data rawdemod ar = demod an ask tag from GraphBuffer");
+ PrintAndLog(" : data rawdemod ar a = demod an ask tag from GraphBuffer, amplified");
+ PrintAndLog(" : data rawdemod ar 32 = demod an ask tag from GraphBuffer using a clock of RF/32");
+ PrintAndLog(" : data rawdemod ar 32 1 = demod an ask tag from GraphBuffer using a clock of RF/32 and inverting data");
+ PrintAndLog(" : data rawdemod ar 1 = demod an ask tag from GraphBuffer while inverting data");
+ PrintAndLog(" : data rawdemod ar 64 1 0 = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
+ PrintAndLog(" : data rawdemod ar 64 1 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
+ return 0;
+ }
+ return ASKrawDemod(Cmd, TRUE);
+}
+
projects / proxmark3-svn / blobdiff