"Исчезает" guardant Code

  FAILURE IN : GrdCodeLoad(teh_guardant, 0x00, gcexe.size(), &gcexe[0], NULL)
  ERROR CODE : 23
             : Guardant dongle locked by another copy of protected application

    D:\Projects\GrdTest\Release>grdtest
    GrdTest sample application by iRacly 2012
     A initialize and start thread...
     T begin
     T Opening guardant session...
     T logged in, flushing...
     A grd thread is flushing...
     A done, aborting...

    D:\Projects\GrdTest\Release>grdtest
    GrdTest sample application by iRacly 2012
     A initialize and start thread...
     T begin
     T Opening guardant session...
     T logged in, flushing...
     A grd thread is flushing...
      FAILURE IN : GrdCodeLoad(teh_guardant, 0x00, gcexe.size(), &gcexe[0], NULL)
      ERROR CODE : 23
                 : Guardant dongle locked by another copy of protected application
     T guardant ready
     T Using guardant session...
     T Closing guardant session...
     A done, aborting...

// GrdTest.cpp : Defines the entry point for the console application.
//
// iRacly 2012
#include <iostream>
#include <assert.h>
#include <Windows.h>
#include <process.h>
#include <fstream>
#include "GrdAPI\grdapi.h"
#pragma comment (lib, "Grdapi32.lib")


HANDLE beginWriteEvent;

#define VERIFY_GRD(X) { int result = (X);                                   \
    if (GrdE_OK != result) {                                                \
        char szErrorMsg[1024];                                              \
        int nRet = GrdFormatMessage(NULL, result, GrdLng_ENG, szErrorMsg,   \
            1024, NULL);                                                    \
        std::cerr                                                           \
            << "  FAILURE IN : " << #X << std::endl                         \
            << "  ERROR CODE : " << result << std::endl                     \
            << "             : " << szErrorMsg << std::endl;                \
    }                                                                       \
}

unsigned __stdcall GrdThread(void* arguments)
{
    std::cout << " T begin" << std::endl;
    int a, b, c, d;
    {
        std::ifstream codes("codes.txt");
        codes >> a >> b >> c >> d;
    }
    std::string gcexe;
    {
        std::ifstream app("dongle.gcexe", std::ios::binary);
        assert(app.good());
        size_t const chunkSize = 64 * 1024;
        char chunk[chunkSize];
        // Program is 64K max!
        app.read(chunk, chunkSize);
        std::streamsize sz = app.gcount();
        assert(!app.good());
        assert(sz < chunkSize);
        gcexe.assign(chunk, chunk + sz);
    }
    HANDLE teh_guardant;
    unsigned int id = 0;
    BYTE abyGrd[GrdContainerSize];
    {    
        std::cout << " T Opening guardant session..." << std::endl;
        int grdRz;
        grdRz = GrdStartup(GrdFMR_Local);
        assert(GrdE_OK == grdRz);
        teh_guardant = GrdCreateHandle(
            (HANDLE)abyGrd, // Pointer to memory allocated for Grd protected container, if NULL, Grd API allocates memory for new Grd protected container by itself
            GrdCHM_MultiThread,
            NULL); // Reserved and must be NULL
        assert(teh_guardant);
        VERIFY_GRD(GrdSetAccessCodes(teh_guardant, a, b, c, d));
        VERIFY_GRD(GrdSetFindMode(teh_guardant, GrdFMR_Local, 0, 0, 0, 0, 0, 0, 0, 0, GrdFMI_USB));
        TGrdFindInfo GrdFindInfo;
        //always look first and the only key
        VERIFY_GRD(GrdFind(teh_guardant, GrdF_First, (DWORD*)&id, &GrdFindInfo));
        VERIFY_GRD(GrdLogin(teh_guardant, -1, GrdLM_PerStation));
        std::cout << " T logged in, flushing..." << std::endl;
        BOOL resetRz = SetEvent(beginWriteEvent);
        assert(resetRz);
        VERIFY_GRD(GrdCodeLoad(teh_guardant, 0x00, gcexe.size(), &gcexe[0], NULL));
        std::cout << " T guardant ready" << std::endl;
    }
    { // use guardant here
        std::cout << " T Using guardant session..." << std::endl;
    }
    { // finalize
        std::cout << " T Closing guardant session..." << std::endl;
        VERIFY_GRD(GrdCloseHandle(teh_guardant));
        VERIFY_GRD(GrdCleanup());
    }
    std::cout << " T end" << std::endl;
    return 0;
}

int main(int argc, char* argv[])
{
    std::cout << "GrdTest sample application by iRacly 2012" << std::endl;
    std::cout << " A initialize and start thread..." << std::endl;
    beginWriteEvent = CreateEventW(NULL, TRUE, FALSE, L"FlashingGrdProgram");
    assert(beginWriteEvent);
    unsigned threadID = 0;
    HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, &GrdThread, NULL, 0, &threadID);
    DWORD waitRz = WaitForSingleObject(beginWriteEvent, INFINITE);
    assert(WAIT_OBJECT_0 == waitRz);
    std::cout << " A grd thread is flushing..." << std::endl;
    Sleep(30); // this is empirical value: let T print something
    // harakiri
    std::cout << " A done, aborting..." << std::endl;
    TerminateProcess(OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId()), 0);
    WaitForSingleObject(hThread, INFINITE);
    return 0;
}