Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  щл
Language: C/C++
Code:
/* This file has been generated by the Hex-Rays decompiler.
   Copyright (c) 2007-2015 Hex-Rays <[email protected]>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

// int __fastcall _cxa_finalize(_DWORD); weak
// int atoi(const char *nptr);
// size_t strlen(const char *s);
// char *strstr(const char *haystack, const char *needle);
// int __fastcall _stack_chk_fail(_DWORD); weak
// unsigned int sleep(unsigned int seconds);
// time_t time(time_t *timer);
// FILE *fopen(const char *filename, const char *modes);
// int fseek(FILE *stream, __int32 off, int whence);
// __int32 ftell(FILE *stream);
// size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
// void *memset(void *s, int c, size_t n);
// int fclose(FILE *stream);
// char *strcpy(char *dest, const char *src);
// char *strcat(char *dest, const char *src);
// size_t fwrite(const void *ptr, size_t size, size_t n, FILE *s);
// int ftime(struct timeb *timebuf);
// int close(int fd);
// void *memcpy(void *dest, const void *src, size_t n);
// int sprintf(char *s, const char *format, ...);
// int open(const char *file, int oflag, ...);
// void exit(int status);
// int fcntl(int fd, int cmd, ...);
// int ioctl(int fd, unsigned __int32 request, ...);
// int usleep(__useconds_t useconds);
// ssize_t write(int fd, const void *buf, size_t n);
// ssize_t read(int fd, void *buf, size_t nbytes);
// void *malloc(size_t size);
// void free(void *ptr);
// int strcmp(const char *s1, const char *s2);
// void *realloc(void *ptr, size_t size);
// void sync(void);
// int memcmp(const void *s1, const void *s2, size_t n);
// int puts(const char *s);
// char *getcwd(char *buf, size_t size);
// int access(const char *name, int type);
// double strtod(const char *nptr, char **endptr);
// int sigaction(int sig, const struct sigaction *act, struct sigaction *oact);
// int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
// __pid_t getppid(void);
// int kill(__pid_t pid, int sig);
// int chdir(const char *path);
// char *strncpy(char *dest, const char *src, size_t n);
// int sscanf(const char *s, const char *format, ...);
// int fgetc(FILE *stream);
// int toupper(int c);
// void srand48(__int32 seedval);
// __int32 lrand48(void);
// int printf(const char *format, ...);
// int putchar(int c);
// void *dlopen(const char *file, int mode);
// void *dlsym(void *handle, const char *name);
// int raise(int sig);
// int __fastcall _gnu_Unwind_Find_exidx(_DWORD, _DWORD); weak
// void abort(void);
// int __fastcall _cxa_begin_cleanup(_DWORD); weak
// int __fastcall _cxa_type_match(_DWORD, _DWORD, _DWORD, _DWORD); weak
int sub_AD64();
int __fastcall OpenCommunicationPort(char *a1);
int __fastcall OpenCommunicationPortNew(char *a1);
int CloseCommunicationPort();
signed int __fastcall SendDownloadPackageGetAnswer(int a1, int a2, unsigned int a3);
int __fastcall Download(const char *a1);
int wrfile();
int __fastcall ReadDpuSnInfo(char *a1, char *a2);
int __fastcall WrfileCommData(const char *a1);
time_t __fastcall GetWaitTime(int a1, time_t a2, int a3, int a4);
int __fastcall SetCommunicationPort(int result, int a2);
int __fastcall ErrorCode(int result);
void CleanErrorCode();
int GetErrorCode();
int GetErrorTimes();
int ClosePort();
void *__fastcall ResetBox(unsigned int a1);
signed int OpenPort();
int __fastcall ReceiveByte(void *buf); // idb
int __fastcall ReceiveDataNoFixMode(int a1, int a2);
signed int __fastcall ReceiveData(int a1, int a2);
int __fastcall SendByteS(void *buf, size_t n); // idb
signed int __fastcall SendByte(char a1, int a2, int a3);
int __fastcall SendDataNoFixMode(int a1, int a2, int a3);
int __fastcall SendData(int a1, int a2, int a3);
int __fastcall ClearBuffer(int a1);
int __fastcall ReadData(void *buf, size_t nbytes); // idb
int __fastcall SetLanguage(int result);
int GetLanguage();
unsigned __int64 __fastcall SetDateString(unsigned __int64 a1, int a2, int a3);
char *__fastcall SetTimeString(char *a1, signed int a2, int a3, int a4);
void __fastcall __spoils<R2,R3,R12> InitFileName(const char *a1, int a2, int a3);
char *__fastcall GetFileNameText(int a1, int a2, int a3);
void *InitIndex();
int __fastcall FileOpen(char *src); // idb
unsigned int __fastcall GotoNextLine(unsigned int result);
signed int __fastcall ReadText(unsigned int a1, int a2);
signed int __fastcall FindIndex(char *a1);
size_t __fastcall GotoLastLine(unsigned int a1);
signed int __fastcall ReadDataName(unsigned int a1, int a2);
int __fastcall FindData(unsigned int a1, const char *a2);
char *__fastcall GetPrivateProFileString(size_t n, char *filename, const char *a3, char *a4, size_t na, char *filenamea);
int __fastcall GetPrivateProFileInt(char *a1, const char *a2, int a3, char *a4);
signed int __fastcall AddIndex(const char *a1);
int __fastcall AddData(int a1, const char *a2, const char *a3);
int __fastcall ModifyData(unsigned int a1, char *a2);
int __fastcall save(char *a1);
signed int __fastcall SetPrivateProFileString(char *a1, const char *a2, const char *a3, char *a4);
int __fastcall SetPrivateProFileInt(char *a1, const char *a2, int a3, char *a4);
void *__fastcall R_memset(void *result, int a2, size_t a3);
void *__fastcall R_memcpy(void *result, const void *a2, size_t a3);
int __fastcall R_memcmp(const void *a1, const void *a2, int a3);
int __fastcall sub_CB90(int result, unsigned int *a2, unsigned int a3);
char *__fastcall sub_CBB8(int a1, int a2);
int __fastcall MD5Init(int result);
int __fastcall MD5Update(int a1, int a2, unsigned int a3);
int __fastcall MD5Final(int a1, int a2, int a3);
int __fastcall NN_DigitMult(int result, unsigned int a2, unsigned int a3);
int __fastcall NN_DigitDiv(int *a1, int a2, unsigned int a3);
int __fastcall R_DigestInit(_DWORD *a1);
int __fastcall R_DigestUpdate(int a1, int a2, unsigned int a3);
int __fastcall R_DigestFinal(int a1, int a2, _DWORD *a3);
int __fastcall R_SignInit(_DWORD *a1);
int __fastcall R_SignUpdate(int a1, int a2, unsigned int a3);
int __fastcall R_SignFinal(int a1, int a2, int *a3, _DWORD *a4);
int __fastcall R_VerifyInit(_DWORD *a1);
int __fastcall R_VerifyUpdate(int a1, int a2, unsigned int a3);
int __fastcall R_VerifyFinal(int a1, int a2, unsigned int a3, _DWORD *a4);
int __fastcall R_SignBlock(int a1, int *a2, int a3, unsigned int a4, _DWORD *a5);
int __fastcall R_VerifyBlockSignature(int a1, unsigned int a2, int a3, unsigned int a4, _DWORD *a5);
int __fastcall R_DigestBlock(int a1, _DWORD *a2, int a3, unsigned int a4);
int __fastcall sub_D9F0(int a1);
int __fastcall sub_DA08(unsigned int a1, int a2, int a3);
int __fastcall sub_DA40(int a1, int a2);
int __fastcall sub_DA70(unsigned int a1, unsigned int a2);
int __fastcall sub_DAC0(const char *a1);
unsigned int __fastcall ByteSub(int a1);
int gentables();
int __fastcall strtoHex(int result, int a2);
int __fastcall hextoStr(int result, int a2);
_DWORD *__fastcall gkey(signed int a1, signed int a2, int a3);
int __fastcall encrypt(int a1);
int __fastcall decrypt(int a1);
void DelIdBuffer();
int __fastcall SearchIdOpenFile(char *a1);
void __fastcall SearchIdCloseFile(FILE **a1);
int __fastcall ByteToChar(int a1);
int __fastcall ggp_Open(const char *a1);
void *ggp_Close();
int __fastcall GetGAGOffsetFromGGP(char *a1, const char *a2);
int __fastcall GetGAGSizeFromGGP(char *a1, const char *a2);
signed int __fastcall fseekGGP(int a1, __int32 a2, int a3);
int __fastcall IdSearch(const void *a1, void *a2, signed int a3, int a4);
int __fastcall FromIdGetBinaryString(const void *a1, void *a2, signed int a3, char *a4);
int __fastcall GetTextFromTextLib(unsigned int a1, void *a2, signed int a3);
int __fastcall SetFixTextIdBuffer(int a1, int a2, int a3, int a4);
int __fastcall sub_EF20(signed int a1, int a2, int a3);
int __fastcall CommunicationPacketFormat(char a1);
int __fastcall AddMenuTextID(signed int a1);
int __fastcall InitMenuID(signed int a1);
int __fastcall InitDSMenuID(signed int a1);
int __fastcall AddMenuTextIDWithMenuType(signed int a1);
int __fastcall InitMenuIDWithMenuType(signed int a1, signed int a2);
int (__fastcall *__fastcall SetTroubleCodeCallBackFunction(int a1))(_DWORD, _DWORD, _DWORD);
int InitTroubleCode();
int __fastcall AddTroubleCode(signed int a1, signed int a2);
int InitTroubleCodeFrozen();
int __fastcall AddTroubleCodeFrozen(signed int a1, signed int a2);
int InitDataStream();
int __fastcall AddDataStreamItem(signed int a1, const char *a2);
int InitVwDataStream();
int __fastcall AddVwDataStreamItem(signed int a1, signed int a2, const char *a3);
int __fastcall ShowMessageBox(const char *a1, const char *a2, int a3);
int sub_F444();
int ShowVwDataStream();
int ShowAudiDataStream();
int __fastcall ShowDataStream(int a1, time_t a2, int a3, int a4);
int ShowTroubleCodeFrozen();
int ShowTroubleCode();
int __fastcall ShowMenuGetSelectedItem(char a1, char a2, _WORD *a3);
int __fastcall ShowMenuGetSelectedItemWithMenuType(char a1, char a2, _WORD *a3);
int __fastcall ShowMessageBoxID(unsigned int a1, unsigned int a2, int a3);
int InitStreamSelectedBox();
int __fastcall AddStreamSelectBox(signed int a1);
signed int __fastcall ShowStreamSelect(int *a1, void *a2);
signed int __fastcall ShowStreamSelectBox(int a1, void *a2, int a3);
__int64 __fastcall InputNumeric(int a1, char *src, int a3, int a4, __int16 a5, int a6);
__int64 __fastcall InputNumericID(unsigned int a1, unsigned int a2, int a3, int a4, __int16 a5, int a6);
int __fastcall InputInteger(const char *a1, const char *a2);
int __fastcall InputIntegerID(unsigned int a1, unsigned int a2);
int __fastcall InputStringEx(int a1, char *src, int a3, int a4, __int16 a5);
int __fastcall InputStringExID(unsigned int a1, unsigned int a2, int a3, int a4, __int16 a5);
int __fastcall InputString(const char *a1, const char *a2, char *a3, signed int a4);
int __fastcall InputStringID(unsigned int a1, unsigned int a2, char *a3, signed int a4);
int __fastcall InitActiveTest(int a1, int a2, int a3, int a4);
int __fastcall ActiveTestAddButton(signed int a1);
int __fastcall AddActiveTestItem(signed int a1, const char *a2);
int __fastcall ShowActiveTestItem(int a1, time_t a2, int a3, int a4);
int __fastcall ShowActiveTestItemUseTitleID(signed int a1);
signed int OnEnterDiagnosticProgram();
int OnExitDiagnosticProgram();
void sub_10128();
int __fastcall ShowPicture(signed int a1);
size_t __fastcall FileDialog(int a1, int a2, char *src, char *a4, char *dest, size_t n);
char *__fastcall GetSmartboxSn(char *a1);
char *__fastcall GetTextName(char *a1);
int __fastcall SendGGPNametoShowProcess(char *a1, const char *a2);
int __fastcall cal_digest_context(char *src, _DWORD *a2);
signed int __fastcall License(int a1);
int __fastcall hex2int(int a1, int a2, int a3);
char *__fastcall GetStdText(int a1);
int __fastcall GetInfoFormGdscanIni(char *a1, const char *a2, int a3);
int __fastcall InitStd(int a1);
int __fastcall SetInfoToGdscanIni(char *a1, const char *a2, int a3);
signed int __fastcall GetInfoFromModifyList(int a1, int a2, char *a3, size_t a4);
signed int __fastcall GetBoxSerialNum(char *a1);
int __fastcall AddMenuText(char *src); // idb
int __fastcall InitMenu(char *a1);
int __fastcall ShowMenuTextGetSelectedItem(char a1, char a2, _WORD *a3);
int __fastcall ShowAgingInfo(char *src, char *a2);
int Disclaimer();
signed int __fastcall wrfile2(const char *a1);
int __fastcall InitActiveTestByMenu(int a1, int a2, int a3, int a4);
signed int GetStdVerInfo();
int __fastcall InitDataStreamEx(signed int a1, signed int a2, void *a3);
int __fastcall AddDataStreamItemEx(signed int a1, const char *a2);
int __fastcall ShowDataStreamEx(void *a1, time_t a2, int a3, int a4);
int __fastcall GetDataStreamItem(signed int a1, void *a2, void *a3);
int __fastcall InitSpecialFunction(signed int a1);
int __fastcall AddSpecialFunctionColumn(signed int a1, signed int a2, signed int a3);
int __fastcall AddSpecialFunctionButton(signed int a1);
int __fastcall AddSpecialFunctionItem(__int16 a1, int a2, int a3, int a4);
int __fastcall ShowSpecialFunction(int a1, time_t a2, int a3, int a4);
int __fastcall InitTroubleCodeEx(char *src); // idb
int __fastcall AddTroubleCodeEx(signed int a1, signed int a2);
int ShowTroubleCodeEx();
int __fastcall InitTroubleCodeFrozenEx(char *src); // idb
int __fastcall AddTroubleCodeFrozenEx(signed int a1, signed int a2);
int ShowTroubleCodeFrozenEx();
signed int __fastcall IsTroubleCodeIdSameByCombine(int a1);
int InitTroubleCodeByCombine();
int __fastcall AddTroubleCodeByCombine(int a1, char *a2);
int ShowTroubleCodeByCombine();
int InitTroubleCodeFrozenByCombine();
int __fastcall AddTroubleCodeFrozenByCombine(int a1, char *a2);
int ShowTroubleCodeFrozenByCombine();
int __fastcall InitTroubleCodeExByCombine(char *src); // idb
int __fastcall AddTroubleCodeExByCombine(int a1, char *a2);
int ShowTroubleCodeExByCombine();
int __fastcall InitTroubleCodeFrozenExByCombine(char *src); // idb
int __fastcall AddTroubleCodeFrozenExByCombine(int a1, char *a2);
int ShowTroubleCodeFrozenExByCombine();
int __fastcall ShowNoWaitMessageBox(char *a1, const char *a2);
int __fastcall ShowNoWaitMessageBoxID(unsigned int a1, unsigned int a2);
int __fastcall ShowProgressBarBox(char *a1, const char *a2, __int16 a3);
int __fastcall ShowProgressBarBoxID(unsigned int a1, unsigned int a2, __int16 a3);
int __fastcall InitTroubleCodeByLoopMode(char *src); // idb
int __fastcall AddTroubleCodeByLoopMode(int a1, char *a2);
int ShowTroubleCodeByLoopMode();
int __fastcall InitCombinationMenu(char *src, int a2);
int __fastcall AddCombinationMenu(char *src, char *a2);
int __fastcall ShowCombinationMenuGetSelectedItem(char a1, _WORD *a2);
int __fastcall SetVin(void *src, size_t n); // idb
int __fastcall GetVin(void *a1, unsigned int a2);
int __fastcall SupportConnect(int a1, signed int *a2);
int __fastcall SendGGPPathNametoShowProcess(const char *a1);
int __fastcall GetDisplayModuleVersion(char *a1);
int __fastcall ShowDiagPicture(const char *a1);
int __fastcall InitMenuIDWithHelp(signed int a1, signed int a2);
int __fastcall InitMenuWithHelp(signed int a1, char *a2);
int __fastcall InitFixedItemActiveTest(int a1, int a2, int a3, int a4);
signed int __fastcall GetDiagVersion(char *a1);
int InitTransDiagData();
int __fastcall AddTransDiagData(void *src, size_t n); // idb
int ShowTransDiagData();
int __fastcall ShowTransDiagDataEx(int, size_t n, int, int, int); // idb
int GetDeviceDistrict();
int __fastcall InitTroubleCodeWithHelp(char *src); // idb
int __fastcall AddTroubleCodeWithHelp(int a1, char *a2);
int ShowTroubleCodeWithHelp();
int __fastcall InitMenuIDEx(signed int a1, signed int a2);
int __fastcall AddMenuTextIDEx(signed int a1);
int __fastcall ShowMenuGetSelectedItemEx(char a1, char a2, _WORD *a3, _WORD *a4, _WORD *a5);
int InitTroubleCodeWithSystem();
int __fastcall AddTroubleCodeWithSystem(signed int a1, signed int a2);
int __fastcall ShowTroubleCodeWithSystem(_WORD *a1, _WORD *a2);
int __fastcall InitDataStreamExWithSystem(signed int a1, signed int a2, void *a3);
int __fastcall AddDataStreamItemExWithSystem(signed int a1, const char *a2);
int __fastcall ShowDataStreamExWithSystem(void *a1, _DWORD *a2, _WORD *a3, _WORD *a4);
int __fastcall StartRecordDiagData(char a1, const char *a2);
int __fastcall StopRecordDiagData(char a1, const char *a2);
int __fastcall InitCombinationSubItem(char *a1);
int __fastcall AddCombinationSubItem(char *src); // idb
int ShowCombinationSubItemGetSelectedItem();
int __fastcall SetCurrentMenuPath(char *src); // idb
int __fastcall EnableHistoryRecord(unsigned int a1);
int __fastcall RecordMake(char *src); // idb
int __fastcall RecordModel(char *src); // idb
int __fastcall RecordSubmodel(char *src); // idb
int __fastcall RecordEngine(char *src); // idb
int __fastcall RecordYear(char *src); // idb
int __fastcall RecordVin(char *src); // idb
int __fastcall RecordActiveTest(char *src, const char *a2);
int __fastcall RecordSystemIDInfo(char *src, size_t a2, void *a3, size_t a4, char *srca);
int GetSysNum();
int __fastcall GetSystemIDInfo(void *a1, int a2, int a3, int *a4, void *a5, signed int a6, signed int *a7);
int __fastcall RecordDSAvailableInfo(char *src); // idb
int __fastcall GetDSAvailableInfo(void *a1, int a2, const void *a3, size_t a4);
int __fastcall RecordActiveTestAvailableInfo(char *src); // idb
int __fastcall GetActiveTestAvailableInfo(void *a1, int a2, const void *a3, size_t a4);
int __fastcall RecordVehicleInfo(char *src); // idb
size_t __fastcall GetVehicleInfo(char *a1);
int __fastcall RecordMenuPath(char *src); // idb
size_t __fastcall GetMenuPath(char *a1);
int GetDiagProcessWay();
int __fastcall SetDiagFuncInfo(char a1, const char *a2, char a3);
int __fastcall InitSpecialDataStream(signed int a1, char a2);
int __fastcall SetSpecialDataStreamMainItemRange(char *src, const char *a2);
int __fastcall AddSpecialDataStreamMainItem(signed int a1, const char *a2);
int __fastcall AddSpecialDataStreamAttachedItem(signed int a1, const char *a2, char *a3, char *a4);
int __fastcall ShowSpecialDataStream(int a1, time_t a2, int a3, int a4);
int __fastcall ShowFileDialogGetSelectedFile(char *a1);
int __fastcall InitDataStreamExWithStandardValue(signed int a1, signed int a2, void *a3);
int __fastcall AddDataStreamItemExWithStandardValue(signed int a1, const char *a2, char *a3, char a4);
int __fastcall ShowDataStreamExWithStandardValue(void *a1, time_t a2, int a3, int a4);
size_t __fastcall InitCustomMessageBox(const char *a1, const char *a2);
int __fastcall AddCustomMessageBoxButton(signed int a1);
int ShowCustomMessageBox();
int __fastcall InitTroubleCodeExWithReturnValue(char *src); // idb
int __fastcall AddTroubleCodeExReturnValue(signed int a1, signed int a2);
int ShowTroubleCodeExReturnValue();
int __fastcall CallServiceAlgorithmBase(int, size_t n, int, int, int); // idb
int __fastcall ShowDtcHelp(const char *a1, const char *a2, char *a3, signed int a4);
int __fastcall ShowFunctionHelp(const char *a1, const char *a2, char *a3, signed int a4);
int __fastcall Download_ecu_file(const char *a1, const char *a2, char *a3);
int __fastcall InputCustomString(int a1, char *src, int a3, int a4, __int16 a5, char *srca, char *dest, __int16 a8);
int __fastcall InputCustomStringID(unsigned int a1, unsigned int a2, int a3, int a4, __int16 a5, char *a6, char *a7, __int16 a8);
int ResetHardware();
int __fastcall AddMenuAndHelpBtnTextTitleID(signed int a1);
int __fastcall InitMenuAndHelpBtnID(signed int a1);
int __fastcall AddMenuAndHelpBtnTextID(signed int a1, int a2);
int __fastcall ShowMenuAndHelpBtnGetSelectedItem(__int16 a1, __int16 a2, _WORD *a3, _BYTE *a4);
int __fastcall AddMenuTextAndHelpBtnTitle(char *src); // idb
int __fastcall InitMenuAndHelpBtn(char *a1);
int __fastcall AddMenuTextAndHelpBtn(char *src, int a2);
int __fastcall ShowMenuTextAndHelpBtnGetSelectedItem(__int16 a1, __int16 a2, _WORD *a3, _BYTE *a4);
int __fastcall InitMultiInputWindow(char *src); // idb
int __fastcall AddMultiInputWindow(char *src, const char *a2, int a3);
int __fastcall ShowMultiInputWindow(int a1);
int __fastcall VerifyMaintenanceQualifications(char *src, const char *a2);
int __fastcall QueryInfoFromWebsite(char *src, char *a2, char *a3);
FILE *__fastcall FOPEN(char *a1, char *a2);
void gdDebug();
void gdDebugFileLine();
int DoDownTask();
int DoUpTask();
signed int __fastcall MenuTreeDispose(int a1);
signed int __fastcall SetfVehicleVersion(int a1);
int __fastcall OpenFileIssueSearchID(char *a1);
void __fastcall CloseFileIssueSearchID(FILE **a1);
int __fastcall GagDecrypt(int a1, int a2, int a3, unsigned int a4);
signed int __fastcall EncryptNumber(int a1, int a2, int a3, unsigned int a4);
__int64 __fastcall NN_Decode(__int64 a1, int a2, int a3);
int __fastcall NN_Encode(int result, int a2, unsigned int *a3, unsigned int a4);
_DWORD *__fastcall NN_Assign(_DWORD *result, int *a2, int a3);
_DWORD *__fastcall NN_AssignZero(_DWORD *result, int a2);
_DWORD *__fastcall NN_Assign2Exp(_DWORD *a1, unsigned int a2, int a3);
unsigned int __fastcall NN_Add(int *a1, int *a2, int *a3, int a4);
int __fastcall NN_Sub(unsigned int *a1, int *a2, _DWORD *a3, int a4);
unsigned int __fastcall NN_LShift(unsigned int *a1, unsigned int *a2, unsigned int a3, int a4);
unsigned int __fastcall NN_RShift(int a1, int a2, unsigned int a3, int a4);
signed int __fastcall NN_Cmp(int a1, int a2, int a3);
signed int __fastcall NN_Zero(int *a1, int a2);
int __fastcall NN_Digits(int a1, int a2);
int __fastcall NN_Bits(int a1, int a2);
char *__fastcall NN_Div(_DWORD *a1, _DWORD *a2, int a3, int a4, unsigned int *a5, int a6);
void *__fastcall NN_Mod(_DWORD *a1, int a2, int a3, unsigned int *a4, int a5);
void *__fastcall NN_Gcd(_DWORD *a1, int *a2, int *a3, int a4);
void *__fastcall NN_Mult(_DWORD *a1, int a2, int a3, int a4);
void *__fastcall NN_ModInv(unsigned int *a1, int *a2, int *a3, int a4);
void *__fastcall NN_ModMult(_DWORD *a1, int a2, int a3, unsigned int *a4, int a5);
void *__fastcall NN_ModExp(_DWORD *a1, int *a2, int a3, int a4, unsigned int *a5, int a6);
signed int __fastcall sub_14F1C(int a1, int *a2, int a3, int a4, _DWORD *a5);
signed int __fastcall RSAPublicDecrypt(void *a1, _DWORD *a2, int a3, unsigned int a4, _DWORD *a5);
signed int __fastcall RSAPrivateEncrypt(int a1, int *a2, const void *a3, size_t a4, _DWORD *a5);
signed int __fastcall RSAPrivateDecrypt(void *a1, _DWORD *a2, int a3, unsigned int a4, int *a5);
int __fastcall sub_15408(int result, int a2, signed int a3);
void *__fastcall sub_1542C(void *a1, int a2, int a3, signed int a4);
void *__fastcall sub_1545C(void *src, size_t n);
unsigned __int64 __fastcall sub_15490(unsigned int a1, int a2);
__int64 __fastcall sub_154FC(int a1, int a2);
unsigned __int64 __fastcall sub_1559C(unsigned int a1, int a2, unsigned int a3, int a4);
unsigned int __fastcall DesDo(unsigned int a1, int a2, int a3, const void *a4, signed int a5, unsigned __int8 a6);
unsigned int __fastcall read_file(FILE *stream, void *ptr, size_t *a3, size_t a4);
int __fastcall Package(int a1, char a2, int a3, int a4);
signed int __fastcall SendLicenseData(int a1, int a2, int a3);
int SendLicenseResetData();
signed int __fastcall SendLicenseData2(int a1, int a2, int a3);
signed int __fastcall SendLicenseData_test(int a1, int a2, int a3);
int __fastcall verify_file(FILE *a1, int a2);
int __fastcall verify_file_with_box_no(FILE *a1, int a2, char *a3);
int __fastcall cal_context_dir(char *src, _DWORD *a2);
int __fastcall cal_context(const char *a1, _DWORD *a2);
signed int __fastcall Resetdpu(int a1, int a2);
signed int __fastcall CheckLicense(const char *a1, void *a2);
signed int __fastcall dbs_verify_diag_file(int a1, int a2);
int __fastcall ResetDpuToDownload(int a1, int a2);
void *__fastcall jstringToChar(int a1, int a2);
int (*__fastcall Java_com_ifoer_expedition_ndk_StdJni_setCallbackEnv(int a1, int a2, int a3))(void);
int __fastcall NotifyDataReadyWaitAnswerSendData(void *a1, size_t a2);
int __fastcall NotifyErrorCode(int a1, int a2);
int __fastcall Java_com_ifoer_expedition_ndk_StdJni_setStateCode(int a1, int a2, int a3);
size_t __fastcall Java_com_ifoer_expedition_ndk_StdJni_setDiagPrivateFilePath(int a1, int a2, int a3);
int __fastcall SendDataToSmartBoxGetBinaryString(void *a1, size_t a2, void *a3, size_t a4);
int __fastcall SendDataToSmartBoxGetBinaryStringNoFixMode(void *a1, size_t a2, void *a3, size_t a4);
int __fastcall ReceiveDataByTime(void *a1, size_t a2);
int __fastcall GetLocalLanguage(int a1, int a2, int a3);
int __fastcall DiagGetFilePath(char *a1, int a2);
int __fastcall DiagGetPrivateFilePath(char *a1, int a2);
_DWORD *__fastcall GetConnectorLinkMode(int a1, int a2, int a3);
_DWORD *__fastcall GetConnectorReady(int a1, int a2, int a3);
int __fastcall NotifyConnector(int a1, int a2, int a3);
int __fastcall GetAppVehicleVersionPath(char *a1, int a2, int a3);
int __fastcall _gnu_thumb1_case_uqi(int result);
int __fastcall sub_172B8(int result, unsigned int a2);
int __fastcall _aeabi_drsub(__int64 a1, __int64 a2);
int __fastcall _subdf3(_DWORD, _DWORD, _DWORD, _DWORD); // weak
int __fastcall _aeabi_dadd(__int64 a1, __int64 a2);
int __fastcall _floatunsidf(int result);
int __fastcall _floatsidf(int result);
int __fastcall _extendsfdf2(int a1, int a2, int a3, unsigned int a4);
int __fastcall _floatundidf(__int64 a1);
int __fastcall _floatdidf(__int64 a1);
void _gtdf2();
void _ltdf2();
int __fastcall _nedf2(unsigned int a1, unsigned int a2, unsigned int a3, signed int a4);
unsigned int __fastcall _aeabi_cdrcmple(unsigned int a1, signed int a2, unsigned int a3, unsigned int a4);
void __fastcall __spoils<R1,R2,R3,R12> _aeabi_cdcmple(unsigned int a1, unsigned int a2, unsigned int a3, signed int a4);
signed int __fastcall _aeabi_dcmpeq(unsigned int a1, unsigned int a2, unsigned int a3, signed int a4);
signed int __fastcall _aeabi_dcmplt(unsigned int a1, unsigned int a2, unsigned int a3, signed int a4);
signed int __fastcall _aeabi_dcmple(unsigned int a1, unsigned int a2, unsigned int a3, signed int a4);
signed int __fastcall _aeabi_dcmpge(unsigned int a1, signed int a2, unsigned int a3, unsigned int a4);
signed int __fastcall _aeabi_dcmpgt(unsigned int a1, signed int a2, unsigned int a3, unsigned int a4);
int __fastcall _aeabi_frsub(int a1, int a2, int a3, unsigned int a4);
int __fastcall _aeabi_fadd(int result, int a2, int a3, unsigned int a4);
void _floatunsisf();
int __fastcall _floatsisf(int result);
int __fastcall _floatundisf(__int64 a1);
int __fastcall _floatdisf(__int64 a1);
int __fastcall _mulsf3(unsigned int a1, unsigned int a2, int a3, int a4);
int __fastcall _divsf3(unsigned int a1, unsigned int a2, int a3, int a4);
int _aeabi_ldiv0();
int __fastcall sub_17DE8(char *a1);
int __fastcall sub_17E00(int a1, int a2);
void __fastcall sub_17FD4(__int64 a1);
signed int __fastcall sub_18040(int a1, int a2, int a3);
signed int __fastcall sub_18154(int a1, int a2, int a3, int a4, unsigned int a5);
signed int __fastcall Unwind_VRS_Get(int a1, unsigned int a2, unsigned int a3, int a4, unsigned int a5);
int __fastcall sub_181F0(int a1, unsigned int a2, int a3, int a4);
signed int __fastcall Unwind_VRS_Set(signed int result, _DWORD *a2, unsigned int a3, int a4, _DWORD *a5);
signed int __fastcall sub_1825C(signed int a1, unsigned int a2, int a3);
signed int __fastcall sub_18288(char a1, int a2, int a3, int a4);
signed int __fastcall _aeabi_unwind_cpp_pr2(char a1, int a2, int a3);
signed int __fastcall _aeabi_unwind_cpp_pr1(char a1, int a2, int a3);
signed int __fastcall _aeabi_unwind_cpp_pr0(char a1, int a2, int a3);
signed int __fastcall Unwind_VRS_Pop(int a1, int a2, unsigned int a3, int a4);
int __fastcall Unwind_GetCFA(int a1);
signed int __fastcall _gnu_Unwind_RaiseException(int a1, int a2);
signed int __fastcall _gnu_Unwind_ForcedUnwind(int a1, int a2, int a3, int a4);
void __fastcall _gnu_Unwind_Resume(int a1, int a2, int a3, unsigned int a4);
signed int __fastcall _gnu_Unwind_Resume_or_Rethrow(int a1, int a2);
int __fastcall Unwind_DeleteException(int result);
signed int __fastcall _gnu_Unwind_Backtrace(int (__fastcall *a1)(int *, int), int a2, int a3);
void __fastcall restore_core_regs(int a1);
int __fastcall _gnu_Unwind_Restore_VFP(__int64 _R0);
__int64 _gnu_Unwind_Save_VFP();
int __fastcall _gnu_Unwind_Restore_VFP_D(__int64 _R0);
__int64 _gnu_Unwind_Save_VFP_D();
void _gnu_Unwind_Restore_VFP_D_16_to_31();
void _gnu_Unwind_Save_VFP_D_16_to_31();
int __fastcall _gnu_Unwind_Restore_WMMXD(_DWORD *a1);
void _gnu_Unwind_Save_WMMXD();
int __fastcall _gnu_Unwind_Restore_WMMXC(_DWORD *a1);
void _gnu_Unwind_Save_WMMXC();
signed int __fastcall __Unwind_RaiseException(int a1, int a2, int a3, int a4);
void __fastcall __Unwind_Resume(int a1, int a2, int a3, int a4);
signed int __fastcall __Unwind_Resume_or_Rethrow(int a1, int a2, int a3, int a4);
signed int __fastcall __Unwind_ForcedUnwind(int a1, int a2, int a3, int a4);
signed int __fastcall __Unwind_Backtrace(int (__fastcall *a1)(int *, int), int a2, int a3, int a4);
signed int __fastcall sub_18D6C(int a1);
signed int __fastcall _gnu_unwind_execute(int a1, int a2, int a3, int a4);
signed int __fastcall _gnu_unwind_frame(int a1, int a2, int a3, int a4);
int __fastcall Unwind_GetRegionStart(int a1, int a2, int a3, int a4);
int __fastcall Unwind_GetLanguageSpecificData(int a1, int a2, int a3, int a4);
void Unwind_GetDataRelBase();
void Unwind_GetTextRelBase();

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN loc_174A4; // weak
_UNKNOWN loc_17500; // weak
_UNKNOWN loc_17720; // weak
_UNKNOWN loc_17778; // weak
_UNKNOWN loc_17A3C; // weak
_UNKNOWN loc_17A7C; // weak
_UNKNOWN loc_17A94; // weak
_UNKNOWN loc_17B80; // weak
_UNKNOWN loc_17C10; // weak
_UNKNOWN loc_17C58; // weak
_UNKNOWN loc_17C6C; // weak
_UNKNOWN unk_1A27E; // weak
_UNKNOWN unk_1A281; // weak
_UNKNOWN unk_1A284; // weak
_UNKNOWN unk_1A6BE; // weak
_UNKNOWN unk_24641; // weak
_UNKNOWN unk_24645; // weak
_UNKNOWN unk_24BC4; // weak
_UNKNOWN unk_24BD4; // weak
_BYTE byte_24C0C[72] =
{
  1,
  1,
  2,
  2,
  2,
  2,
  2,
  2,
  1,
  2,
  2,
  2,
  2,
  2,
  2,
  1,
  14,
  17,
  11,
  24,
  1,
  5,
  3,
  28,
  15,
  6,
  21,
  10,
  23,
  19,
  12,
  4,
  26,
  8,
  16,
  7,
  27,
  20,
  13,
  2,
  41,
  52,
  31,
  37,
  47,
  55,
  30,
  40,
  51,
  45,
  33,
  48,
  44,
  49,
  39,
  56,
  34,
  53,
  46,
  42,
  50,
  36,
  29,
  32,
  32,
  1,
  2,
  3,
  4,
  5,
  4,
  5
}; // idb
_UNKNOWN unk_24C7C; // weak
_UNKNOWN unk_24E7C; // weak
_UNKNOWN unk_24E9C; // weak
_UNKNOWN unk_24EDC; // weak
_UNKNOWN unk_24F1C; // weak
_UNKNOWN unk_25128; // weak
int (*GLOBAL_OFFSET_TABLE_)(void) = NULL; // weak
_UNKNOWN unk_27000; // weak
int dword_27004 = 1; // weak
int dword_27008 = 19200; // weak
int dword_2700C = 4294967295; // weak
int dword_27010 = 4294967295; // weak
_UNKNOWN unk_27014; // weak
_UNKNOWN unk_27054; // weak
_UNKNOWN unk_27061; // weak
char byte_27068 = 'v'; // weak
char byte_27069 = 'r'; // weak
char byte_2706A = 't'; // weak
char byte_2706B = 'x0E'; // weak
_UNKNOWN unk_2708A; // weak
__int16 word_2708C = 0; // weak
__int16 word_2708E = 0; // weak
int dword_27090 = 0; // weak
_UNKNOWN g_isggpnew; // weak
int dword_27098 = 1; // weak
int dword_2709C = 1; // weak
int dword_270A0 = 1; // weak
int dword_270A4 = 1; // weak
int dword_270A8 = 1; // weak
int dword_270AC = 1; // weak
int dword_270B0 = 1; // weak
int dword_270B4 = 1; // weak
int dword_270B8 = 1; // weak
int dword_270BC = 1; // weak
int dword_270C0 = 1; // weak
int dword_270C4 = 1; // weak
int dword_270C8 = 1; // weak
void *g_pSwapDataBuffer = &pSwapDataBuffer; // weak
char *ShowText = "ACTUATION TEST"; // weak
int dword_2990C; // weak
__int16 word_29910; // weak
int dword_29918; // weak
int dword_2991C; // weak
char g_bCounter[4]; // idb
char byte_29924[]; // weak
char byte_29A24[]; // weak
char byte_29A25; // weak
char byte_29B24[]; // weak
char byte_29B25; // weak
char byte_29B27; // weak
_BYTE byte_29C24[99]; // idb
char byte_29C87; // weak
_DWORD dword_29D24[256]; // idb
_UNKNOWN unk_2A124; // weak
_UNKNOWN unk_2A19C; // weak
_UNKNOWN g_shareggpname; // weak
char g_ggpname[256]; // idb
_UNKNOWN fpggp; // weak
_UNKNOWN unk_2A89C; // weak
_UNKNOWN unk_2A89E; // weak
_UNKNOWN unk_2A89F; // weak
_UNKNOWN unk_2A8A4; // weak
_UNKNOWN unk_2A8A8; // weak
_UNKNOWN unk_2A8AC; // weak
_UNKNOWN unk_2A8B0; // weak
void *dword_2A8B4; // idb
char byte_2A8B8; // weak
int (__fastcall *dword_2A8BC)(_DWORD, _DWORD, _DWORD); // weak
int dword_2A8C0; // weak
__int16 word_2A8C4; // weak
int dword_2A8CC; // weak
__int16 word_2A8D0; // weak
int dword_2A8D8; // weak
__int16 word_2A8DC; // weak
int dword_2A8E4; // weak
__int16 word_2A8E8; // weak
char byte_2A8F0; // weak
int dword_2A8F4; // weak
__int16 word_2A8F8; // weak
int dword_2A900; // weak
int dword_2A904; // weak
__int16 word_2A908; // weak
int dword_2A910; // weak
__int16 word_2A914; // weak
int dword_2A91C; // weak
__int16 word_2A920; // weak
int dword_2A928; // weak
__int16 word_2A92C; // weak
int dword_2A934; // weak
__int16 word_2A938; // weak
int dword_2A940; // weak
__int16 word_2A944; // weak
int dword_2A94C; // weak
__int16 word_2A950; // weak
int dword_2A958; // weak
__int16 word_2A95C; // weak
_UNKNOWN s_iShowProcessID; // weak
_UNKNOWN g_BoxInformation; // weak
_UNKNOWN unk_2A987; // weak
_UNKNOWN unk_2A9CC; // weak
int dword_2AA30; // weak
int dword_2AA34; // weak
int dword_2AA38; // weak
int dword_2AA3C; // weak
_BYTE byte_2AA40[140]; // idb
_BYTE byte_2AB40[1024]; // idb
_BYTE byte_2AF40[256]; // idb
_UNKNOWN unk_2B040; // weak
_UNKNOWN unk_2B05C; // weak
char byte_2B080[]; // weak
char algn_2B086[58]; // weak
char byte_2B0D0; // weak
_UNKNOWN unk_2B0F0; // weak
_UNKNOWN unk_2B110; // weak
_UNKNOWN unk_2B118; // weak
_UNKNOWN unk_2B120; // weak
_UNKNOWN unk_2B420; // weak
char byte_2B720; // weak
_UNKNOWN libm_handle; // weak
_UNKNOWN pSwapDataBuffer; // weak
_UNKNOWN unk_2B729; // weak
_UNKNOWN unk_2B72A; // weak
_UNKNOWN unk_2B72B; // weak
_UNKNOWN unk_2B72C; // weak
_UNKNOWN unk_2B72D; // weak
_UNKNOWN unk_2B72E; // weak
_UNKNOWN unk_2B72F; // weak
_UNKNOWN unk_2B730; // weak
unsigned __int8 byte_2B731[10231]; // idb
char FileName[45]; // idb
_UNKNOWN unk_2DF55; // weak
_UNKNOWN unk_2DF8C; // weak
_UNKNOWN unk_2DFB9; // weak
_UNKNOWN unk_2DFF0; // weak
_UNKNOWN unk_2E01D; // weak
_UNKNOWN unk_2E054; // weak
_UNKNOWN unk_2E0B8; // weak
_UNKNOWN unk_2E11C; // weak
_UNKNOWN unk_2E180; // weak
_UNKNOWN unk_2E1E4; // weak
_UNKNOWN unk_2E248; // weak
_UNKNOWN unk_2E2AC; // weak
_UNKNOWN unk_2E310; // weak
_UNKNOWN unk_2E374; // weak
_UNKNOWN unk_2E3D8; // weak
_DWORD fkey[120]; // idb
_DWORD rkey[120]; // idb
char config_file_path[256]; // idb
_DWORD IndexList[32]; // idb
_UNKNOWN BOXVERSION; // weak
_UNKNOWN x; // weak
_UNKNOWN unk_2E9E0; // weak
_UNKNOWN unk_2E9E4; // weak
_UNKNOWN unk_2E9E8; // weak
_UNKNOWN unk_2E9EC; // weak
_UNKNOWN unk_2E9F0; // weak
_UNKNOWN unk_2E9F4; // weak
_UNKNOWN unk_2E9F8; // weak
_UNKNOWN unk_2E9FC; // weak
_UNKNOWN unk_2EA00; // weak
_UNKNOWN unk_2EA04; // weak
_UNKNOWN unk_2EA08; // weak
_UNKNOWN unk_2EA0C; // weak
_UNKNOWN unk_2EA10; // weak
_UNKNOWN unk_2EA14; // weak
_UNKNOWN unk_2EA18; // weak
_UNKNOWN IniFileName; // weak
_BYTE fi[24]; // idb
_BYTE ri[24]; // idb
int (*AnalysisDataFromStdAndUIWait)(void); // weak
_UNKNOWN IndexNum; // weak
_UNKNOWN Nb; // weak
int Nk; // idb
_UNKNOWN Nr; // weak
_UNKNOWN a; // weak
_UNKNOWN b; // weak
_UNKNOWN c; // weak
void *cFileData; // idb
_UNKNOWN d; // weak
_UNKNOWN gGetAppVehicleVersionPath; // weak
_UNKNOWN gGetConnectorLinkMode; // weak
_UNKNOWN gGetConnectorReady; // weak
_UNKNOWN gGetLocalLanguage; // weak
_UNKNOWN gNotifyConnector; // weak
_UNKNOWN gReceiveDataByTime; // weak
_UNKNOWN gWriteAndReadMethod; // weak
_UNKNOWN gWriteAndReadMethod2701; // weak
_UNKNOWN g_cls; // weak
_UNKNOWN g_fIssVehiclesVersion; // weak
_UNKNOWN g_i; // weak
_UNKNOWN g_index; // weak
_UNKNOWN g_partLen; // weak
_DWORD *gs_jvm; // idb
size_t lFileDataLen; // idb
_UNKNOWN len; // weak
_UNKNOWN mObject; // weak
_UNKNOWN m_mid; // weak
_UNKNOWN m_mid_notifyerror; // weak
_UNKNOWN memcpy_i; // weak
_UNKNOWN pFilePath; // weak
const char *pPrivatePath; // idb
_UNKNOWN privatelen; // weak
_UNKNOWN s_pDiagnosticShareAddress; // weak
// extern _UNKNOWN _stack_chk_guard; weak
// extern _UNKNOWN toupper_tab_; weak
// extern _UNKNOWN __gnu_Unwind_Find_exidx; weak
// extern _UNKNOWN _cxa_call_unexpected; weak


//----- (0000AD64) --------------------------------------------------------
int sub_AD64()
{
  return _cxa_finalize(&unk_27000);
}
// AAA0: using guessed type int __fastcall _cxa_finalize(_DWORD);

//----- (0000AD74) --------------------------------------------------------
int __fastcall OpenCommunicationPort(char *a1)
{
  char *v1; // [email protected]
  size_t v2; // [email protected]
  char *v3; // [email protected]
  int result; // [email protected]
  int v5; // [sp+Ch] [bp-9Ch]@1
  char nptr; // [sp+14h] [bp-94h]@1
  char v7[100]; // [sp+28h] [bp-80h]@1
  int v8; // [sp+8Ch] [bp-1Ch]@1

  v1 = a1;
  v8 = _stack_chk_guard;
  GetPrivateProFileString((size_t)"Communication", "ComRate", "19200", &nptr, 0x14u, a1);
  v5 = atoi(&nptr);
  v2 = 0;
  GetPrivateProFileString((size_t)"Communication", "Port", "ttyS1", v7, 0x64u, v1);
  while ( v2 < strlen(v7) )
  {
    v7[v2] = *(_WORD *)(toupper_tab_ + 2 * ((unsigned __int8)v7[v2] + 1));
    ++v2;
  }
  if ( strstr(v7, "TTYS1") || (v3 = strstr(v7, "COM2")) != 0 )
    v3 = (char *)1;
  SetCommunicationPort((int)v3, v5);
  result = 0;
  if ( v8 != _stack_chk_guard )
    _stack_chk_fail(0);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);
// AD74: using guessed type char var_80[100];

//----- (0000AE40) --------------------------------------------------------
int __fastcall OpenCommunicationPortNew(char *a1)
{
  char *v1; // [email protected]
  size_t v2; // [email protected]
  char *v3; // [email protected]
  int result; // [email protected]
  int v5; // [sp+Ch] [bp-84h]@1
  char v6[100]; // [sp+10h] [bp-80h]@1
  int v7; // [sp+74h] [bp-1Ch]@1

  v1 = a1;
  v7 = _stack_chk_guard;
  v5 = GetPrivateProFileInt("Communication", "BaudRate", 19200, a1);
  v2 = 0;
  GetPrivateProFileString((size_t)"Communication", "Port", "ttyS1", v6, 0x64u, v1);
  while ( v2 < strlen(v6) )
  {
    v6[v2] = *(_WORD *)(toupper_tab_ + 2 * ((unsigned __int8)v6[v2] + 1));
    ++v2;
  }
  if ( strstr(v6, "TTYS1") || (v3 = strstr(v6, "COM2")) != 0 )
    v3 = (char *)1;
  SetCommunicationPort((int)v3, v5);
  result = 0;
  if ( v7 != _stack_chk_guard )
    _stack_chk_fail(0);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);
// AE40: using guessed type char var_80[100];

//----- (0000AEFC) --------------------------------------------------------
int CloseCommunicationPort()
{
  ClosePort();
  return 0;
}

//----- (0000AF08) --------------------------------------------------------
signed int __fastcall SendDownloadPackageGetAnswer(int a1, int a2, unsigned int a3)
{
  int v3; // [email protected]
  int v4; // [email protected]
  int v5; // [email protected]
  int v6; // [email protected]
  int v7; // [email protected]
  signed int v8; // [email protected]
  int v9; // [email protected]
  int v10; // [email protected]
  int v11; // [email protected]
  char v12; // [email protected]
  int v13; // [email protected]
  char v14; // [email protected]
  signed int v15; // [email protected]
  int v16; // [email protected]
  int v17; // [email protected]
  signed int v18; // [email protected]
  char v20; // [sp+0h] [bp-48h]@1
  char v21; // [sp+4h] [bp-44h]@1
  signed int v22; // [sp+8h] [bp-40h]@1
  int v23; // [sp+Ch] [bp-3Ch]@1
  int v24; // [sp+14h] [bp-34h]@11
  int v25; // [sp+18h] [bp-30h]@12
  unsigned int v26; // [sp+1Ch] [bp-2Ch]@1
  int v27; // [sp+20h] [bp-28h]@1
  int v28; // [sp+24h] [bp-24h]@1
  int v29; // [sp+2Fh] [bp-19h]@10

  v26 = a3;
  v3 = (unsigned __int8)(a3 + 3);
  v4 = ((signed int)(a3 + 3) >> 8) & 0xFF;
  v21 = v3;
  v20 = v4;
  v27 = v4 ^ v3 ^ a1;
  v5 = 10;
  v23 = a1;
  v28 = a2;
  v22 = 10;
  while ( 1 )
  {
    v8 = SendByte(v20, a2, v5);
    if ( !v8 )
    {
      v8 = SendByte(v21, v6, v7);
      if ( !v8 )
      {
        v8 = SendByte(v23, v9, v10);
        if ( !v8 )
          break;
      }
    }
LABEL_25:
    gdDebug();
LABEL_26:
    v5 = v22 - 1;
    v22 = v5;
    if ( !v5 )
      return v8;
  }
  v12 = v27;
  v13 = 0;
  while ( (unsigned __int16)v13 < v26 )
  {
    v14 = *(_BYTE *)(v28 + v13++);
    v15 = SendByte(v14, v11, v28);
    if ( v15 )
    {
      v8 = v15;
      goto LABEL_25;
    }
    v12 ^= v14;
  }
  v8 = SendByte(v12, v11, v26);
  if ( v8 )
    goto LABEL_25;
  v16 = 0;
  v17 = ReceiveByte(&v29);
  if ( !v17 )
  {
    v24 = (unsigned __int8)v29;
    v17 = ReceiveByte(&v29);
    if ( !v17 )
    {
      v25 = (unsigned __int8)v29;
      if ( (((v24 << 8) + (unsigned __int8)v29) & 0xFFFF) == 2 )
      {
        v17 = ReceiveByte(&v29);
        if ( v17 )
          goto LABEL_20;
        v16 = (unsigned __int8)v29;
        v17 = ReceiveByte(&v29);
        if ( v17 || (unsigned __int8)v29 == (v25 ^ v24 ^ v16) )
          goto LABEL_20;
        v18 = 13;
      }
      else
      {
        v16 = 0;
        v18 = 12;
      }
      v17 = -v18;
      goto LABEL_20;
    }
  }
LABEL_20:
  ErrorCode(v17);
  if ( !v17 )
    v17 = v16;
  if ( v17 != v23 )
  {
    sleep(1u);
    v8 = v17;
    goto LABEL_26;
  }
  return v8;
}

//----- (0000B01C) --------------------------------------------------------
int __fastcall Download(const char *a1)
{
  const char *v1; // [email protected]
  int v2; // [email protected]
  signed int v3; // [email protected]
  FILE *v4; // [email protected]
  FILE *v5; // [email protected]
  __int32 v6; // [email protected]
  int v7; // [email protected]
  int v8; // [email protected]
  signed int v9; // [email protected]
  int result; // [email protected]
  int v11; // [sp+8h] [bp-130h]@9
  unsigned __int8 v12; // [sp+13h] [bp-125h]@5
  time_t timer; // [sp+14h] [bp-124h]@1
  time_t v14; // [sp+18h] [bp-120h]@2
  char ptr; // [sp+1Ch] [bp-11Ch]@10
  char v16; // [sp+1Dh] [bp-11Bh]@13
  int v17; // [sp+11Ch] [bp-1Ch]@1

  v1 = a1;
  v17 = _stack_chk_guard;
  ResetBox(1u);
  OpenPort();
  time(&timer);
  do
  {
    time(&v14);
    if ( (signed int)(v14 - timer) > 10 )
    {
      v9 = 16;
LABEL_23:
      v8 = -v9;
      goto LABEL_24;
    }
    v3 = SendByte(85, v2, v14);
    if ( !v3 )
      v3 = ReceiveByte(&v12);
  }
  while ( v3 || v12 - 170 != v12 - 171 + ((unsigned int)v12 - 170 < 1) );
  v4 = fopen(v1, "rb");
  v5 = v4;
  if ( !v4 )
  {
    v9 = 17;
    goto LABEL_23;
  }
  fseek(v4, 0, 2);
  v6 = ftell(v5);
  fseek(v5, 0, 0);
  v11 = v6 / 256;
  v7 = v6 % 256;
  if ( v7 <= 0 )
    ptr = v11;
  else
    ptr = v11 + 1;
  v8 = SendDownloadPackageGetAnswer(4, (int)&ptr, 1u);
  if ( !v8 )
  {
    ptr = 0;
    v16 = 0;
    v8 = SendDownloadPackageGetAnswer(5, (int)&ptr, 2u);
    if ( !v8 )
    {
      while ( v8 < v11 )
      {
        fread(&ptr, 0x100u, 1u, v5);
        if ( SendDownloadPackageGetAnswer(6, (int)&ptr, 0x100u) )
          break;
        ++v8;
      }
      if ( v7 <= 0
        || (memset(&ptr, 0, 0x100u),
            fread(&ptr, v7, 1u, v5),
            (v8 = SendDownloadPackageGetAnswer(6, (int)&ptr, 0x100u)) == 0) )
      {
        v8 = SendDownloadPackageGetAnswer(7, (int)&ptr, 0);
      }
    }
  }
  fclose(v5);
  ClosePort();
  ErrorCode(v8);
LABEL_24:
  result = v8;
  if ( v17 != _stack_chk_guard )
    _stack_chk_fail(v8);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);

//----- (0000B194) --------------------------------------------------------
int wrfile()
{
  return 0;
}

//----- (0000B198) --------------------------------------------------------
int __fastcall ReadDpuSnInfo(char *a1, char *a2)
{
  signed int v2; // [email protected]
  int v3; // [email protected]
  int v4; // [email protected]
  const char *v5; // [email protected]
  int v6; // [email protected]
  int v7; // [email protected]
  int v8; // [email protected]
  const char *v9; // [email protected]
  int v10; // [email protected]
  char *v11; // [email protected]
  signed int v12; // [email protected]
  int result; // [email protected]
  char *dest; // [sp+Ch] [bp-42Ch]@1
  char *v15; // [sp+10h] [bp-428h]@1
  char v16; // [sp+18h] [bp-420h]@1
  char v17; // [sp+19h] [bp-41Fh]@1
  char s; // [sp+1Ch] [bp-41Ch]@3
  char v19; // [sp+1Dh] [bp-41Bh]@7
  __int16 v20; // [sp+1Eh] [bp-41Ah]@8
  int v21; // [sp+41Ch] [bp-1Ch]@1

  v15 = a2;
  v21 = _stack_chk_guard;
  v2 = 3;
  v16 = 33;
  dest = a1;
  v17 = 3;
  if ( !a1 )
  {
    v12 = 3;
LABEL_18:
    result = -v12;
    goto LABEL_20;
  }
  if ( !a2 )
  {
    v12 = 4;
    goto LABEL_18;
  }
  do
  {
    memset(&s, 0, 0x400u);
    v3 = SendDataToSmartBoxGetBinaryStringNoFixMode(&v16, 2u, &s, 0x400u);
    if ( v3 > 0 )
      break;
    --v2;
  }
  while ( v2 );
  v4 = v3 - 2;
  if ( v3 - 2 <= 2 || s != 97 || v19 != 3 )
  {
    v12 = 1;
    goto LABEL_18;
  }
  v5 = (const char *)&v20;
  v6 = 0;
  do
  {
    v7 = *v5;
    v8 = v5[1];
    v9 = v5 + 2;
    v10 = (v7 << 8) | v8;
    if ( v6 == 1 )
      v11 = dest;
    else
      v11 = v15;
    strcpy(v11, v9);
    v4 += -2 - v10;
    if ( v4 <= 0 )
      break;
    ++v6;
    v5 = &v9[v10];
  }
  while ( v6 != 2 );
  result = 0;
LABEL_20:
  if ( v21 != _stack_chk_guard )
    _stack_chk_fail(result);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);

//----- (0000B270) --------------------------------------------------------
int __fastcall WrfileCommData(const char *a1)
{
  const char *v1; // [email protected]
  FILE *v2; // [email protected]
  FILE *v3; // [email protected]
  size_t v4; // [email protected]
  int result; // [email protected]
  signed int v6; // [email protected]
  char dest; // [sp+4h] [bp-11Ch]@1
  int v8; // [sp+104h] [bp-1Ch]@1

  v1 = a1;
  v8 = _stack_chk_guard;
  if ( DiagGetFilePath(&dest, 256) )
  {
    v6 = 1;
  }
  else
  {
    strcat(&dest, "CommData.txt");
    v2 = fopen(&dest, "ab");
    v3 = v2;
    if ( v2 )
    {
      fseek(v2, 0, 2);
      v4 = strlen(v1);
      fwrite(v1, v4, 1u, v3);
      fclose(v3);
      result = 0;
      goto LABEL_7;
    }
    v6 = 2;
  }
  result = -v6;
LABEL_7:
  if ( v8 != _stack_chk_guard )
    _stack_chk_fail(result);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);

//----- (0000B2F4) --------------------------------------------------------
time_t __fastcall GetWaitTime(int a1, time_t a2, int a3, int a4)
{
  struct timeb timebuf; // [sp+4h] [bp-14h]@1

  timebuf.time = a2;
  *(_DWORD *)&timebuf.millitm = a3;
  *(_DWORD *)&timebuf.dstflag = a4;
  ftime(&timebuf);
  return 1000 * (timebuf.time - dword_2990C) + timebuf.millitm - (unsigned __int16)word_29910;
}
// 2990C: using guessed type int dword_2990C;
// 29910: using guessed type __int16 word_29910;

//----- (0000B320) --------------------------------------------------------
int __fastcall SetCommunicationPort(int result, int a2)
{
  dword_27004 = result;
  dword_27008 = a2;
  if ( a2 == 19200 )
    dword_27008 = 14;
  return result;
}
// 27004: using guessed type int dword_27004;
// 27008: using guessed type int dword_27008;

//----- (0000B33C) --------------------------------------------------------
int __fastcall ErrorCode(int result)
{
  if ( result )
    ++dword_29918;
  else
    dword_29918 = 0;
  dword_2991C = result;
  return result;
}
// 29918: using guessed type int dword_29918;
// 2991C: using guessed type int dword_2991C;

//----- (0000B368) --------------------------------------------------------
void CleanErrorCode()
{
  dword_29918 = 0;
  dword_2991C = 0;
}
// 29918: using guessed type int dword_29918;
// 2991C: using guessed type int dword_2991C;

//----- (0000B378) --------------------------------------------------------
int GetErrorCode()
{
  return dword_2991C;
}
// 2991C: using guessed type int dword_2991C;

//----- (0000B384) --------------------------------------------------------
int GetErrorTimes()
{
  return dword_29918;
}
// 29918: using guessed type int dword_29918;

//----- (0000B390) --------------------------------------------------------
int ClosePort()
{
  int result; // [email protected]

  result = dword_2700C;
  if ( dword_2700C != -1 )
    result = close(dword_2700C);
  dword_2700C = -1;
  return result;
}
// 2700C: using guessed type int dword_2700C;

//----- (0000B3B4) --------------------------------------------------------
void *__fastcall ResetBox(unsigned int a1)
{
  unsigned int v1; // [email protected]
  void *result; // [email protected]
  int v3; // [email protected]
  int v4; // [email protected]
  signed int v5; // [email protected]
  int v6; // [email protected]
  const char *v7; // [sp+4h] [bp-45Ch]@1
  const char *v8; // [sp+8h] [bp-458h]@1
  char s; // [sp+Ch] [bp-454h]@2
  int v10; // [sp+20h] [bp-440h]@5
  int v11; // [sp+24h] [bp-43Ch]@5
  unsigned int v12; // [sp+28h] [bp-438h]@5
  int v13; // [sp+2Ch] [bp-434h]@5
  char v14; // [sp+36h] [bp-42Ah]@5
  char v15; // [sp+37h] [bp-429h]@5
  char dest; // [sp+44h] [bp-41Ch]@1
  char v17; // [sp+53h] [bp-40Dh]@1
  int v18; // [sp+444h] [bp-1Ch]@1

  v1 = a1;
  v18 = _stack_chk_guard;
  v7 = "0SWITCHO";
  v8 = "0SWITCHI";
  memcpy(&dest, "Testdll false!", 0xFu);
  result = memset(&v17, 0, 0x3F1u);
  if ( v1 <= 1 )
  {
    ClosePort();
    sprintf(&s, "/dev/ttyS%d", dword_27004);
    v3 = open(&s, 2306);
    v4 = v3;
    if ( v3 == -1 )
    {
      strcpy(&dest, "n------无法打开串口----");
      wrfile();
      exit(1);
    }
    fcntl(v3, 4, 0, v3 + 1);
    ioctl(v4, 0x5401u, &v10);
    v5 = 3;
    v6 = 4 * v1;
    v10 &= 0xFFFFFA14;
    v11 &= 0xFFFFFFFE;
    v13 &= 0xFFFF7FB4;
    v12 = (v12 & 0xFFFFEFF0 | 0xB) & 0xFFFFFECF | 0x30;
    v15 = 0;
    v14 = 10;
    ioctl(v4, 0x5402u, &v10);
    ioctl(v4, 0x540Bu, 2);
    do
    {
      usleep(0xC8u);
      if ( write(v4, (&v7)[v6], 8u) == 8 )
        break;
      --v5;
    }
    while ( v5 );
    close(v4);
    result = (void *)usleep(0x7D0u);
  }
  if ( v18 != _stack_chk_guard )
    _stack_chk_fail(result);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);
// 27004: using guessed type int dword_27004;

//----- (0000B51C) --------------------------------------------------------
signed int OpenPort()
{
  int v0; // [email protected]
  int v1; // [email protected]
  signed int result; // [email protected]
  int v3; // [sp+0h] [bp-60h]@3
  int v4; // [sp+20h] [bp-40h]@4
  int v5; // [sp+24h] [bp-3Ch]@4
  unsigned int v6; // [sp+28h] [bp-38h]@4
  int v7; // [sp+2Ch] [bp-34h]@4
  char v8; // [sp+36h] [bp-2Ah]@4
  char v9; // [sp+37h] [bp-29h]@4
  int v10; // [sp+44h] [bp-1Ch]@1

  v10 = _stack_chk_guard;
  if ( dword_2700C != -1 )
    close(dword_2700C);
  ftime((struct timeb *)&dword_2990C);
  sprintf((char *)&v3, "/dev/ttyS%d", dword_27004);
  v0 = open((const char *)&v3, 2306);
  v1 = v0;
  if ( v0 != -1 )
  {
    fcntl(v0, 4, 0, v0 + 1);
    ioctl(v1, 0x5401u, &v4);
    v4 &= 0xFFFFFA14;
    v5 &= 0xFFFFFFFE;
    v7 &= 0xFFFF7FB4;
    v6 = (v6 & 0xFFFFEFF0 | dword_27008 & 0x100F) & 0xFFFFFECF | 0x30;
    v9 = 0;
    v8 = 20;
    ioctl(v1, 0x5402u, &v4);
    ioctl(dword_2700C, 0x540Bu, 2);
  }
  dword_2700C = v1;
  usleep(0x13880u);
  result = 0;
  if ( v1 == -1 )
    result = -11;
  if ( v10 != _stack_chk_guard )
    _stack_chk_fail(result);
  return result;
}
// AAD0: using guessed type int __fastcall _stack_chk_fail(_DWORD);
// 27004: using guessed type int dword_27004;
// 27008: using guessed type int dword_27008;
// 2700C: using guessed type int dword_2700C;
// 2990C: using guessed type int dword_2990C;

//----- (0000B624) --------------------------------------------------------
int __fastcall ReceiveByte(void *buf)
{
  void *v1; // [email protected]
  ssize_t v2; // [email protected]
  int result; // [email protected]

  v1 = buf;
  if ( dword_2700C == -1 )
    OpenPort();
  v2 = read(dword_2700C, v1, 1u);
  result = 0;
  if ( v2 != 1 )
    result = -14;
  return result;
}
// 2700C: using guessed type int dword_2700C;

//----- (0000B65C) --------------------------------------------------------
int __fastcall ReceiveDataNoFixMode(int a1, int a2)
{
  int v2; // [email protected]
  int v3; // [email protected]
  int v4; // [email protected]
  int v5; // [email protected]
  int v6; // [email protected]
  int v7; // [email protected]
  int v8; // [email protected]
  int v10; // [sp+0h] [bp-30h]@16
  int v11; // [sp+4h] [bp-2Ch]@15
  int v12; // [sp+8h] [bp-28h]@1
  int v13; // [sp+Ch] [bp-24h]@1
  unsigned __int8 v14; // [sp+17h] [bp-19h]@1

  v12 = a1;
  v13 = a2;
  v14 = 0;
  v2 = -14;
  while ( v14 != 170 )
  {
    v2 = ReceiveByte(&v14);
    if ( v2 )
      goto LABEL_31;
    if ( v14 == 85 )
    {
      v3 = ReceiveByte(&v14);
      if ( v3 )
      {
        v2 = v3;
LABEL_31:
        v4 = 0;
        goto LABEL_27;
      }
    }
    else
    {
      v14 = 0;
    }
  }
  v4 = 0;
  v5 = v2;
  if ( !v2 )
  {
    v2 = ReceiveByte(&v14);
    if ( !v2 )
    {
      if ( v14 != 248 )
        goto LABEL_34;
      v2 = ReceiveByte(&v14);
      if ( v2 )
        goto LABEL_27;
      if ( v14 != 240 )
      {
LABEL_34:
        v2 = -11;
        v4 = v5;
      }
      else
      {
        v2 = ReceiveByte(&v14);
        if ( !v2 )
        {
          v6 = v14;
          v2 = ReceiveByte(&v14);
          if ( !v2 )
          {
            v11 = v14;
            v2 = ReceiveByte(&v14);
            if ( !v2 )
            {
              v7 = 0;
              v10 = v11 ^ v6 ^ 8 ^ v14;
              v4 = (v6 << 8) + v11 - 1;
              while ( v7 < v4 )
              {
                v2 = ReceiveByte(&v14);
                if ( v2 )
                  goto LABEL_27;
                if ( v7 < v13 )
                  *(_BYTE *)(v12 + v7) = v14;
                v8 = v14;
                *(_BYTE *)(v12 + v7++) = v14;
                v10 ^= v8;
              }
              v2 = ReceiveByte(&v14);
              if ( !v2 )
              {
                if ( v14 == v10 )
                  ++g_bCounter;
                else
                  v2 = -13;
              }
            }
          }
        }
      }
    }
  }
LABEL_27:
  ErrorCode(v2);
  if ( v2 )
    v4 = 0;
  else
    ftime((struct timeb *)&dword_2990C);
  return v4;
}
// 2990C: using guessed type int dword_2990C;

//----- (0000B78C) --------------------------------------------------------
signed int __fastcall ReceiveData(int a1, int a2)
{
  int v2; // [email protected]
  int v3; // [email protected]
  int v4; // [email protected]
  int v5; // [email protected]
  int i; // [email protected]
  int v7; // [email protected]
  signed int v8; // [email protected]
  int v10; // [sp+4h] [bp-34h]@16
  int v11; // [sp+4h] [bp-34h]@20
  int v12; // [sp+8h] [bp-30h]@14
  signed int v13; // [sp+8h] [bp-30h]@21
  int v14; // [sp+Ch] [bp-2Ch]@1
  int v15; // [sp+10h] [bp-28h]@15
  int v16; // [sp+14h] [bp-24h]@1
  unsigned __int8 v17; // [sp+1Fh] [bp-19h]@1

  v16 = a1;
  v14 = a2;
  v17 = 0;
  v2 = -14;
  while ( v17 != 170 )
  {
    v2 = ReceiveByte(&v17);
    if ( v2 )
      goto LABEL_43;
    if ( v17 == 85 )
    {
      v3 = ReceiveByte(&v17);
      if ( v3 )
      {
        v2 = v3;
        goto LABEL_43;
      }
    }
    else
    {
      v17 = 0;
    }
  }
  v4 = v2;
  if ( v2 )
    goto LABEL_43;
  v5 = 0;
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  if ( v17 != 248 )
    goto LABEL_46;
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  if ( v17 != 240 )
  {
LABEL_46:
    v2 = -11;
    v5 = v4;
    goto LABEL_38;
  }
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  v12 = v17;
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  v15 = v17;
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  v10 = v17;
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  if ( v17 != 103 )
  {
    v2 = -11;
LABEL_43:
    v5 = 0;
    goto LABEL_38;
  }
  v5 = 0;
  v2 = ReceiveByte(&v17);
  if ( v2 )
    goto LABEL_38;
  if ( v17 != 1 )
  {
    v8 = 11;
LABEL_37:
    v2 = -v8;
    goto LABEL_38;
  }
  v11 = v10 ^ v12 ^ v15 ^ 0x6E;
  v5 = (v12 << 8) + v15 - 3;
  if ( v5 > v14 )
  {
    v5 = v14;
    v13 = 1;
  }
  else
  {
    v13 = 0;
  }
  for ( i = 0; i < v5; ++i )
  {
    v2 = ReceiveByte(&v17);
    if ( v2 )
      goto LABEL_38;
    if ( i < v14 )
      *(_BYTE *)(v16 + i) = v17;
    v7 = v11 ^ v17;
    *(_BYTE *)(v16 + i) = v17;
    v11 = v7;
  }
  if ( v13 )
    return -80;
  v2 = ReceiveByte(&v17);
  if ( !v2 )
  {
    if ( v17 == v11 )
    {
      ++g_bCounter[0];
      goto LABEL_38;
    }
    v8 = 13;
    goto LABEL_37;
  }
LABEL_38:
  ErrorCode(v2);
  if ( v2 )
    v5 = 0;
  else
    ftime((struct timeb *)&dword_2990C);
  return v5;
}
// 2990C: using guessed type int dword_2990C;

//----- (0000B910) --------------------------------------------------------
int __fastcall SendByteS(void *buf, size_t n)
{
  void *v2; // [email protected]
  size_t v3; // [email protected]
  ssize_t v4; // [email protected]
  int result; // [email protected]

  v2 = buf;
  dword_27004 = 1;
  dword_27008 = 38400;
  v3 = n;
  if ( dword_2700C == -1 )
    OpenPort();
  v4 = write(dword_2700C, v2, v3);
  result = 0;
  if ( v4 != v3 )
    result = -14;
  return result;
}
// 27004: using guessed type int dword_27004;
// 27008: using guessed type int dword_27008;
// 2700C: using guessed type int dword_2700C;

//----- (0000B954) --------------------------------------------------------
signed int __fastcall SendByte(char a1, int a2, int a3)
{
  ssize_t v3; // [email protected]
  signed int result; // [email protected]
  int v5; // [sp+4h] [bp-Ch]@1
  int v6; // [sp+8h] [bp-8h]@1

  v5 = a2;
  v6 = a3;
  BYTE3(v5) = a1;
  if ( dword_2700C == -1 )
    OpenPort();
  v3 = write(dword_2700C, (char *)&v5 + 3, 1u);
  result = 0;
  if ( v3 != 1 )
    result = -14;
  return result;
}
// 2700C: using guessed type int dword_2700C;

//----- (0000B990) --------------------------------------------------------
int __fastcall SendDataNoFixMode(int a1, int a2, int a3)
{
  int v3; // [email protected]
  int v4; // [email protected]
  int v5; // [email protected]
  int v6; // [email protected]
  int v7; // [email protected]
  int v8; // [email protected]
  int v9; // [email protected]
  int v10; // [email protected]
  int v11; // [email protected]
  int v12; // [email protected]
  int v13; // [email protected]
  int v14; // [email protected]
  int v15; // [email protected]
  int v16; // [email protected]
  int v17; // [email protected]
  int v18; // [email protected]
  int v19; // [email protected]
  int v20; // [email protected]
  int i; // [email protected]
  char v22; // [email protected]0
  int v24; // [sp+0h] [bp-20h]@1
  int v25; // [sp+4h] [bp-1Ch]@1

  v3 = a2 + 1;
  v25 = a1;
  v24 = a2;
  if ( a2 + 1 > 0xFFFF )
  {
    v6 = -10;
  }
  else
  {
    v6 = SendByte(85, a2, a3);
    if ( !v6 )
    {
      v6 = SendByte(-86, v4, v5);
      if ( !v6 )
      {
        v6 = SendByte(-16, v7, v8);
        if ( !v6 )
        {
          v6 = SendByte(-8, v9, v10);
          if ( !v6 )
          {
            v13 = (v3 >> 8) & 0xFF;
            v6 = SendByte(SBYTE1(v3), v11, v12);
            if ( !v6 )
            {
              v3 = (unsigned __int8)v3;
              v6 = SendByte(v3, v14, v15);
              if ( !v6 )
              {
                v6 = SendByte(g_bCounter[0], v16, v17);
                if ( !v6 )
                {
                  v19 = 8;
                  v20 = v13 ^ v3 ^ (unsigned __int8)g_bCounter[0] ^ 8;
                  for ( i = 0; i < v24; ++i )
                  {
                    v22 = *(_BYTE *)(v25 + i);
                    v6 = SendByte(*(_BYTE *)(v25 + i), v18, v19);
                    if ( v6 )
                      goto LABEL_15;
                    LOBYTE(v20) = v20 ^ v22;
                  }
                  v6 = SendByte(v20, v18, v19);
                }
              }
            }
          }
        }
      }
    }
  }
LABEL_15:
  ioctl(dword_2700C, 0x540Bu, 0);
  ErrorCode(v6);
  return v6;
}
// 2700C: using guessed type int dword_2700C;

//----- (0000BA54) --------------------------------------------------------
int __fastcall SendData(int a1, int a2, int a3)
{
  int v3; // [email protected]
  int v4; // [email protected]
  int v5; // [email protected]
  int v6; // [email protected]
  int v7; // [email protected]
  int v8; // [email protected]
  int v9; // [email protected]
  int v10; // [email protected]
  int v11; // [email protected]
  int v12; // [email protected]
  int v13; // [email protected]
  int v14; // [email protected]
  int v15; // [email protected]
  int v16; // [email protected]
  int v17; // [email protected]
  int v18; // [email protected]
  int v19; // [email protected]
  int v20; // [email protected]
  int v21; // [email protected]
  int v22; // [email protected]
  int v23; // [email protected]
  int v24; // [email protected]
  int v25; // [email protected]
  int i; // [email protected]
  char v27; // [email protected]
  int v29; // [sp+0h] [bp-20h]@1
  int v30; // [sp+4h] [bp-1Ch]@1

  v3 = a2 + 3;
  v30 = a1;
  v29 = a2;
  if ( a2 + 3 > 0xFFFF )
  {
    v6 = -10;
  }
  else
  {
    v6 = SendByte(85, a2, a3);
    if ( !v6 )
    {
      v6 = SendByte(-86, v4, v5);
      if ( !v6 )
      {
        v6 = SendByte(-16, v7, v8);
        if ( !v6 )
        {
          v6 = SendByte(-8, v9, v10);
          if ( !v6 )
          {
            v13 = (v3 >> 8) & 0xFF;
            v6 = SendByte(SBYTE1(v3), v11, v12);
            if ( !v6 )
            {
              v3 = (unsigned __int8)v3;
              v6 = SendByte(v3, v14, v15);
              if ( !v6 )
              {
                v6 = SendByte(g_bCounter[0], v16, v17);
                if ( !v6 )
                {
                  v20 = (unsigned __int8)g_bCounter[0];
                  v6 = SendByte(39, v18, v19);
                  if ( !v6 )
                  {
                    v6 = SendByte(1, v21, v22);
                    if ( !v6 )
                    {
                      v25 = v20 ^ 0x2E ^ v3 ^ v13;
                      for ( i = 0; i < v29; ++i )
                      {
                        v27 = *(_BYTE *)(v30 + i);
                        v6 = SendByte(*(_BYTE *)(v30 + i), v23, v24);
                        if ( v6 )
                          goto LABEL_17;
                        LOBYTE(v25) = v25 ^ v27;
                      }
                      v6 = SendByte(v25, v23, v24);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
LABEL_17:
  ioctl(dword_2700C, 0x540Bu, 0);
  ErrorCode(v6);
  return v6;
}
// 2700C: using guessed type int dword_2700C;

//----- (0000BB2C) --------------------------------------------------------
int __fastcall ClearBuffer(int a1)
{
  int v1; // [email protected]
  int result; // [email protected]

  v1 = a1;
  result = dword_2700C;
  if ( dword_2700C >= 0 )
    result = ioctl(dword_2700C, 0x540Bu, v1);
  return result;
}
// 2700C: using guessed type int dword_2700C;

//----- (0000BB4C) --------------------------------------------------------
int __fastcall ReadData(void *buf, size_t nbytes)
{
  void *v2; // [email protected]
  size_t v3; // [email protected]

  v2 = buf;
  v3 = nbytes;
  if ( dword_2700C == -1 )
    OpenPort();
  return read(dword_2700C, v2, v3);
}
// 2700C: using guessed type int dword_2700C;

//----- (0000BB78) --------------------------------------------------------
int __fastcall SetLanguage(int result)
{
  dword_27010 = result;
  return result;
}
// 27010: using guessed type int dword_27010;

//----- (0000BB84) --------------------------------------------------------
int GetLanguage()
{
  return dword_27010;
}
// 27010: using guessed type int dword_27010;

//----- (0000BB90) --------------------------------------------------------
unsigned __int64 __fastcall SetDateString(unsigned __int64 a1, int a2, int a3)
{
  unsigned __int64 v3; // [email protected]
  int v4; // [email protected]
  int v5; // [email protected]
  const char *v6; // [email protected]
  char *v7; // [email protected]
  int v8; // [email protected]
  unsigned __int64 v9; // [email protected]
  int v10; // [email protected]
  unsigned __int64 v12; // [sp+0h] [bp-20h]@1
  int v13; // [sp+0h] [bp-20h]@15

  v12 = a1;
  v3 = a1;
  v4 = a2;
  v5 = a3;
  if ( (_DWORD)a1 )
  {
    switch ( GetLanguage() )
    {
      case 1:
      case 14:
        v6 = "%d.%d.%d";
        goto LABEL_17;
      case 4:
        v6 = "%d/%d/%d";
        goto LABEL_17;
      case 2:
        v6 = "%d/%02d/%02d";
        goto LABEL_17;
      case 3:
        v6 = "%02d.%02d.%d";
        goto LABEL_15;
      case 5:
        v6 = "%02d/%02d/%d";
        goto LABEL_15;
      case 8:
        v6 = "%02d/%02d/%d";
        goto LABEL_15;
      case 7:
        v6 = "%02d.%02d.%d";
        goto LABEL_15;
      case 9:
        v6 = "%02d/%02d/%d";
        goto LABEL_15;
      case 6:
        v6 = "%02d-%02d-%d";
        goto LABEL_15;
      case 10:
        v6 = "%d-%d-%d";
        goto LABEL_17;
      case 11:
        v6 = "%02d.%02d.%d";
        goto LABEL_15;
      case 12:
        v6 = "%d-%d-%d";
LABEL_15:
        v13 = HIDWORD(v3);
        v7 = (char *)v3;
        v8 = v5;
        goto LABEL_18;
      case 19:
        v6 = "%d/%d/%d";
LABEL_17:
        v13 = v5;
 
Comments: