int CmdHF14AMifare(const char *Cmd)
{
        uint32_t uid = 0;
        uint32_t nt = 0, nr = 0;
        uint64_t par_list = 0, ks_list = 0, r_key = 0;
        uint8_t isOK = 0;
        uint8_t keyBlock[8] = {0};

        UsbCommand c = {CMD_READER_MIFARE, {true, 0, 0};

        // message
        printf("-------------------------------------------------------------------------\n");
        printf("Executing command. Expected execution time: 25sec on average  :-)\n");
        printf("Press the key on the proxmark3 device to abort both proxmark3 and client.\n");
        printf("-------------------------------------------------------------------------\n");

        
start:
    clearCommandBuffer();
    SendCommand(&c);
        
        //flush queue
        while (ukbhit())        getchar();

        
        // wait cycle
        while (true) {
        printf(".");
                fflush(stdout);
                if (ukbhit()) {
                        getchar();
                        printf("\naborted via keyboard!\n");
                        break;
                }
                
                UsbCommand resp;
                if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
                        isOK  = resp.arg[0] & 0xff;
                        uid = (uint32_t)bytes_to_num(resp.d.asBytes +  0, 4);
                        nt =  (uint32_t)bytes_to_num(resp.d.asBytes +  4, 4);
                        par_list = bytes_to_num(resp.d.asBytes +  8, 8);
                        ks_list = bytes_to_num(resp.d.asBytes +  16, 8);
                        nr = bytes_to_num(resp.d.asBytes + 24, 4);
                        printf("\n\n");
                        if (!isOK) PrintAndLog("Proxmark can't get statistic info. Execution aborted.\n");
                        break;
                }
        }       

        printf("\n");
        
        // error
        if (isOK != 1) return 1;
        
        // execute original function from util nonce2key
        if (nonce2key(uid, nt, nr, par_list, ks_list, &r_key))
        {
                isOK = 2;
                PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);    
        } else {
                printf("------------------------------------------------------------------\n");
                PrintAndLog("Key found:%012"llx" \n", r_key);

                num_to_bytes(r_key, 6, keyBlock);
                isOK = mfCheckKeys(0, 0, 1, keyBlock, &r_key);
        }
        if (!isOK) 
                PrintAndLog("Found valid key:%012"llx, r_key);
        else
        {
                if (isOK != 2) PrintAndLog("Found invalid key. ");      
                PrintAndLog("Failing is expected to happen in 25%% of all cases. Trying again with a different reader nonce...");
                c.arg[0] = false;
                goto start;
        }
        
        return 0;
}

function mfcrack()
	core.clearCommandBuffer()
	-- Build the mifare-command
	local cmd = Command:new{cmd = cmds.CMD_READER_MIFARE, arg1 = 1}
	
	local retry = true
	while retry do
		core.SendCommand(cmd:getBytes())
		local key, errormessage = mfcrack_inner()
		-- Success?
		if key then return key end
		-- Failure? 
		if errormessage then return nil, errormessage end
		-- Try again..set arg1 to 0 this time. 

		cmd = Command:new{cmd = cmds.CMD_READER_MIFARE, arg1 = 0}
	end	
	return nil, "Aborted by user"
end

function mfcrack_inner()
    while not core.ukbhit() do      
        local result = core.WaitForResponseTimeout(cmds.CMD_ACK,1000)
        if result then
            -- Unpacking the three arg-parameters
            local count,cmd,isOK = bin.unpack('LL',result)

            if isOK ~= 1 then return nil, "Error occurred" end


            -- The data-part is left
            -- Starts 32 bytes in, at byte 33
            local data = result:sub(33)

            -- A little helper
            local get = function(num)
                local x = data:sub(1,num)
                data = data:sub(num+1)
                return x
            end

            local uid,nt,pl = get(4),get(4),get(8)
            local ks,nr = get(8),get(4)

            local status, key = core.nonce2key(uid,nt, nr, pl,ks)
            if not status then return status,key end

            if status > 0 then 
                print("Key not found (lfsr_common_prefix problem)")
                -- try again
                return nil,nil
            else
                return key
            end
        end
    end
    return nil, "Aborted by user"
end

x = "\xDE\xAD\xBE\xEF"
x = bin.pack("H","DEADBEEF")

local count,cmd,isOK = bin.unpack('LL',result)

int set_pm3_libraries(lua_State *L)
{

    static const luaL_Reg libs[] = {
        {"SendCommand",                 l_SendCommand},
        {"WaitForResponseTimeout",      l_WaitForResponseTimeout},
        {"nonce2key",                   l_nonce2key},
 

static int l_nonce2key(lua_State *L){

    size_t size;
    const char *p_uid = luaL_checklstring(L, 1, &size);
    if(size != 4)  return returnToLuaWithError(L,"Wrong size of uid, got %d bytes, expected 4", (int) size);

    const char *p_nt = luaL_checklstring(L, 2, &size);
    if(size != 4)  return returnToLuaWithError(L,"Wrong size of nt, got %d bytes, expected 4", (int) size);

    const char *p_nr = luaL_checklstring(L, 3, &size);
    if(size != 4)  return returnToLuaWithError(L,"Wrong size of nr, got %d bytes, expected 4", (int) size);

    const char *p_par_info = luaL_checklstring(L, 4, &size);
    if(size != 8)  return returnToLuaWithError(L,"Wrong size of par_info, got %d bytes, expected 8", (int) size);

    const char *p_pks_info = luaL_checklstring(L, 5, &size);
    if(size != 8)  return returnToLuaWithError(L,"Wrong size of ks_info, got %d bytes, expected 8", (int) size);


    uint32_t uid = bytes_to_num(( uint8_t *)p_uid,4);
    uint32_t nt = bytes_to_num(( uint8_t *)p_nt,4);

    uint64_t nr = bytes_to_num(( uint8_t*)p_nr,8);
    uint64_t par_info = bytes_to_num(( uint8_t *)p_par_info,8);
    uint64_t ks_info = bytes_to_num(( uint8_t *)p_pks_info,8);

    uint64_t key = 0;

    int retval = nonce2key(uid,nt, nr, par_info,ks_info, &key);

    //Push the retval on the stack
    lua_pushinteger(L,retval);
    //Push the key onto the stack
    lua_pushlstring(L,(const char *) &key,sizeof(key));

    return 2; //Two return values
}

function nested(key)
	local cmd = string.format("hf mf nested 1 0 A %s d",key)
	core.console(cmd)
end

function dump()
	core.console("hf mf dump")
end

function dump(uid)
	core.console("hf mf dump")
	-- Save the global args, those are *our* arguments
	local myargs = args
	-- Set the arguments for htmldump script
	args =("-o %s.html"):format(uid)
	-- call it 
	require('../scripts/htmldump')

	args =""
	-- dump to emulator
	require('../scripts/dumptoemul')
	-- Set back args. Not that it's used, just for the karma... 
	args = myargs
end