Untitled

typedef unsigned char   undefined;

typedef unsigned long long    GUID;
typedef pointer32 ImageBaseOffset32;

typedef unsigned char    bool;
typedef unsigned char    byte;
typedef unsigned int    dword;
typedef long long    longlong;
typedef unsigned char    uchar;
typedef unsigned int    uint;
typedef unsigned long    ulong;
typedef unsigned long long    ulonglong;
typedef unsigned char    undefined1;
typedef unsigned short    undefined2;
typedef unsigned int    undefined4;
typedef unsigned long long    undefined8;
typedef unsigned short    ushort;
typedef unsigned short    wchar16;
typedef short    wchar_t;
typedef unsigned short    word;
typedef struct _s_HandlerType _s_HandlerType, *P_s_HandlerType;

typedef struct _s_HandlerType HandlerType;

typedef struct TypeDescriptor TypeDescriptor, *PTypeDescriptor;

typedef int ptrdiff_t;

struct TypeDescriptor {
    void * pVFTable;
    void * spare;
    char name[0];
};

struct _s_HandlerType {
    uint adjectives;
    struct TypeDescriptor * pType;
    ptrdiff_t dispCatchObj;
    void * addressOfHandler;
};

typedef struct _com_error _com_error, *P_com_error;

struct _com_error { // PlaceHolder Class Structure
};

typedef struct _s__RTTIBaseClassDescriptor _s__RTTIBaseClassDescriptor, *P_s__RTTIBaseClassDescriptor;

typedef struct _s__RTTIBaseClassDescriptor RTTIBaseClassDescriptor;

typedef struct PMD PMD, *PPMD;

typedef struct _s__RTTIClassHierarchyDescriptor _s__RTTIClassHierarchyDescriptor, *P_s__RTTIClassHierarchyDescriptor;

typedef struct _s__RTTIClassHierarchyDescriptor RTTIClassHierarchyDescriptor;

struct PMD {
    ptrdiff_t mdisp;
    ptrdiff_t pdisp;
    ptrdiff_t vdisp;
};

struct _s__RTTIBaseClassDescriptor {
    struct TypeDescriptor * pTypeDescriptor; // ref to TypeDescriptor (RTTI 0) for class
    dword numContainedBases; // count of extended classes in BaseClassArray (RTTI 2)
    struct PMD where; // member displacement structure
    dword attributes; // bit flags
    RTTIClassHierarchyDescriptor * pClassHierarchyDescriptor; // ref to ClassHierarchyDescriptor (RTTI 3) for class
};

struct _s__RTTIClassHierarchyDescriptor {
    dword signature;
    dword attributes; // bit flags
    dword numBaseClasses; // number of base classes (i.e. rtti1Count)
    RTTIBaseClassDescriptor * * pBaseClassArray; // ref to BaseClassArray (RTTI 2)
};

typedef struct _s_UnwindMapEntry _s_UnwindMapEntry, *P_s_UnwindMapEntry;

typedef struct _s_UnwindMapEntry UnwindMapEntry;

typedef int __ehstate_t;

struct _s_UnwindMapEntry {
    __ehstate_t toState;
    void (* action)(void);
};

typedef union IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryUnion IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryUnion, *PIMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryUnion;

typedef struct IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryStruct IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryStruct, *PIMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryStruct;

struct IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryStruct {
    dword OffsetToDirectory;
    dword DataIsDirectory;
};

union IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryUnion {
    dword OffsetToData;
    struct IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryStruct IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryStruct;
};

typedef struct _s_TryBlockMapEntry _s_TryBlockMapEntry, *P_s_TryBlockMapEntry;

struct _s_TryBlockMapEntry {
    __ehstate_t tryLow;
    __ehstate_t tryHigh;
    __ehstate_t catchHigh;
    int nCatches;
    HandlerType * pHandlerArray;
};

typedef struct _s_TryBlockMapEntry TryBlockMapEntry;

typedef struct _s__RTTICompleteObjectLocator _s__RTTICompleteObjectLocator, *P_s__RTTICompleteObjectLocator;

struct _s__RTTICompleteObjectLocator {
    dword signature;
    dword offset; // offset of vbtable within class
    dword cdOffset; // constructor displacement offset
    struct TypeDescriptor * pTypeDescriptor; // ref to TypeDescriptor (RTTI 0) for class
    RTTIClassHierarchyDescriptor * pClassDescriptor; // ref to ClassHierarchyDescriptor (RTTI 3)
};

typedef struct _s_ESTypeList _s_ESTypeList, *P_s_ESTypeList;

struct _s_ESTypeList {
    int nCount;
    HandlerType * pTypeArray;
};

typedef struct _s_ESTypeList ESTypeList;

typedef struct CLIENT_ID CLIENT_ID, *PCLIENT_ID;

struct CLIENT_ID {
    void * UniqueProcess;
    void * UniqueThread;
};

typedef struct _s_FuncInfo _s_FuncInfo, *P_s_FuncInfo;

typedef struct _s_FuncInfo FuncInfo;

struct _s_FuncInfo {
    uint magicNumber_and_bbtFlags;
    __ehstate_t maxState;
    UnwindMapEntry * pUnwindMap;
    uint nTryBlocks;
    TryBlockMapEntry * pTryBlockMap;
    uint nIPMapEntries;
    void * pIPToStateMap;
    ESTypeList * pESTypeList;
    int EHFlags;
};

typedef struct _s__RTTICompleteObjectLocator RTTICompleteObjectLocator;

typedef struct tagINPUT tagINPUT, *PtagINPUT;

typedef struct tagINPUT * LPINPUT;

typedef ulong DWORD;

typedef union _union_859 _union_859, *P_union_859;

typedef struct tagMOUSEINPUT tagMOUSEINPUT, *PtagMOUSEINPUT;

typedef struct tagMOUSEINPUT MOUSEINPUT;

typedef struct tagKEYBDINPUT tagKEYBDINPUT, *PtagKEYBDINPUT;

typedef struct tagKEYBDINPUT KEYBDINPUT;

typedef struct tagHARDWAREINPUT tagHARDWAREINPUT, *PtagHARDWAREINPUT;

typedef struct tagHARDWAREINPUT HARDWAREINPUT;

typedef long LONG;

typedef ulong ULONG_PTR;

typedef ushort WORD;

struct tagMOUSEINPUT {
    LONG dx;
    LONG dy;
    DWORD mouseData;
    DWORD dwFlags;
    DWORD time;
    ULONG_PTR dwExtraInfo;
};

struct tagKEYBDINPUT {
    WORD wVk;
    WORD wScan;
    DWORD dwFlags;
    DWORD time;
    ULONG_PTR dwExtraInfo;
};

struct tagHARDWAREINPUT {
    DWORD uMsg;
    WORD wParamL;
    WORD wParamH;
};

union _union_859 {
    MOUSEINPUT mi;
    KEYBDINPUT ki;
    HARDWAREINPUT hi;
};

struct tagINPUT {
    DWORD type;
    union _union_859 field1_0x4;
};

typedef int BOOL;

typedef struct HWND__ HWND__, *PHWND__;

typedef struct HWND__ * HWND;

typedef long LONG_PTR;

typedef LONG_PTR LPARAM;

typedef BOOL (* WNDENUMPROC)(HWND, LPARAM);

struct HWND__ {
    int unused;
};

typedef struct HMONITOR__ HMONITOR__, *PHMONITOR__;

typedef struct HMONITOR__ * HMONITOR;

typedef struct HDC__ HDC__, *PHDC__;

typedef struct HDC__ * HDC;

typedef struct tagRECT tagRECT, *PtagRECT;

typedef struct tagRECT * LPRECT;

typedef BOOL (* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);

struct HDC__ {
    int unused;
};

struct HMONITOR__ {
    int unused;
};

struct tagRECT {
    LONG left;
    LONG top;
    LONG right;
    LONG bottom;
};

typedef struct exception exception, *Pexception;

struct exception { // PlaceHolder Class Structure
};

typedef struct basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_> basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>, *Pbasic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>;

struct basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_> { // PlaceHolder Class Structure
};


// WARNING! conflicting data type names: /guiddef.h/GUID - /GUID

typedef GUID IID;

typedef struct _GUID _GUID, *P_GUID;

struct _GUID {
    ulong Data1;
    ushort Data2;
    ushort Data3;
    uchar Data4[8];
};

typedef void * PVOID;

typedef PVOID BCRYPT_KEY_HANDLE;

typedef PVOID BCRYPT_HANDLE;

typedef PVOID BCRYPT_ALG_HANDLE;

typedef LONG NTSTATUS;

typedef enum _SC_ENUM_TYPE {
    SC_ENUM_PROCESS_INFO=0
} _SC_ENUM_TYPE;

typedef enum _SC_ENUM_TYPE SC_ENUM_TYPE;

typedef struct SC_HANDLE__ SC_HANDLE__, *PSC_HANDLE__;

typedef struct SC_HANDLE__ * SC_HANDLE;

struct SC_HANDLE__ {
    int unused;
};

typedef void * RPC_AUTH_IDENTITY_HANDLE;

typedef struct _EXCEPTION_POINTERS _EXCEPTION_POINTERS, *P_EXCEPTION_POINTERS;

typedef LONG (* PTOP_LEVEL_EXCEPTION_FILTER)(struct _EXCEPTION_POINTERS *);

typedef struct _EXCEPTION_RECORD _EXCEPTION_RECORD, *P_EXCEPTION_RECORD;

typedef struct _EXCEPTION_RECORD EXCEPTION_RECORD;

typedef EXCEPTION_RECORD * PEXCEPTION_RECORD;

typedef struct _CONTEXT _CONTEXT, *P_CONTEXT;

typedef struct _CONTEXT CONTEXT;

typedef CONTEXT * PCONTEXT;

typedef struct _FLOATING_SAVE_AREA _FLOATING_SAVE_AREA, *P_FLOATING_SAVE_AREA;

typedef struct _FLOATING_SAVE_AREA FLOATING_SAVE_AREA;

typedef uchar BYTE;

struct _FLOATING_SAVE_AREA {
    DWORD ControlWord;
    DWORD StatusWord;
    DWORD TagWord;
    DWORD ErrorOffset;
    DWORD ErrorSelector;
    DWORD DataOffset;
    DWORD DataSelector;
    BYTE RegisterArea[80];
    DWORD Cr0NpxState;
};

struct _CONTEXT {
    DWORD ContextFlags;
    DWORD Dr0;
    DWORD Dr1;
    DWORD Dr2;
    DWORD Dr3;
    DWORD Dr6;
    DWORD Dr7;
    FLOATING_SAVE_AREA FloatSave;
    DWORD SegGs;
    DWORD SegFs;
    DWORD SegEs;
    DWORD SegDs;
    DWORD Edi;
    DWORD Esi;
    DWORD Ebx;
    DWORD Edx;
    DWORD Ecx;
    DWORD Eax;
    DWORD Ebp;
    DWORD Eip;
    DWORD SegCs;
    DWORD EFlags;
    DWORD Esp;
    DWORD SegSs;
    BYTE ExtendedRegisters[512];
};

struct _EXCEPTION_RECORD {
    DWORD ExceptionCode;
    DWORD ExceptionFlags;
    struct _EXCEPTION_RECORD * ExceptionRecord;
    PVOID ExceptionAddress;
    DWORD NumberParameters;
    ULONG_PTR ExceptionInformation[15];
};

struct _EXCEPTION_POINTERS {
    PEXCEPTION_RECORD ExceptionRecord;
    PCONTEXT ContextRecord;
};

typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;

typedef union _SLIST_HEADER _SLIST_HEADER, *P_SLIST_HEADER;

typedef union _SLIST_HEADER * PSLIST_HEADER;

typedef double ULONGLONG;

typedef struct _struct_299 _struct_299, *P_struct_299;

typedef struct _SINGLE_LIST_ENTRY _SINGLE_LIST_ENTRY, *P_SINGLE_LIST_ENTRY;

typedef struct _SINGLE_LIST_ENTRY SINGLE_LIST_ENTRY;

struct _SINGLE_LIST_ENTRY {
    struct _SINGLE_LIST_ENTRY * Next;
};

struct _struct_299 {
    SINGLE_LIST_ENTRY Next;
    WORD Depth;
    WORD Sequence;
};

union _SLIST_HEADER {
    ULONGLONG Alignment;
    struct _struct_299 s;
};

typedef wchar_t WCHAR;

typedef long HRESULT;

typedef struct _OSVERSIONINFOEXW _OSVERSIONINFOEXW, *P_OSVERSIONINFOEXW;

struct _OSVERSIONINFOEXW {
    DWORD dwOSVersionInfoSize;
    DWORD dwMajorVersion;
    DWORD dwMinorVersion;
    DWORD dwBuildNumber;
    DWORD dwPlatformId;
    WCHAR szCSDVersion[128];
    WORD wServicePackMajor;
    WORD wServicePackMinor;
    WORD wSuiteMask;
    BYTE wProductType;
    BYTE wReserved;
};

typedef char CHAR;

typedef CHAR * LPCSTR;

typedef ULONGLONG DWORDLONG;

typedef union _LARGE_INTEGER _LARGE_INTEGER, *P_LARGE_INTEGER;

typedef struct _struct_19 _struct_19, *P_struct_19;

typedef struct _struct_20 _struct_20, *P_struct_20;

typedef double LONGLONG;

struct _struct_20 {
    DWORD LowPart;
    LONG HighPart;
};

struct _struct_19 {
    DWORD LowPart;
    LONG HighPart;
};

union _LARGE_INTEGER {
    struct _struct_19 s;
    struct _struct_20 u;
    LONGLONG QuadPart;
};

typedef union _LARGE_INTEGER LARGE_INTEGER;

typedef struct _OSVERSIONINFOEXW * LPOSVERSIONINFOEXW;

typedef CHAR * LPSTR;

typedef WCHAR * LPWSTR;

typedef WORD LANGID;

typedef short SHORT;

typedef WCHAR * LPCWSTR;

typedef DWORD LCID;

typedef void * HANDLE;

typedef struct IMAGE_DOS_HEADER IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;

struct IMAGE_DOS_HEADER {
    char e_magic[2]; // Magic number
    word e_cblp; // Bytes of last page
    word e_cp; // Pages in file
    word e_crlc; // Relocations
    word e_cparhdr; // Size of header in paragraphs
    word e_minalloc; // Minimum extra paragraphs needed
    word e_maxalloc; // Maximum extra paragraphs needed
    word e_ss; // Initial (relative) SS value
    word e_sp; // Initial SP value
    word e_csum; // Checksum
    word e_ip; // Initial IP value
    word e_cs; // Initial (relative) CS value
    word e_lfarlc; // File address of relocation table
    word e_ovno; // Overlay number
    word e_res[4][4]; // Reserved words
    word e_oemid; // OEM identifier (for e_oeminfo)
    word e_oeminfo; // OEM information; e_oemid specific
    word e_res2[10][10]; // Reserved words
    dword e_lfanew; // File address of new exe header
    byte e_program[64]; // Actual DOS program
};

typedef struct _CRYPTOAPI_BLOB _CRYPTOAPI_BLOB, *P_CRYPTOAPI_BLOB;

typedef struct _CRYPTOAPI_BLOB CRYPT_INTEGER_BLOB;

struct _CRYPTOAPI_BLOB {
    DWORD cbData;
    BYTE * pbData;
};

typedef struct _CRYPTOAPI_BLOB CRYPT_OBJID_BLOB;

typedef void * HCERTSTORE;

typedef struct _CERT_PUBLIC_KEY_INFO _CERT_PUBLIC_KEY_INFO, *P_CERT_PUBLIC_KEY_INFO;

typedef struct _CRYPT_ALGORITHM_IDENTIFIER _CRYPT_ALGORITHM_IDENTIFIER, *P_CRYPT_ALGORITHM_IDENTIFIER;

typedef struct _CRYPT_ALGORITHM_IDENTIFIER CRYPT_ALGORITHM_IDENTIFIER;

typedef struct _CRYPT_BIT_BLOB _CRYPT_BIT_BLOB, *P_CRYPT_BIT_BLOB;

typedef struct _CRYPT_BIT_BLOB CRYPT_BIT_BLOB;

struct _CRYPT_BIT_BLOB {
    DWORD cbData;
    BYTE * pbData;
    DWORD cUnusedBits;
};

struct _CRYPT_ALGORITHM_IDENTIFIER {
    LPSTR pszObjId;
    CRYPT_OBJID_BLOB Parameters;
};

struct _CERT_PUBLIC_KEY_INFO {
    CRYPT_ALGORITHM_IDENTIFIER Algorithm;
    CRYPT_BIT_BLOB PublicKey;
};

typedef struct _CERT_PUBLIC_KEY_INFO * PCERT_PUBLIC_KEY_INFO;

typedef ULONG_PTR HCRYPTPROV;

typedef struct _CERT_PUBLIC_KEY_INFO CERT_PUBLIC_KEY_INFO;

typedef struct _CERT_INFO _CERT_INFO, *P_CERT_INFO;

typedef struct _CERT_INFO * PCERT_INFO;

typedef struct _CRYPTOAPI_BLOB CERT_NAME_BLOB;

typedef struct _FILETIME _FILETIME, *P_FILETIME;

typedef struct _FILETIME FILETIME;

typedef struct _CERT_EXTENSION _CERT_EXTENSION, *P_CERT_EXTENSION;

typedef struct _CERT_EXTENSION * PCERT_EXTENSION;

struct _CERT_EXTENSION {
    LPSTR pszObjId;
    BOOL fCritical;
    CRYPT_OBJID_BLOB Value;
};

struct _FILETIME {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
};

struct _CERT_INFO {
    DWORD dwVersion;
    CRYPT_INTEGER_BLOB SerialNumber;
    CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
    CERT_NAME_BLOB Issuer;
    FILETIME NotBefore;
    FILETIME NotAfter;
    CERT_NAME_BLOB Subject;
    CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
    CRYPT_BIT_BLOB IssuerUniqueId;
    CRYPT_BIT_BLOB SubjectUniqueId;
    DWORD cExtension;
    PCERT_EXTENSION rgExtension;
};

typedef struct _CERT_CONTEXT _CERT_CONTEXT, *P_CERT_CONTEXT;

typedef struct _CERT_CONTEXT CERT_CONTEXT;

struct _CERT_CONTEXT {
    DWORD dwCertEncodingType;
    BYTE * pbCertEncoded;
    DWORD cbCertEncoded;
    PCERT_INFO pCertInfo;
    HCERTSTORE hCertStore;
};

typedef CERT_CONTEXT * PCCERT_CONTEXT;

typedef struct _CRYPTOAPI_BLOB * PCERT_NAME_BLOB;

typedef ULONG_PTR HCRYPTPROV_LEGACY;

typedef struct tagFUNCDESC tagFUNCDESC, *PtagFUNCDESC;

typedef LONG DISPID;

typedef DISPID MEMBERID;

typedef LONG SCODE;

typedef struct tagELEMDESC tagELEMDESC, *PtagELEMDESC;

typedef struct tagELEMDESC ELEMDESC;

typedef enum tagFUNCKIND {
    FUNC_VIRTUAL=0,
    FUNC_PUREVIRTUAL=1,
    FUNC_NONVIRTUAL=2,
    FUNC_STATIC=3,
    FUNC_DISPATCH=4
} tagFUNCKIND;

typedef enum tagFUNCKIND FUNCKIND;

typedef enum tagINVOKEKIND {
    INVOKE_FUNC=1,
    INVOKE_PROPERTYGET=2,
    INVOKE_PROPERTYPUT=4,
    INVOKE_PROPERTYPUTREF=8
} tagINVOKEKIND;

typedef enum tagINVOKEKIND INVOKEKIND;

typedef enum tagCALLCONV {
    CC_FASTCALL=0,
    CC_CDECL=1,
    CC_MSCPASCAL=2,
    CC_PASCAL=3,
    CC_MACPASCAL=4,
    CC_STDCALL=5,
    CC_FPFASTCALL=6,
    CC_SYSCALL=7,
    CC_MPWCDECL=8,
    CC_MPWPASCAL=9,
    CC_MAX=10
} tagCALLCONV;

typedef enum tagCALLCONV CALLCONV;

typedef struct tagTYPEDESC tagTYPEDESC, *PtagTYPEDESC;

typedef struct tagTYPEDESC TYPEDESC;

typedef union _union_2702 _union_2702, *P_union_2702;

typedef union _union_2691 _union_2691, *P_union_2691;

typedef ushort VARTYPE;

typedef struct tagIDLDESC tagIDLDESC, *PtagIDLDESC;

typedef struct tagIDLDESC IDLDESC;

typedef struct tagPARAMDESC tagPARAMDESC, *PtagPARAMDESC;

typedef struct tagPARAMDESC PARAMDESC;

typedef struct tagARRAYDESC tagARRAYDESC, *PtagARRAYDESC;

typedef DWORD HREFTYPE;

typedef ushort USHORT;

typedef struct tagPARAMDESCEX tagPARAMDESCEX, *PtagPARAMDESCEX;

typedef struct tagPARAMDESCEX * LPPARAMDESCEX;

typedef struct tagSAFEARRAYBOUND tagSAFEARRAYBOUND, *PtagSAFEARRAYBOUND;

typedef struct tagSAFEARRAYBOUND SAFEARRAYBOUND;

typedef DWORD ULONG;

typedef struct tagVARIANT tagVARIANT, *PtagVARIANT;

typedef struct tagVARIANT VARIANT;

typedef VARIANT VARIANTARG;

typedef union _union_2683 _union_2683, *P_union_2683;

typedef struct __tagVARIANT __tagVARIANT, *P__tagVARIANT;

typedef struct tagDEC tagDEC, *PtagDEC;

typedef struct tagDEC DECIMAL;

typedef union _union_2685 _union_2685, *P_union_2685;

typedef union _union_1695 _union_1695, *P_union_1695;

typedef union _union_1697 _union_1697, *P_union_1697;

typedef float FLOAT;

typedef double DOUBLE;

typedef short VARIANT_BOOL;

typedef union tagCY tagCY, *PtagCY;

typedef union tagCY CY;

typedef double DATE;

typedef WCHAR OLECHAR;

typedef OLECHAR * BSTR;

typedef struct IUnknown IUnknown, *PIUnknown;

typedef struct IDispatch IDispatch, *PIDispatch;

typedef struct tagSAFEARRAY tagSAFEARRAY, *PtagSAFEARRAY;

typedef struct tagSAFEARRAY SAFEARRAY;

typedef int INT;

typedef uint UINT;

typedef struct __tagBRECORD __tagBRECORD, *P__tagBRECORD;

typedef struct _struct_1696 _struct_1696, *P_struct_1696;

typedef struct _struct_1698 _struct_1698, *P_struct_1698;

typedef struct _struct_1693 _struct_1693, *P_struct_1693;

typedef struct IUnknownVtbl IUnknownVtbl, *PIUnknownVtbl;

typedef struct IDispatchVtbl IDispatchVtbl, *PIDispatchVtbl;

typedef struct ITypeInfo ITypeInfo, *PITypeInfo;

typedef OLECHAR * LPOLESTR;

typedef struct tagDISPPARAMS tagDISPPARAMS, *PtagDISPPARAMS;

typedef struct tagDISPPARAMS DISPPARAMS;

typedef struct tagEXCEPINFO tagEXCEPINFO, *PtagEXCEPINFO;

typedef struct tagEXCEPINFO EXCEPINFO;

typedef struct IRecordInfo IRecordInfo, *PIRecordInfo;

typedef struct ITypeInfoVtbl ITypeInfoVtbl, *PITypeInfoVtbl;

typedef struct tagTYPEATTR tagTYPEATTR, *PtagTYPEATTR;

typedef struct tagTYPEATTR TYPEATTR;

typedef struct ITypeComp ITypeComp, *PITypeComp;

typedef struct tagFUNCDESC FUNCDESC;

typedef struct tagVARDESC tagVARDESC, *PtagVARDESC;

typedef struct tagVARDESC VARDESC;

typedef struct ITypeLib ITypeLib, *PITypeLib;

typedef struct IRecordInfoVtbl IRecordInfoVtbl, *PIRecordInfoVtbl;

typedef OLECHAR * LPCOLESTR;

typedef enum tagTYPEKIND {
    TKIND_ENUM=0,
    TKIND_RECORD=1,
    TKIND_MODULE=2,
    TKIND_INTERFACE=3,
    TKIND_DISPATCH=4,
    TKIND_COCLASS=5,
    TKIND_ALIAS=6,
    TKIND_UNION=7,
    TKIND_MAX=8
} tagTYPEKIND;

typedef enum tagTYPEKIND TYPEKIND;

typedef struct ITypeCompVtbl ITypeCompVtbl, *PITypeCompVtbl;

typedef enum tagDESCKIND {
    DESCKIND_NONE=0,
    DESCKIND_FUNCDESC=1,
    DESCKIND_VARDESC=2,
    DESCKIND_TYPECOMP=3,
    DESCKIND_IMPLICITAPPOBJ=4,
    DESCKIND_MAX=5
} tagDESCKIND;

typedef enum tagDESCKIND DESCKIND;

typedef union tagBINDPTR tagBINDPTR, *PtagBINDPTR;

typedef union tagBINDPTR BINDPTR;

typedef union _union_2711 _union_2711, *P_union_2711;

typedef enum tagVARKIND {
    VAR_PERINSTANCE=0,
    VAR_STATIC=1,
    VAR_CONST=2,
    VAR_DISPATCH=3
} tagVARKIND;

typedef enum tagVARKIND VARKIND;

typedef struct ITypeLibVtbl ITypeLibVtbl, *PITypeLibVtbl;

typedef struct tagTLIBATTR tagTLIBATTR, *PtagTLIBATTR;

typedef struct tagTLIBATTR TLIBATTR;

typedef enum tagSYSKIND {
    SYS_WIN16=0,
    SYS_WIN32=1,
    SYS_MAC=2,
    SYS_WIN64=3
} tagSYSKIND;

typedef enum tagSYSKIND SYSKIND;

struct _struct_1693 {
    ulong Lo;
    long Hi;
};

union tagCY {
    struct _struct_1693 s;
    LONGLONG int64;
};

struct _struct_1698 {
    ULONG Lo32;
    ULONG Mid32;
};

union _union_1697 {
    struct _struct_1698 s2;
    ULONGLONG Lo64;
};

struct _struct_1696 {
    BYTE scale;
    BYTE sign;
};

union _union_1695 {
    struct _struct_1696 s;
    USHORT signscale;
};

struct tagDEC {
    USHORT wReserved;
    union _union_1695 u;
    ULONG Hi32;
    union _union_1697 u2;
};

struct __tagBRECORD {
    PVOID pvRecord;
    struct IRecordInfo * pRecInfo;
};

union _union_2685 {
    LONGLONG llVal;
    LONG lVal;
    BYTE bVal;
    SHORT iVal;
    FLOAT fltVal;
    DOUBLE dblVal;
    VARIANT_BOOL boolVal;
    SCODE scode;
    CY cyVal;
    DATE date;
    BSTR bstrVal;
    struct IUnknown * punkVal;
    struct IDispatch * pdispVal;
    SAFEARRAY * parray;
    BYTE * pbVal;
    SHORT * piVal;
    LONG * plVal;
    LONGLONG * pllVal;
    FLOAT * pfltVal;
    DOUBLE * pdblVal;
    VARIANT_BOOL * pboolVal;
    SCODE * pscode;
    CY * pcyVal;
    DATE * pdate;
    BSTR * pbstrVal;
    struct IUnknown * * ppunkVal;
    struct IDispatch * * ppdispVal;
    SAFEARRAY * * pparray;
    VARIANT * pvarVal;
    PVOID byref;
    CHAR cVal;
    USHORT uiVal;
    ULONG ulVal;
    ULONGLONG ullVal;
    INT intVal;
    UINT uintVal;
    DECIMAL * pdecVal;
    CHAR * pcVal;
    USHORT * puiVal;
    ULONG * pulVal;
    ULONGLONG * pullVal;
    INT * pintVal;
    UINT * puintVal;
    struct __tagBRECORD brecVal;
};

struct __tagVARIANT {
    VARTYPE vt;
    WORD wReserved1;
    WORD wReserved2;
    WORD wReserved3;
    union _union_2685 n3;
};

union _union_2683 {
    struct __tagVARIANT n2;
    DECIMAL decVal;
};

union _union_2691 {
    struct tagTYPEDESC * lptdesc;
    struct tagARRAYDESC * lpadesc;
    HREFTYPE hreftype;
};

struct tagTYPEDESC {
    union _union_2691 u;
    VARTYPE vt;
};

struct tagIDLDESC {
    ULONG_PTR dwReserved;
    USHORT wIDLFlags;
};

struct tagPARAMDESC {
    LPPARAMDESCEX pparamdescex;
    USHORT wParamFlags;
};

union _union_2702 {
    IDLDESC idldesc;
    PARAMDESC paramdesc;
};

struct tagELEMDESC {
    TYPEDESC tdesc;
    union _union_2702 u;
};

struct tagFUNCDESC {
    MEMBERID memid;
    SCODE * lprgscode;
    ELEMDESC * lprgelemdescParam;
    FUNCKIND funckind;
    INVOKEKIND invkind;
    CALLCONV callconv;
    SHORT cParams;
    SHORT cParamsOpt;
    SHORT oVft;
    SHORT cScodes;
    ELEMDESC elemdescFunc;
    WORD wFuncFlags;
};

struct tagVARIANT {
    union _union_2683 n1;
};

struct tagPARAMDESCEX {
    ULONG cBytes;
    VARIANTARG varDefaultValue;
};

union _union_2711 {
    ULONG oInst;
    VARIANT * lpvarValue;
};

struct tagVARDESC {
    MEMBERID memid;
    LPOLESTR lpstrSchema;
    union _union_2711 u;
    ELEMDESC elemdescVar;
    WORD wVarFlags;
    VARKIND varkind;
};

struct ITypeCompVtbl {
    HRESULT (* QueryInterface)(struct ITypeComp *, IID *, void * *);
    ULONG (* AddRef)(struct ITypeComp *);
    ULONG (* Release)(struct ITypeComp *);
    HRESULT (* Bind)(struct ITypeComp *, LPOLESTR, ULONG, WORD, struct ITypeInfo * *, DESCKIND *, BINDPTR *);
    HRESULT (* BindType)(struct ITypeComp *, LPOLESTR, ULONG, struct ITypeInfo * *, struct ITypeComp * *);
};

struct tagSAFEARRAYBOUND {
    ULONG cElements;
    LONG lLbound;
};

struct tagSAFEARRAY {
    USHORT cDims;
    USHORT fFeatures;
    ULONG cbElements;
    ULONG cLocks;
    PVOID pvData;
    SAFEARRAYBOUND rgsabound[1];
};

struct ITypeInfoVtbl {
    HRESULT (* QueryInterface)(struct ITypeInfo *, IID *, void * *);
    ULONG (* AddRef)(struct ITypeInfo *);
    ULONG (* Release)(struct ITypeInfo *);
    HRESULT (* GetTypeAttr)(struct ITypeInfo *, TYPEATTR * *);
    HRESULT (* GetTypeComp)(struct ITypeInfo *, struct ITypeComp * *);
    HRESULT (* GetFuncDesc)(struct ITypeInfo *, UINT, FUNCDESC * *);
    HRESULT (* GetVarDesc)(struct ITypeInfo *, UINT, VARDESC * *);
    HRESULT (* GetNames)(struct ITypeInfo *, MEMBERID, BSTR *, UINT, UINT *);
    HRESULT (* GetRefTypeOfImplType)(struct ITypeInfo *, UINT, HREFTYPE *);
    HRESULT (* GetImplTypeFlags)(struct ITypeInfo *, UINT, INT *);
    HRESULT (* GetIDsOfNames)(struct ITypeInfo *, LPOLESTR *, UINT, MEMBERID *);
    HRESULT (* Invoke)(struct ITypeInfo *, PVOID, MEMBERID, WORD, DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *);
    HRESULT (* GetDocumentation)(struct ITypeInfo *, MEMBERID, BSTR *, BSTR *, DWORD *, BSTR *);
    HRESULT (* GetDllEntry)(struct ITypeInfo *, MEMBERID, INVOKEKIND, BSTR *, BSTR *, WORD *);
    HRESULT (* GetRefTypeInfo)(struct ITypeInfo *, HREFTYPE, struct ITypeInfo * *);
    HRESULT (* AddressOfMember)(struct ITypeInfo *, MEMBERID, INVOKEKIND, PVOID *);
    HRESULT (* CreateInstance)(struct ITypeInfo *, struct IUnknown *, IID *, PVOID *);
    HRESULT (* GetMops)(struct ITypeInfo *, MEMBERID, BSTR *);
    HRESULT (* GetContainingTypeLib)(struct ITypeInfo *, struct ITypeLib * *, UINT *);
    void (* ReleaseTypeAttr)(struct ITypeInfo *, TYPEATTR *);
    void (* ReleaseFuncDesc)(struct ITypeInfo *, FUNCDESC *);
    void (* ReleaseVarDesc)(struct ITypeInfo *, VARDESC *);
};

struct ITypeLibVtbl {
    HRESULT (* QueryInterface)(struct ITypeLib *, IID *, void * *);
    ULONG (* AddRef)(struct ITypeLib *);
    ULONG (* Release)(struct ITypeLib *);
    UINT (* GetTypeInfoCount)(struct ITypeLib *);
    HRESULT (* GetTypeInfo)(struct ITypeLib *, UINT, struct ITypeInfo * *);
    HRESULT (* GetTypeInfoType)(struct ITypeLib *, UINT, TYPEKIND *);
    HRESULT (* GetTypeInfoOfGuid)(struct ITypeLib *, GUID *, struct ITypeInfo * *);
    HRESULT (* GetLibAttr)(struct ITypeLib *, TLIBATTR * *);
    HRESULT (* GetTypeComp)(struct ITypeLib *, struct ITypeComp * *);
    HRESULT (* GetDocumentation)(struct ITypeLib *, INT, BSTR *, BSTR *, DWORD *, BSTR *);
    HRESULT (* IsName)(struct ITypeLib *, LPOLESTR, ULONG, BOOL *);
    HRESULT (* FindName)(struct ITypeLib *, LPOLESTR, ULONG, struct ITypeInfo * *, MEMBERID *, USHORT *);
    void (* ReleaseTLibAttr)(struct ITypeLib *, TLIBATTR *);
};

struct tagTLIBATTR {
    GUID guid;
    LCID lcid;
    SYSKIND syskind;
    WORD wMajorVerNum;
    WORD wMinorVerNum;
    WORD wLibFlags;
};

struct tagARRAYDESC {
    TYPEDESC tdescElem;
    USHORT cDims;
    SAFEARRAYBOUND rgbounds[1];
};

struct ITypeComp {
    struct ITypeCompVtbl * lpVtbl;
};

struct IRecordInfo {
    struct IRecordInfoVtbl * lpVtbl;
};

struct tagTYPEATTR {
    GUID guid;
    LCID lcid;
    DWORD dwReserved;
    MEMBERID memidConstructor;
    MEMBERID memidDestructor;
    LPOLESTR lpstrSchema;
    ULONG cbSizeInstance;
    TYPEKIND typekind;
    WORD cFuncs;
    WORD cVars;
    WORD cImplTypes;
    WORD cbSizeVft;
    WORD cbAlignment;
    WORD wTypeFlags;
    WORD wMajorVerNum;
    WORD wMinorVerNum;
    TYPEDESC tdescAlias;
    IDLDESC idldescType;
};

struct IRecordInfoVtbl {
    HRESULT (* QueryInterface)(struct IRecordInfo *, IID *, void * *);
    ULONG (* AddRef)(struct IRecordInfo *);
    ULONG (* Release)(struct IRecordInfo *);
    HRESULT (* RecordInit)(struct IRecordInfo *, PVOID);
    HRESULT (* RecordClear)(struct IRecordInfo *, PVOID);
    HRESULT (* RecordCopy)(struct IRecordInfo *, PVOID, PVOID);
    HRESULT (* GetGuid)(struct IRecordInfo *, GUID *);
    HRESULT (* GetName)(struct IRecordInfo *, BSTR *);
    HRESULT (* GetSize)(struct IRecordInfo *, ULONG *);
    HRESULT (* GetTypeInfo)(struct IRecordInfo *, struct ITypeInfo * *);
    HRESULT (* GetField)(struct IRecordInfo *, PVOID, LPCOLESTR, VARIANT *);
    HRESULT (* GetFieldNoCopy)(struct IRecordInfo *, PVOID, LPCOLESTR, VARIANT *, PVOID *);
    HRESULT (* PutField)(struct IRecordInfo *, ULONG, PVOID, LPCOLESTR, VARIANT *);
    HRESULT (* PutFieldNoCopy)(struct IRecordInfo *, ULONG, PVOID, LPCOLESTR, VARIANT *);
    HRESULT (* GetFieldNames)(struct IRecordInfo *, ULONG *, BSTR *);
    BOOL (* IsMatchingType)(struct IRecordInfo *, struct IRecordInfo *);
    PVOID (* RecordCreate)(struct IRecordInfo *);
    HRESULT (* RecordCreateCopy)(struct IRecordInfo *, PVOID, PVOID *);
    HRESULT (* RecordDestroy)(struct IRecordInfo *, PVOID);
};

struct tagDISPPARAMS {
    VARIANTARG * rgvarg;
    DISPID * rgdispidNamedArgs;
    UINT cArgs;
    UINT cNamedArgs;
};

union tagBINDPTR {
    FUNCDESC * lpfuncdesc;
    VARDESC * lpvardesc;
    struct ITypeComp * lptcomp;
};

struct IDispatch {
    struct IDispatchVtbl * lpVtbl;
};

struct IUnknownVtbl {
    HRESULT (* QueryInterface)(struct IUnknown *, IID *, void * *);
    ULONG (* AddRef)(struct IUnknown *);
    ULONG (* Release)(struct IUnknown *);
};

struct IDispatchVtbl {
    HRESULT (* QueryInterface)(struct IDispatch *, IID *, void * *);
    ULONG (* AddRef)(struct IDispatch *);
    ULONG (* Release)(struct IDispatch *);
    HRESULT (* GetTypeInfoCount)(struct IDispatch *, UINT *);
    HRESULT (* GetTypeInfo)(struct IDispatch *, UINT, LCID, struct ITypeInfo * *);
    HRESULT (* GetIDsOfNames)(struct IDispatch *, IID *, LPOLESTR *, UINT, LCID, DISPID *);
    HRESULT (* Invoke)(struct IDispatch *, DISPID, IID *, LCID, WORD, DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *);
};

struct IUnknown {
    struct IUnknownVtbl * lpVtbl;
};

struct ITypeLib {
    struct ITypeLibVtbl * lpVtbl;
};

struct ITypeInfo {
    struct ITypeInfoVtbl * lpVtbl;
};

struct tagEXCEPINFO {
    WORD wCode;
    WORD wReserved;
    BSTR bstrSource;
    BSTR bstrDescription;
    BSTR bstrHelpFile;
    DWORD dwHelpContext;
    PVOID pvReserved;
    HRESULT (* pfnDeferredFillIn)(struct tagEXCEPINFO *);
    SCODE scode;
};

typedef uint UINT_PTR;

typedef ULONG_PTR SIZE_T;

typedef struct DotNetPdbInfo DotNetPdbInfo, *PDotNetPdbInfo;

struct DotNetPdbInfo {
    char signature[4];
    GUID guid;
    dword age;
    char pdbpath[66];
};


// WARNING! conflicting data type names: /WinDef.h/ULONG - /wtypes.h/ULONG

typedef uchar UCHAR;

typedef UCHAR * PUCHAR;

typedef UINT_PTR WPARAM;

typedef DWORD * LPDWORD;

typedef struct tagRECT RECT;

typedef RECT * LPCRECT;

typedef DWORD * PDWORD;

typedef uint * PUINT;

typedef struct HINSTANCE__ HINSTANCE__, *PHINSTANCE__;

typedef struct HINSTANCE__ * HINSTANCE;

struct HINSTANCE__ {
    int unused;
};

typedef void * LPVOID;

typedef HINSTANCE HMODULE;

typedef HANDLE HLOCAL;

typedef BYTE * LPBYTE;

typedef struct _FILETIME * LPFILETIME;

typedef int (* FARPROC)(void);

typedef void * LPCVOID;

typedef union IMAGE_RESOURCE_DIRECTORY_ENTRY IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;

typedef union IMAGE_RESOURCE_DIRECTORY_ENTRY_NameUnion IMAGE_RESOURCE_DIRECTORY_ENTRY_NameUnion, *PIMAGE_RESOURCE_DIRECTORY_ENTRY_NameUnion;

typedef struct IMAGE_RESOURCE_DIRECTORY_ENTRY_NameStruct IMAGE_RESOURCE_DIRECTORY_ENTRY_NameStruct, *PIMAGE_RESOURCE_DIRECTORY_ENTRY_NameStruct;

struct IMAGE_RESOURCE_DIRECTORY_ENTRY_NameStruct {
    dword NameOffset;
    dword NameIsString;
};

union IMAGE_RESOURCE_DIRECTORY_ENTRY_NameUnion {
    struct IMAGE_RESOURCE_DIRECTORY_ENTRY_NameStruct IMAGE_RESOURCE_DIRECTORY_ENTRY_NameStruct;
    dword Name;
    word Id;
};

union IMAGE_RESOURCE_DIRECTORY_ENTRY {
    union IMAGE_RESOURCE_DIRECTORY_ENTRY_NameUnion NameUnion;
    union IMAGE_RESOURCE_DIRECTORY_ENTRY_DirectoryUnion DirectoryUnion;
};

typedef struct IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;

typedef struct IMAGE_DATA_DIRECTORY IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;

struct IMAGE_DATA_DIRECTORY {
    ImageBaseOffset32 VirtualAddress;
    dword Size;
};

struct IMAGE_OPTIONAL_HEADER32 {
    word Magic;
    byte MajorLinkerVersion;
    byte MinorLinkerVersion;
    dword SizeOfCode;
    dword SizeOfInitializedData;
    dword SizeOfUninitializedData;
    ImageBaseOffset32 AddressOfEntryPoint;
    ImageBaseOffset32 BaseOfCode;
    ImageBaseOffset32 BaseOfData;
    pointer32 ImageBase;
    dword SectionAlignment;
    dword FileAlignment;
    word MajorOperatingSystemVersion;
    word MinorOperatingSystemVersion;
    word MajorImageVersion;
    word MinorImageVersion;
    word MajorSubsystemVersion;
    word MinorSubsystemVersion;
    dword Win32VersionValue;
    dword SizeOfImage;
    dword SizeOfHeaders;
    dword CheckSum;
    word Subsystem;
    word DllCharacteristics;
    dword SizeOfStackReserve;
    dword SizeOfStackCommit;
    dword SizeOfHeapReserve;
    dword SizeOfHeapCommit;
    dword LoaderFlags;
    dword NumberOfRvaAndSizes;
    struct IMAGE_DATA_DIRECTORY DataDirectory[16];
};

typedef struct IMAGE_SECTION_HEADER IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;

typedef union Misc Misc, *PMisc;

typedef enum SectionFlags {
    IMAGE_SCN_TYPE_NO_PAD=8,
    IMAGE_SCN_RESERVED_0001=16,
    IMAGE_SCN_CNT_CODE=32,
    IMAGE_SCN_CNT_INITIALIZED_DATA=64,
    IMAGE_SCN_CNT_UNINITIALIZED_DATA=128,
    IMAGE_SCN_LNK_OTHER=256,
    IMAGE_SCN_LNK_INFO=512,
    IMAGE_SCN_RESERVED_0040=1024,
    IMAGE_SCN_LNK_REMOVE=2048,
    IMAGE_SCN_LNK_COMDAT=4096,
    IMAGE_SCN_GPREL=32768,
    IMAGE_SCN_MEM_16BIT=131072,
    IMAGE_SCN_MEM_PURGEABLE=131072,
    IMAGE_SCN_MEM_LOCKED=262144,
    IMAGE_SCN_MEM_PRELOAD=524288,
    IMAGE_SCN_ALIGN_1BYTES=1048576,
    IMAGE_SCN_ALIGN_2BYTES=2097152,
    IMAGE_SCN_ALIGN_4BYTES=3145728,
    IMAGE_SCN_ALIGN_8BYTES=4194304,
    IMAGE_SCN_ALIGN_16BYTES=5242880,
    IMAGE_SCN_ALIGN_32BYTES=6291456,
    IMAGE_SCN_ALIGN_64BYTES=7340032,
    IMAGE_SCN_ALIGN_128BYTES=8388608,
    IMAGE_SCN_ALIGN_256BYTES=9437184,
    IMAGE_SCN_ALIGN_512BYTES=10485760,
    IMAGE_SCN_ALIGN_1024BYTES=11534336,
    IMAGE_SCN_ALIGN_2048BYTES=12582912,
    IMAGE_SCN_ALIGN_4096BYTES=13631488,
    IMAGE_SCN_ALIGN_8192BYTES=14680064,
    IMAGE_SCN_LNK_NRELOC_OVFL=16777216,
    IMAGE_SCN_MEM_DISCARDABLE=33554432,
    IMAGE_SCN_MEM_NOT_CACHED=67108864,
    IMAGE_SCN_MEM_NOT_PAGED=134217728,
    IMAGE_SCN_MEM_SHARED=268435456,
    IMAGE_SCN_MEM_EXECUTE=536870912,
    IMAGE_SCN_MEM_READ=1073741824,
    IMAGE_SCN_MEM_WRITE=2147483648
} SectionFlags;

union Misc {
    dword PhysicalAddress;
    dword VirtualSize;
};

struct IMAGE_SECTION_HEADER {
    char Name[8];
    union Misc Misc;
    ImageBaseOffset32 VirtualAddress;
    dword SizeOfRawData;
    dword PointerToRawData;
    dword PointerToRelocations;
    dword PointerToLinenumbers;
    word NumberOfRelocations;
    word NumberOfLinenumbers;
    enum SectionFlags Characteristics;
};

typedef struct IMAGE_RESOURCE_DATA_ENTRY IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;

struct IMAGE_RESOURCE_DATA_ENTRY {
    dword OffsetToData;
    dword Size;
    dword CodePage;
    dword Reserved;
};

typedef enum IMAGE_GUARD_FLAGS {
    IMAGE_GUARD_CF_INSTRUMENTED=256,
    IMAGE_GUARD_CFW_INSTRUMENTED=512,
    IMAGE_GUARD_CF_FUNCTION_TABLE_PRESENT=1024,
    IMAGE_GUARD_SECURITY_COOKIE_UNUSED=2048,
    IMAGE_GUARD_PROTECT_DELAYLOAD_IAT=4096,
    IMAGE_GUARD_DELAYLOAD_IAT_IN_ITS_OWN_SECTION=8192,
    IMAGE_GUARD_CF_EXPORT_SUPPRESSION_INFO_PRESENT=16384,
    IMAGE_GUARD_CF_ENABLE_EXPORT_SUPPRESSION=32768,
    IMAGE_GUARD_CF_LONGJUMP_TABLE_PRESENT=65536,
    IMAGE_GUARD_RF_INSTRUMENTED=131072,
    IMAGE_GUARD_RF_ENABLE=262144,
    IMAGE_GUARD_RF_STRICT=524288,
    IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK_1=268435456,
    IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK_2=536870912,
    IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK_4=1073741824,
    IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK_8=2147483648
} IMAGE_GUARD_FLAGS;

typedef struct IMAGE_RESOURCE_DIRECTORY IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;

struct IMAGE_RESOURCE_DIRECTORY {
    dword Characteristics;
    dword TimeDateStamp;
    word MajorVersion;
    word MinorVersion;
    word NumberOfNamedEntries;
    word NumberOfIdEntries;
};

typedef struct IMAGE_LOAD_CONFIG_CODE_INTEGRITY IMAGE_LOAD_CONFIG_CODE_INTEGRITY, *PIMAGE_LOAD_CONFIG_CODE_INTEGRITY;

struct IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
    word Flags;
    word Catalog;
    dword CatalogOffset;
    dword Reserved;
};

typedef struct IMAGE_DIRECTORY_ENTRY_EXPORT IMAGE_DIRECTORY_ENTRY_EXPORT, *PIMAGE_DIRECTORY_ENTRY_EXPORT;

struct IMAGE_DIRECTORY_ENTRY_EXPORT {
    dword Characteristics;
    dword TimeDateStamp;
    word MajorVersion;
    word MinorVersion;
    dword Name;
    dword Base;
    dword NumberOfFunctions;
    dword NumberOfNames;
    dword AddressOfFunctions;
    dword AddressOfNames;
    dword AddressOfNameOrdinals;
};

typedef struct IMAGE_DEBUG_DIRECTORY IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;

struct IMAGE_DEBUG_DIRECTORY {
    dword Characteristics;
    dword TimeDateStamp;
    word MajorVersion;
    word MinorVersion;
    dword Type;
    dword SizeOfData;
    dword AddressOfRawData;
    dword PointerToRawData;
};

typedef struct IMAGE_FILE_HEADER IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;

struct IMAGE_FILE_HEADER {
    word Machine; // 332
    word NumberOfSections;
    dword TimeDateStamp;
    dword PointerToSymbolTable;
    dword NumberOfSymbols;
    word SizeOfOptionalHeader;
    word Characteristics;
};

typedef struct IMAGE_NT_HEADERS32 IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;

struct IMAGE_NT_HEADERS32 {
    char Signature[4];
    struct IMAGE_FILE_HEADER FileHeader;
    struct IMAGE_OPTIONAL_HEADER32 OptionalHeader;
};

typedef struct IMAGE_LOAD_CONFIG_DIRECTORY32 IMAGE_LOAD_CONFIG_DIRECTORY32, *PIMAGE_LOAD_CONFIG_DIRECTORY32;

struct IMAGE_LOAD_CONFIG_DIRECTORY32 {
    dword Size;
    dword TimeDateStamp;
    word MajorVersion;
    word MinorVersion;
    dword GlobalFlagsClear;
    dword GlobalFlagsSet;
    dword CriticalSectionDefaultTimeout;
    dword DeCommitFreeBlockThreshold;
    dword DeCommitTotalFreeThreshold;
    pointer32 LockPrefixTable;
    dword MaximumAllocationSize;
    dword VirtualMemoryThreshold;
    dword ProcessHeapFlags;
    dword ProcessAffinityMask;
    word CsdVersion;
    word DependentLoadFlags;
    pointer32 EditList;
    pointer32 SecurityCookie;
    pointer32 SEHandlerTable;
    dword SEHandlerCount;
    pointer32 GuardCFCCheckFunctionPointer;
    pointer32 GuardCFDispatchFunctionPointer;
    pointer32 GuardCFFunctionTable;
    dword GuardCFFunctionCount;
    enum IMAGE_GUARD_FLAGS GuardFlags;
    struct IMAGE_LOAD_CONFIG_CODE_INTEGRITY CodeIntegrity;
    pointer32 GuardAddressTakenIatEntryTable;
    dword GuardAddressTakenIatEntryCount;
    pointer32 GuardLongJumpTargetTable;
    dword GuardLongJumpTargetCount;
    pointer32 DynamicValueRelocTable;
    pointer32 CHPEMetadataPointer;
    pointer32 GuardRFFailureRoutine;
    pointer32 GuardRFFailureRoutineFunctionPointer;
    dword DynamicValueRelocTableOffset;
    word DynamicValueRelocTableSection;
    word Reserved1;
    pointer32 GuardRFVerifyStackPointerFunctionPointer;
    dword HotPatchTableOffset;
    dword Reserved2;
    dword Reserved3;
};

typedef void (* PMFN)(void *);

typedef struct _s_CatchableType _s_CatchableType, *P_s_CatchableType;


// WARNING! conflicting data type names: /ehdata.h/TypeDescriptor - /TypeDescriptor

struct _s_CatchableType {
    uint properties;
    struct TypeDescriptor * pType;
    struct PMD thisDisplacement;
    int sizeOrOffset;
    PMFN copyFunction;
};

typedef struct _s_CatchableType CatchableType;

typedef struct _s_CatchableTypeArray _s_CatchableTypeArray, *P_s_CatchableTypeArray;

typedef struct _s_CatchableTypeArray CatchableTypeArray;

struct _s_CatchableTypeArray {
    int nCatchableTypes;
    CatchableType * arrayOfCatchableTypes[0];
};

typedef struct _s_ThrowInfo _s_ThrowInfo, *P_s_ThrowInfo;

typedef struct _s_ThrowInfo ThrowInfo;

struct _s_ThrowInfo {
    uint attributes;
    PMFN pmfnUnwind;
    int (* pForwardCompat)(void);
    CatchableTypeArray * pCatchableTypeArray;
};

typedef struct _IMAGE_SECTION_HEADER _IMAGE_SECTION_HEADER, *P_IMAGE_SECTION_HEADER;

struct _IMAGE_SECTION_HEADER { // PlaceHolder Structure
};

typedef struct IErrorInfo IErrorInfo, *PIErrorInfo;

struct IErrorInfo { // PlaceHolder Structure
};

typedef struct basic_streambuf<char,struct_std::char_traits<char>_> basic_streambuf<char,struct_std::char_traits<char>_>, *Pbasic_streambuf<char,struct_std::char_traits<char>_>;

struct basic_streambuf<char,struct_std::char_traits<char>_> { // PlaceHolder Structure
};

typedef struct ios_base ios_base, *Pios_base;

struct ios_base { // PlaceHolder Structure
};

typedef struct basic_ostream<char,struct_std::char_traits<char>_> basic_ostream<char,struct_std::char_traits<char>_>, *Pbasic_ostream<char,struct_std::char_traits<char>_>;

struct basic_ostream<char,struct_std::char_traits<char>_> { // PlaceHolder Structure
};

typedef struct basic_iostream<char,struct_std::char_traits<char>_> basic_iostream<char,struct_std::char_traits<char>_>, *Pbasic_iostream<char,struct_std::char_traits<char>_>;

struct basic_iostream<char,struct_std::char_traits<char>_> { // PlaceHolder Structure
};

typedef struct basic_ios<char,struct_std::char_traits<char>_> basic_ios<char,struct_std::char_traits<char>_>, *Pbasic_ios<char,struct_std::char_traits<char>_>;

struct basic_ios<char,struct_std::char_traits<char>_> { // PlaceHolder Structure
};

typedef struct locale locale, *Plocale;

struct locale { // PlaceHolder Structure
};

typedef int (* _onexit_t)(void);

typedef uint size_t;

typedef struct IUnknown * LPUNKNOWN;




void __cdecl FUN_10001060(int param_1)

{
  *(uint *)(param_1 + 0x14) = *(uint *)(param_1 + 0x14) & 0xfffff9ff | 0x800;
  return;
}



undefined4 * __thiscall FUN_10001080(void *this,LPCSTR param_1)

{
  code *pcVar1;
  undefined4 *puVar2;
  undefined4 uVar3;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b59f;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  puVar2 = (undefined4 *)FUN_1000a4ab(0xc);
  local_8 = 0;
  if (puVar2 == (undefined4 *)0x0) {
    puVar2 = (undefined4 *)0x0;
  }
  else {
    puVar2[1] = 0;
    puVar2[2] = 1;
    uVar3 = ConvertStringToBSTR(param_1);
    *puVar2 = uVar3;
  }
  local_8 = 0xffffffff;
  *(undefined4 **)this = puVar2;
  if (puVar2 != (undefined4 *)0x0) {
    ExceptionList = local_10;
    return (undefined4 *)this;
  }
  _com_issue_error(-0x7ff8fff2);
  pcVar1 = (code *)swi(3);
  puVar2 = (undefined4 *)(*pcVar1)();
  return puVar2;
}



void __fastcall FUN_10001110(undefined4 *param_1)

{
  BSTR *ppOVar1;
  BSTR *ppOVar2;
  BSTR pOVar3;
  
  ppOVar2 = (BSTR *)*param_1;
  if (ppOVar2 != (BSTR *)0x0) {
    LOCK();
    ppOVar1 = ppOVar2 + 2;
    pOVar3 = *ppOVar1;
    *ppOVar1 = (BSTR)((int)*ppOVar1 + -1);
    if ((pOVar3 == (BSTR)0x1) && (ppOVar2 != (BSTR *)0x0)) {
      if (*ppOVar2 != (BSTR)0x0) {
        SysFreeString(*ppOVar2);
        *ppOVar2 = (BSTR)0x0;
      }
      if (ppOVar2[1] != (BSTR)0x0) {
        free(ppOVar2[1]);
        ppOVar2[1] = (BSTR)0x0;
      }
      FUN_1000a4db(ppOVar2);
    }
    *param_1 = 0;
  }
  return;
}



LPWSTR FUN_10001170(undefined4 *param_1)

{
  int iVar1;
  undefined4 *lpMultiByteStr;
  uint cchWideChar;
  LPWSTR lpWideCharStr;
  
  iVar1 = param_1[4];
  lpMultiByteStr = param_1;
  if (0xf < (uint)param_1[5]) {
    lpMultiByteStr = (undefined4 *)*param_1;
  }
  cchWideChar = MultiByteToWideChar(0,0,(LPCSTR)lpMultiByteStr,iVar1 + 1,(LPWSTR)0x0,0);
  lpWideCharStr =
       (LPWSTR)FUN_1000a4e9(-(uint)((int)((ulonglong)cchWideChar * 2 >> 0x20) != 0) |
                            (uint)((ulonglong)cchWideChar * 2));
  if (0xf < (uint)param_1[5]) {
    param_1 = (undefined4 *)*param_1;
  }
  MultiByteToWideChar(0,0,(LPCSTR)param_1,iVar1 + 1,lpWideCharStr,cchWideChar);
  return lpWideCharStr;
}



// WARNING: Could not reconcile some variable overlaps

void FUN_100011e0(void *param_1)

{
  BSTR *ppOVar1;
  int iVar2;
  uint uVar3;
  HRESULT HVar4;
  int *piVar5;
  basic_ostream_char_struct_std__char_traits_char___ *pbVar6;
  undefined4 *puVar7;
  BSTR *ppOVar8;
  BSTR pOVar9;
  int *piVar10;
  LPWSTR pWVar11;
  void *pvVar12;
  undefined4 uStack00000014;
  uint in_stack_00000018;
  void *in_stack_0000001c;
  uint in_stack_00000030;
  undefined4 uVar13;
  undefined *puVar14;
  undefined4 uVar15;
  code *pcVar16;
  undefined4 uVar17;
  int in_stack_fffffefc;
  int local_f4 [2];
  undefined4 local_ec [2];
  basic_iostream_char_struct_std__char_traits_char___ local_e4 [72];
  basic_ios_char_struct_std__char_traits_char___ local_9c [80];
  int local_4c;
  BSTR *local_48;
  int *local_44;
  BSTR *local_40;
  int *local_3c;
  BSTR *local_38;
  int *local_34;
  IUnknown *local_30;
  void *local_2c [2];
  undefined local_24 [12];
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000b65e;
  local_10 = ExceptionList;
  uVar3 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  local_8 = 1;
  local_14 = uVar3;
  HVar4 = CoInitializeEx((LPVOID)0x0,2);
  if (HVar4 < 0) {
    FUN_10001b00((int *)&stack0xfffffefc);
    pcVar16 = FUN_10001060;
    local_8._0_1_ = 2;
    piVar5 = FUN_100023d0(local_f4,"Failed to initialize COM library. Error code = 0x");
    pbVar6 = std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                       ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,pcVar16);
    std::basic_ostream<char,struct_std::char_traits<char>_>::operator__(pbVar6,HVar4);
    puVar7 = (undefined4 *)FUN_10001a40(&stack0xfffffefc,(undefined *)local_2c);
    local_8._0_1_ = 3;
    FUN_10001170(puVar7);
    if (0xf < local_18) {
      pvVar12 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar12 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar12)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar12);
    }
    local_24._8_4_ = 0;
    local_18 = 0xf;
    local_2c[0] = (void *)((uint)local_2c[0] & 0xffffff00);
    *(undefined ***)(local_e4 + *(int *)(in_stack_fffffefc + 4) + -0x20) =
         std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
         vftable;
    *(int *)((int)local_ec + *(int *)(in_stack_fffffefc + 4) + -0x1c) =
         *(int *)(in_stack_fffffefc + 4) + -0x68;
    FUN_100020a0(local_ec);
    std::basic_iostream<char,struct_std::char_traits<char>_>::
    _basic_iostream_char_struct_std__char_traits_char___(local_e4);
    std::basic_ios<char,struct_std::char_traits<char>_>::
    _basic_ios_char_struct_std__char_traits_char___(local_9c);
    goto LAB_100018fa;
  }
  local_34 = (int *)0x0;
  HVar4 = CoCreateInstance((IID *)&DAT_1000d304,(LPUNKNOWN)0x0,1,(IID *)&DAT_1000d314,&local_34);
  if (HVar4 < 0) {
    FUN_10001b00((int *)&stack0xfffffefc);
    pcVar16 = FUN_10001060;
    local_8._0_1_ = 4;
    piVar5 = FUN_100023d0(local_f4,"Failed to create IWbemLocator object.");
    piVar5 = FUN_100023d0(piVar5," Err code = 0x");
    pbVar6 = std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                       ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,pcVar16);
    std::basic_ostream<char,struct_std::char_traits<char>_>::operator__(pbVar6,HVar4);
    CoUninitialize();
    puVar7 = (undefined4 *)FUN_10001a40(&stack0xfffffefc,(undefined *)local_2c);
    local_8._0_1_ = 5;
    FUN_10001170(puVar7);
    if (0xf < local_18) {
      pvVar12 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar12 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar12)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar12);
    }
    local_24._8_4_ = 0;
    local_18 = 0xf;
    local_2c[0] = (void *)((uint)local_2c[0] & 0xffffff00);
    *(undefined ***)(local_e4 + *(int *)(in_stack_fffffefc + 4) + -0x20) =
         std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
         vftable;
    *(int *)((int)local_ec + *(int *)(in_stack_fffffefc + 4) + -0x1c) =
         *(int *)(in_stack_fffffefc + 4) + -0x68;
    FUN_100020a0(local_ec);
    std::basic_iostream<char,struct_std::char_traits<char>_>::
    _basic_iostream_char_struct_std__char_traits_char___(local_e4);
    std::basic_ios<char,struct_std::char_traits<char>_>::
    _basic_ios_char_struct_std__char_traits_char___(local_9c);
    goto LAB_100018fa;
  }
  local_30 = (IUnknown *)0x0;
  ppOVar8 = (BSTR *)FUN_1000a4ab(0xc);
  local_8._0_1_ = 6;
  if (ppOVar8 == (BSTR *)0x0) {
    ppOVar8 = (BSTR *)0x0;
  }
  else {
    ppOVar8[1] = (BSTR)0x0;
    ppOVar8[2] = (BSTR)0x1;
    local_40 = ppOVar8;
    pOVar9 = SysAllocString(L"ROOT\\CIMV2");
    *ppOVar8 = pOVar9;
    if (pOVar9 == (BSTR)0x0) {
      _com_issue_error(-0x7ff8fff2);
      goto LAB_100019a2;
    }
  }
  local_8._0_1_ = 1;
  local_40 = ppOVar8;
  if (ppOVar8 == (BSTR *)0x0) {
LAB_100019a2:
    _com_issue_error(-0x7ff8fff2);
    pcVar16 = (code *)swi(3);
    (*pcVar16)();
    return;
  }
  local_8._0_1_ = 7;
  local_38 = (BSTR *)(**(code **)(*local_34 + 0xc))(local_34,*ppOVar8,0,0,0,0,0,0,&local_30,uVar3);
  local_8._0_1_ = 1;
  LOCK();
  ppOVar1 = ppOVar8 + 2;
  pOVar9 = *ppOVar1;
  *ppOVar1 = (BSTR)((int)*ppOVar1 + -1);
  if (pOVar9 == (BSTR)0x1) {
    if (*ppOVar8 != (BSTR)0x0) {
      SysFreeString(*ppOVar8);
      *ppOVar8 = (BSTR)0x0;
    }
    if (ppOVar8[1] != (BSTR)0x0) {
      free(ppOVar8[1]);
      ppOVar8[1] = (BSTR)0x0;
    }
    FUN_1000a4db(ppOVar8);
  }
  if ((int)local_38 < 0) {
    FUN_10001b00((int *)&stack0xfffffefc);
    local_8._0_1_ = 8;
    pcVar16 = FUN_10001060;
    ppOVar8 = local_38;
    piVar5 = FUN_100023d0(local_f4,"Could not connect. Error code = 0x");
    pbVar6 = std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                       ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,pcVar16);
    std::basic_ostream<char,struct_std::char_traits<char>_>::operator__(pbVar6,(long)ppOVar8);
    (**(code **)(*local_34 + 8))();
    CoUninitialize();
    puVar7 = (undefined4 *)FUN_10001a40(&stack0xfffffefc,(undefined *)local_2c);
    local_8._0_1_ = 9;
    FUN_10001170(puVar7);
    if (0xf < local_18) {
      pvVar12 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar12 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)*(void **)((int)local_2c[0] + -4))))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
LAB_10001844:
      FUN_1000a4db(pvVar12);
    }
  }
  else {
    HVar4 = CoSetProxyBlanket(local_30,10,0,(OLECHAR *)0x0,3,3,(RPC_AUTH_IDENTITY_HANDLE)0x0,0);
    if (HVar4 < 0) {
      FUN_10001b00((int *)&stack0xfffffefc);
      pcVar16 = FUN_10001060;
      local_8._0_1_ = 10;
      piVar5 = FUN_100023d0(local_f4,"Could not set proxy blanket. Error code = 0x");
      pbVar6 = std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                         ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,pcVar16);
      std::basic_ostream<char,struct_std::char_traits<char>_>::operator__(pbVar6,HVar4);
      (*local_30->lpVtbl->Release)(local_30);
      (**(code **)(*local_34 + 8))();
      CoUninitialize();
      puVar7 = (undefined4 *)FUN_10001a40(&stack0xfffffefc,(undefined *)local_2c);
      local_8._0_1_ = 0xb;
      FUN_10001170(puVar7);
      if (0xf < local_18) {
        pvVar12 = local_2c[0];
        if ((0xfff < local_18 + 1) &&
           (pvVar12 = *(void **)((int)local_2c[0] + -4),
           0x1f < (uint)((int)local_2c[0] + (-4 - (int)*(void **)((int)local_2c[0] + -4))))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
        goto LAB_10001844;
      }
    }
    else {
      local_44 = (int *)0x0;
      puVar7 = FUN_10002620(local_2c,"SELECT * FROM ",&param_1);
      local_8._0_1_ = 0xc;
      if (0xf < (uint)puVar7[5]) {
        puVar7 = (undefined4 *)*puVar7;
      }
      piVar5 = FUN_10001080(&local_48,(LPCSTR)puVar7);
      local_8._0_1_ = 0xd;
      piVar10 = FUN_10001080(&local_38,"WQL");
      local_8 = CONCAT31(local_8._1_3_,0xe);
      if ((undefined4 *)*piVar5 == (undefined4 *)0x0) {
        uVar13 = 0;
      }
      else {
        uVar13 = *(undefined4 *)*piVar5;
      }
      if ((undefined4 *)*piVar10 == (undefined4 *)0x0) {
        uVar15 = 0;
      }
      else {
        uVar15 = *(undefined4 *)*piVar10;
      }
      uVar17 = 0x30;
      local_40 = (BSTR *)(*local_30->lpVtbl[6].Release)(local_30);
      ppOVar8 = local_38;
      if (local_38 != (BSTR *)0x0) {
        LOCK();
        ppOVar1 = local_38 + 2;
        pOVar9 = *ppOVar1;
        *ppOVar1 = (BSTR)((int)*ppOVar1 + -1);
        if ((pOVar9 == (BSTR)0x1) && (local_38 != (BSTR *)0x0)) {
          if (*local_38 != (BSTR)0x0) {
            SysFreeString(*local_38);
            *ppOVar8 = (BSTR)0x0;
          }
          if (ppOVar8[1] != (BSTR)0x0) {
            free(ppOVar8[1]);
            ppOVar8[1] = (BSTR)0x0;
          }
          FUN_1000a4db(ppOVar8);
        }
        local_38 = (BSTR *)0x0;
      }
      if (local_48 != (BSTR *)0x0) {
        LOCK();
        ppOVar8 = local_48 + 2;
        pOVar9 = *ppOVar8;
        *ppOVar8 = (BSTR)((int)*ppOVar8 + -1);
        if ((pOVar9 == (BSTR)0x1) && (local_48 != (BSTR *)0x0)) {
          if (*local_48 != (BSTR)0x0) {
            SysFreeString(*local_48);
            *local_48 = (BSTR)0x0;
          }
          if (local_48[1] != (BSTR)0x0) {
            free(local_48[1]);
            local_48[1] = (BSTR)0x0;
          }
          FUN_1000a4db(local_48);
        }
        local_48 = (BSTR *)0x0;
      }
      local_8._0_1_ = 1;
      if (0xf < local_18) {
        pvVar12 = local_2c[0];
        if ((0xfff < local_18 + 1) &&
           (pvVar12 = *(void **)((int)local_2c[0] + -4),
           0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar12)))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
        FUN_1000a4db(pvVar12);
      }
      ppOVar8 = local_40;
      if (-1 < (int)local_40) {
        local_3c = (int *)0x0;
        local_4c = 0;
        (**(code **)(*local_44 + 0x10))
                  (local_44,0xffffffff,1,&local_3c,&local_4c,uVar15,uVar13,uVar17);
        if (local_4c != 0) {
          VariantInit((VARIANTARG *)local_24);
          uVar17 = 0;
          uVar15 = 0;
          iVar2 = *local_3c;
          puVar14 = local_24;
          uVar13 = 0;
          pWVar11 = FUN_10001170(&stack0x0000001c);
          (**(code **)(iVar2 + 0x10))(local_3c,pWVar11,uVar13,puVar14,uVar15,uVar17);
          VariantClear((VARIANTARG *)local_24);
          (**(code **)(*local_3c + 8))(local_3c);
        }
        (**(code **)(*local_44 + 8))(local_44);
        (*local_30->lpVtbl->Release)(local_30);
        (**(code **)(*local_34 + 8))(local_34);
        CoUninitialize();
        goto LAB_100018fa;
      }
      FUN_10001b00((int *)&stack0xfffffefc);
      pcVar16 = FUN_10001060;
      local_8._0_1_ = 0xf;
      piVar5 = FUN_100023d0(local_f4,"Query failed.");
      piVar5 = FUN_100023d0(piVar5," Error code = 0x");
      pbVar6 = std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                         ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,pcVar16);
      std::basic_ostream<char,struct_std::char_traits<char>_>::operator__(pbVar6,(long)ppOVar8);
      puVar7 = (undefined4 *)FUN_10001a40(&stack0xfffffefc,(undefined *)local_2c);
      local_8._0_1_ = 0x10;
      FUN_10001170(puVar7);
      if (0xf < local_18) {
        pvVar12 = local_2c[0];
        if ((0xfff < local_18 + 1) &&
           (pvVar12 = *(void **)((int)local_2c[0] + -4),
           0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar12)))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
        goto LAB_10001844;
      }
    }
  }
  local_24._8_4_ = 0;
  local_18 = 0xf;
  local_2c[0] = (void *)((uint)local_2c[0] & 0xffffff00);
  FUN_100019b0((int *)&stack0xfffffefc);
LAB_100018fa:
  if (0xf < in_stack_00000018) {
    pvVar12 = param_1;
    if ((0xfff < in_stack_00000018 + 1) &&
       (pvVar12 = *(void **)((int)param_1 + -4), 0x1f < (uint)((int)param_1 + (-4 - (int)pvVar12))))
    {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar12);
  }
  uStack00000014 = 0;
  in_stack_00000018 = 0xf;
  param_1 = (void *)((uint)param_1 & 0xffffff00);
  if (0xf < in_stack_00000030) {
    pvVar12 = in_stack_0000001c;
    if ((0xfff < in_stack_00000030 + 1) &&
       (pvVar12 = *(void **)((int)in_stack_0000001c + -4),
       0x1f < (uint)((int)in_stack_0000001c + (-4 - (int)pvVar12)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar12);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void __fastcall FUN_100019b0(int *param_1)

{
  int *this;
  
  this = param_1 + 0x1a;
  *(undefined ***)(*(int *)(*param_1 + 4) + -0x68 + (int)this) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)(*(int *)(*param_1 + 4) + -0x6c + (int)this) = *(int *)(*param_1 + 4) + -0x68;
  FUN_100020a0(param_1 + 6);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___
            ((basic_iostream_char_struct_std__char_traits_char___ *)(param_1 + 8));
                    // WARNING: Could not recover jumptable at 0x100019e2. Too many branches
                    // WARNING: Treating indirect jump as call
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___
            ((basic_ios_char_struct_std__char_traits_char___ *)this);
  return;
}



void __fastcall FUN_100019f0(void **param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  if ((void *)0xf < param_1[5]) {
    pvVar1 = *param_1;
    pvVar2 = pvVar1;
    if ((0xfff < (int)param_1[5] + 1U) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  param_1[4] = (void *)0x0;
  param_1[5] = (void *)0xf;
  *(undefined *)param_1 = 0;
  return;
}



undefined * __thiscall FUN_10001a40(void *this,undefined *param_1)

{
  uint uVar1;
  int *piVar2;
  void *pvVar3;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  pvVar3 = ExceptionList;
  puStack_c = &LAB_1000b6a9;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  local_8 = 0;
  *(undefined4 *)(param_1 + 0x10) = 0;
  *(undefined4 *)(param_1 + 0x14) = 0xf;
  *param_1 = 0;
  if (((*(uint *)((int)this + 0x54) & 2) == 0) &&
     (uVar1 = **(uint **)((int)this + 0x38), uVar1 != 0)) {
    if (uVar1 < *(uint *)((int)this + 0x50)) {
      uVar1 = *(uint *)((int)this + 0x50);
    }
    pvVar3 = **(void ***)((int)this + 0x28);
    piVar2 = (int *)(uVar1 - (int)pvVar3);
  }
  else {
    if ((*(uint *)((int)this + 0x54) & 4) != 0) {
      ExceptionList = pvVar3;
      return param_1;
    }
    if (**(int **)((int)this + 0x34) == 0) {
      ExceptionList = pvVar3;
      return param_1;
    }
    pvVar3 = **(void ***)((int)this + 0x24);
    piVar2 = (int *)((**(int **)((int)this + 0x44) - (int)pvVar3) + **(int **)((int)this + 0x34));
  }
  FUN_10002250(param_1,pvVar3,piVar2);
  ExceptionList = local_10;
  return param_1;
}



int * __fastcall FUN_10001b00(int *param_1)

{
  int *this;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b6f9;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  *param_1 = (int)&PTR_1000d508;
  param_1[4] = (int)&DAT_1000d4b8;
  std::basic_ios<char,struct_std::char_traits<char>_>::
  basic_ios_char_struct_std__char_traits_char___
            ((basic_ios_char_struct_std__char_traits_char___ *)(param_1 + 0x1a));
  this = param_1 + 6;
  local_8 = 0;
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  basic_iostream_char_struct_std__char_traits_char___
            ((basic_iostream_char_struct_std__char_traits_char___ *)param_1,
             (basic_streambuf_char_struct_std__char_traits_char___ *)this);
  local_8 = 1;
  *(undefined ***)((int)param_1 + *(int *)(*param_1 + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)(*(int *)(*param_1 + 4) + -4 + (int)param_1) = *(int *)(*param_1 + 4) + -0x68;
  std::basic_streambuf<char,struct_std::char_traits<char>_>::
  basic_streambuf_char_struct_std__char_traits_char___
            ((basic_streambuf_char_struct_std__char_traits_char___ *)this);
  *this = (int)std::basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>
               ::vftable;
  param_1[0x14] = 0;
  param_1[0x15] = 0;
  ExceptionList = local_10;
  return param_1;
}



void __thiscall
FUN_10001bc0(void *this,uint *param_1,uint param_2,int param_3,uint param_4,int param_5,
            undefined4 param_6,undefined4 param_7,uint param_8)

{
  int iVar1;
  uint uVar2;
  int iVar3;
  int iVar4;
  uint uVar5;
  uint uVar6;
  uint uVar7;
  uint uVar8;
  
  uVar8 = param_4 + param_2;
  uVar7 = param_5 + param_3 + (uint)CARRY4(param_4,param_2);
  iVar1 = **(int **)((int)this + 0x1c);
  uVar2 = **(uint **)((int)this + 0x20);
  if ((uVar2 != 0) && (*(uint *)((int)this + 0x38) < uVar2)) {
    *(uint *)((int)this + 0x38) = uVar2;
  }
  iVar3 = **(int **)((int)this + 0xc);
  iVar4 = *(int *)((int)this + 0x38);
  uVar5 = iVar4 - iVar3;
  uVar6 = (int)uVar5 >> 0x1f;
  if (((uVar7 < uVar6) || ((uVar7 <= uVar6 && (uVar8 <= uVar5)))) &&
     (((uVar8 | uVar7) == 0 ||
      ((((param_8 & 1) == 0 || (iVar1 != 0)) && (((param_8 & 2) == 0 || (uVar2 != 0)))))))) {
    if (((param_8 & 1) != 0) && (iVar1 != 0)) {
      **(int **)((int)this + 0x1c) = iVar3 + uVar8;
      **(int **)((int)this + 0x2c) = iVar4 - (iVar3 + uVar8);
    }
    if (((param_8 & 2) != 0) && (uVar2 != 0)) {
      iVar1 = **(int **)((int)this + 0x20);
      iVar4 = **(int **)((int)this + 0x30);
      **(int **)((int)this + 0x10) = iVar3;
      **(int **)((int)this + 0x20) = iVar3 + uVar8;
      **(int **)((int)this + 0x30) = (iVar1 + iVar4) - (iVar3 + uVar8);
    }
    *param_1 = uVar8;
    param_1[1] = uVar7;
  }
  else {
    *param_1 = 0xffffffff;
    param_1[1] = 0xffffffff;
  }
  param_1[2] = 0;
  param_1[3] = 0;
  *(undefined8 *)(param_1 + 4) = 0;
  return;
}



void __thiscall
FUN_10001cc0(void *this,uint *param_1,uint param_2,int param_3,int param_4,byte param_5)

{
  int iVar1;
  uint uVar2;
  int iVar3;
  int iVar4;
  uint uVar5;
  uint uVar6;
  int iVar7;
  uint uVar8;
  uint uVar9;
  uint local_20;
  uint uStack_1c;
  
  iVar1 = **(int **)((int)this + 0x1c);
  uVar2 = **(uint **)((int)this + 0x20);
  if ((uVar2 != 0) && (*(uint *)((int)this + 0x38) < uVar2)) {
    *(uint *)((int)this + 0x38) = uVar2;
  }
  iVar3 = **(int **)((int)this + 0xc);
  iVar4 = *(int *)((int)this + 0x38);
  uVar5 = iVar4 - iVar3;
  uVar8 = (int)uVar5 >> 0x1f;
  if (param_4 == 0) {
    uStack_1c = 0;
    local_20 = 0;
LAB_10001d7d:
    uVar9 = local_20 + param_2;
    uVar6 = uStack_1c + param_3 + (uint)CARRY4(local_20,param_2);
    if (((uVar6 < uVar8) || ((uVar6 <= uVar8 && (uVar9 <= uVar5)))) &&
       (((uVar9 | uVar6) == 0 ||
        ((((param_5 & 1) == 0 || (iVar1 != 0)) && (((param_5 & 2) == 0 || (uVar2 != 0)))))))) {
      iVar7 = iVar3 + uVar9;
      if (((param_5 & 1) != 0) && (iVar1 != 0)) {
        **(int **)((int)this + 0x1c) = iVar7;
        **(int **)((int)this + 0x2c) = iVar4 - iVar7;
      }
      if (((param_5 & 2) != 0) && (uVar2 != 0)) {
        iVar1 = **(int **)((int)this + 0x30);
        iVar4 = **(int **)((int)this + 0x20);
        **(int **)((int)this + 0x10) = iVar3;
        **(int **)((int)this + 0x20) = iVar7;
        **(int **)((int)this + 0x30) = (iVar1 + iVar4) - iVar7;
      }
      *param_1 = uVar9;
      param_1[1] = uVar6;
      goto LAB_10001e11;
    }
  }
  else if (param_4 == 1) {
    if ((param_5 & 3) != 3) {
      if ((param_5 & 1) == 0) {
        if (((param_5 & 2) != 0) && ((uVar2 != 0 || (iVar3 == 0)))) {
          uStack_1c = (int)(uVar2 - iVar3) >> 0x1f;
          local_20 = uVar2 - iVar3;
          goto LAB_10001d7d;
        }
      }
      else if ((iVar1 != 0) || (iVar3 == 0)) {
        uStack_1c = iVar1 - iVar3 >> 0x1f;
        local_20 = iVar1 - iVar3;
        goto LAB_10001d7d;
      }
    }
  }
  else {
    uStack_1c = uVar8;
    local_20 = uVar5;
    if (param_4 == 2) goto LAB_10001d7d;
  }
  *param_1 = 0xffffffff;
  param_1[1] = 0xffffffff;
LAB_10001e11:
  param_1[2] = 0;
  param_1[3] = 0;
  *(undefined8 *)(param_1 + 4) = 0;
  return;
}



uint __fastcall FUN_10001e30(int param_1)

{
  byte **ppbVar1;
  byte *pbVar2;
  byte *pbVar3;
  byte *pbVar4;
  
  ppbVar1 = *(byte ***)(param_1 + 0x1c);
  pbVar2 = *ppbVar1;
  if (pbVar2 != (byte *)0x0) {
    if (pbVar2 < pbVar2 + **(int **)(param_1 + 0x2c)) {
      return (uint)*pbVar2;
    }
    pbVar3 = **(byte ***)(param_1 + 0x20);
    if ((pbVar3 != (byte *)0x0) && ((*(byte *)(param_1 + 0x3c) & 4) == 0)) {
      pbVar4 = *(byte **)(param_1 + 0x38);
      if (*(byte **)(param_1 + 0x38) < pbVar3) {
        pbVar4 = pbVar3;
      }
      if (pbVar2 < pbVar4) {
        *(byte **)(param_1 + 0x38) = pbVar4;
        pbVar2 = *ppbVar1;
        *ppbVar1 = pbVar2;
        **(int **)(param_1 + 0x2c) = (int)pbVar4 - (int)pbVar2;
        return (uint)***(byte ***)(param_1 + 0x1c);
      }
    }
  }
  return 0xffffffff;
}



// Library Function - Single Match
//  protected: virtual int __thiscall std::basic_stringbuf<char,struct std::char_traits<char>,class
// std::allocator<char> >::pbackfail(int)
// 
// Library: Visual Studio 2019 Release

int __thiscall
std::basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>::pbackfail
          (basic_stringbuf_char_struct_std__char_traits_char__class_std__allocator_char___ *this,
          int param_1)

{
  uint uVar1;
  
  uVar1 = **(uint **)(this + 0x1c);
  if (((uVar1 != 0) && (**(uint **)(this + 0xc) <= uVar1 && uVar1 != **(uint **)(this + 0xc))) &&
     ((param_1 == -1 || (((char)param_1 == *(char *)(uVar1 - 1) || (((byte)this[0x3c] & 2) == 0)))))
     ) {
    **(int **)(this + 0x2c) = **(int **)(this + 0x2c) + 1;
    **(int **)(this + 0x1c) = **(int **)(this + 0x1c) + -1;
    if (param_1 == -1) {
      param_1 = 0;
    }
    else {
      ***(char ***)(this + 0x1c) = (char)param_1;
    }
    return param_1;
  }
  return -1;
}



int __thiscall FUN_10001ef0(void *this,int param_1)

{
  void *_Src;
  char *pcVar1;
  void *pvVar2;
  int iVar3;
  uint uVar4;
  int iVar5;
  uint uVar6;
  uint local_c;
  
  if ((*(byte *)((int)this + 0x3c) & 2) != 0) {
    return -1;
  }
  if (param_1 == -1) {
    return 0;
  }
  uVar6 = **(uint **)((int)this + 0x20);
  uVar4 = **(int **)((int)this + 0x30) + uVar6;
  if ((uVar6 != 0) && (uVar6 < uVar4)) {
    pcVar1 = std::basic_streambuf<char,struct_std::char_traits<char>_>::_Pninc
                       ((basic_streambuf_char_struct_std__char_traits_char___ *)this);
    *pcVar1 = (char)param_1;
    *(uint *)((int)this + 0x38) = uVar6 + 1;
    return param_1;
  }
  _Src = **(void ***)((int)this + 0xc);
  uVar6 = -(uint)(uVar6 != 0) & uVar4 - (int)_Src;
  if (uVar6 < 0x20) {
    local_c = 0x20;
    pvVar2 = (void *)FUN_1000a4ab(0x20);
  }
  else {
    if (uVar6 < 0x3fffffff) {
      local_c = uVar6 * 2;
      if (local_c < 0x1000) {
        if (local_c == 0) {
          pvVar2 = (void *)0x0;
        }
        else {
          pvVar2 = (void *)FUN_1000a4ab(local_c);
        }
        goto LAB_10001fd5;
      }
    }
    else {
      if (0x7ffffffe < uVar6) {
        return -1;
      }
      local_c = 0x7fffffff;
    }
    uVar4 = local_c + 0x23;
    if (uVar4 <= local_c) {
      uVar4 = 0xffffffff;
    }
    iVar3 = FUN_1000a4ab(uVar4);
    if (iVar3 == 0) goto LAB_10002089;
    pvVar2 = (void *)(iVar3 + 0x23U & 0xffffffe0);
    *(int *)((int)pvVar2 - 4) = iVar3;
  }
LAB_10001fd5:
  memcpy(pvVar2,_Src,uVar6);
  iVar3 = uVar6 + (int)pvVar2;
  *(int *)((int)this + 0x38) = iVar3 + 1;
  **(void ***)((int)this + 0x10) = pvVar2;
  **(int **)((int)this + 0x20) = iVar3;
  **(int **)((int)this + 0x30) = (int)pvVar2 + (local_c - iVar3);
  if ((*(byte *)((int)this + 0x3c) & 4) == 0) {
    iVar3 = *(int *)((int)this + 0x38);
    iVar5 = (**(int **)((int)this + 0x1c) - (int)_Src) + (int)pvVar2;
    **(void ***)((int)this + 0xc) = pvVar2;
    **(int **)((int)this + 0x1c) = iVar5;
    **(int **)((int)this + 0x2c) = iVar3 - iVar5;
  }
  else {
    **(void ***)((int)this + 0xc) = pvVar2;
    **(undefined4 **)((int)this + 0x1c) = 0;
    **(void ***)((int)this + 0x2c) = pvVar2;
  }
  uVar4 = *(uint *)((int)this + 0x3c);
  if ((uVar4 & 1) != 0) {
    pvVar2 = _Src;
    if ((0xfff < uVar6) &&
       (pvVar2 = *(void **)((int)_Src + -4), 0x1f < (uint)((int)_Src + (-4 - (int)pvVar2)))) {
LAB_10002089:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
    uVar4 = *(uint *)((int)this + 0x3c);
  }
  *(uint *)((int)this + 0x3c) = uVar4 | 1;
  pcVar1 = std::basic_streambuf<char,struct_std::char_traits<char>_>::_Pninc
                     ((basic_streambuf_char_struct_std__char_traits_char___ *)this);
  *pcVar1 = (char)param_1;
  return param_1;
}



void __fastcall FUN_100020a0(undefined4 *param_1)

{
  void *pvVar1;
  void *pvVar2;
  int iVar3;
  
  *param_1 = std::basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
             vftable;
  if ((*(byte *)(param_1 + 0xf) & 1) != 0) {
    if (*(int *)param_1[8] == 0) {
      iVar3 = *(int *)param_1[0xb] + *(int *)param_1[7];
    }
    else {
      iVar3 = *(int *)param_1[0xc] + *(int *)param_1[8];
    }
    pvVar1 = *(void **)param_1[3];
    pvVar2 = pvVar1;
    if ((0xfff < (uint)(iVar3 - (int)pvVar1)) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  *(undefined4 *)param_1[3] = 0;
  *(undefined4 *)param_1[7] = 0;
  *(undefined4 *)param_1[0xb] = 0;
  *(undefined4 *)param_1[4] = 0;
  *(undefined4 *)param_1[8] = 0;
  *(undefined4 *)param_1[0xc] = 0;
  param_1[0xf] = param_1[0xf] & 0xfffffffe;
  param_1[0xe] = 0;
                    // WARNING: Could not recover jumptable at 0x1000213a. Too many branches
                    // WARNING: Treating indirect jump as call
  std::basic_streambuf<char,struct_std::char_traits<char>_>::
  _basic_streambuf_char_struct_std__char_traits_char___
            ((basic_streambuf_char_struct_std__char_traits_char___ *)param_1);
  return;
}



int * __thiscall FUN_10002150(void *this,byte param_1)

{
  int *piVar1;
  
  piVar1 = (int *)((int)this + -0x68);
  *(undefined ***)(*(int *)(*(int *)((int)this + -0x68) + 4) + -0x68 + (int)this) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)(*(int *)(*piVar1 + 4) + -0x6c + (int)this) = *(int *)(*piVar1 + 4) + -0x68;
  FUN_100020a0((undefined4 *)((int)this + -0x50));
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___
            ((basic_iostream_char_struct_std__char_traits_char___ *)((int)this + -0x48));
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___
            ((basic_ios_char_struct_std__char_traits_char___ *)this);
  if ((param_1 & 1) != 0) {
    FUN_1000a4db(piVar1);
  }
  return piVar1;
}



// Library Function - Single Match
//  public: virtual void * __thiscall std::basic_stringbuf<char,struct std::char_traits<char>,class
// std::allocator<char> >::`scalar deleting destructor'(unsigned int)
// 
// Library: Visual Studio 2019 Release

void * __thiscall
std::basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
_scalar_deleting_destructor_
          (basic_stringbuf_char_struct_std__char_traits_char__class_std__allocator_char___ *this,
          uint param_1)

{
  FUN_100020a0((undefined4 *)this);
  if ((param_1 & 1) != 0) {
    FUN_1000a4db(this);
  }
  return this;
}



void __fastcall FUN_100021e0(int **param_1)

{
  int *piVar1;
  bool bVar2;
  uint uVar3;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b720;
  local_10 = ExceptionList;
  uVar3 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  bVar2 = std::uncaught_exception();
  if (!bVar2) {
    std::basic_ostream<char,struct_std::char_traits<char>_>::_Osfx
              ((basic_ostream_char_struct_std__char_traits_char___ *)*param_1);
  }
  local_8 = 0;
  piVar1 = *(int **)(*(int *)(**param_1 + 4) + 0x38 + (int)*param_1);
  if (piVar1 != (int *)0x0) {
    (**(code **)(*piVar1 + 8))(uVar3);
  }
  ExceptionList = local_10;
  return;
}



int ** __thiscall FUN_10002250(void *this,void *param_1,int *param_2)

{
  uint uVar1;
  int *piVar2;
  void *pvVar3;
  code *pcVar4;
  uint uVar5;
  int iVar6;
  void *pvVar7;
  void *pvVar8;
  int **ppiVar9;
  uint uVar10;
  
  piVar2 = *(int **)((int)this + 0x14);
  if (param_2 <= piVar2) {
    pvVar7 = this;
    if ((int *)0xf < piVar2) {
                    // WARNING: Load size is inaccurate
      pvVar7 = *this;
    }
    *(int **)((int)this + 0x10) = param_2;
    memmove(pvVar7,param_1,(size_t)param_2);
    *(undefined *)((int)pvVar7 + (int)param_2) = 0;
    return (int **)this;
  }
  if ((int *)0x7fffffff < param_2) {
    FUN_100028c0();
    pcVar4 = (code *)swi(3);
    ppiVar9 = (int **)(*pcVar4)();
    return ppiVar9;
  }
  uVar10 = (uint)param_2 | 0xf;
  if (uVar10 < 0x80000000) {
    if ((int *)(0x7fffffff - ((uint)piVar2 >> 1)) < piVar2) {
      uVar10 = 0x7fffffff;
    }
    else {
      uVar1 = ((uint)piVar2 >> 1) + (int)piVar2;
      if (uVar10 < uVar1) {
        uVar10 = uVar1;
      }
    }
  }
  else {
    uVar10 = 0x7fffffff;
  }
  uVar1 = uVar10 + 1;
  if (uVar1 < 0x1000) {
    if (uVar1 == 0) {
      pvVar7 = (void *)0x0;
    }
    else {
      pvVar7 = (void *)FUN_1000a4ab(uVar1);
    }
  }
  else {
    uVar5 = uVar10 + 0x24;
    if (uVar5 <= uVar1) {
      uVar5 = 0xffffffff;
    }
    iVar6 = FUN_1000a4ab(uVar5);
    if (iVar6 == 0) goto LAB_10002368;
    pvVar7 = (void *)(iVar6 + 0x23U & 0xffffffe0);
    *(int *)((int)pvVar7 - 4) = iVar6;
  }
  *(int **)((int)this + 0x10) = param_2;
  *(uint *)((int)this + 0x14) = uVar10;
  memcpy(pvVar7,param_1,(size_t)param_2);
  *(undefined *)((int)pvVar7 + (int)param_2) = 0;
  if ((int *)0xf < piVar2) {
                    // WARNING: Load size is inaccurate
    pvVar3 = *this;
    pvVar8 = pvVar3;
    if ((0xfff < (int)piVar2 + 1U) &&
       (pvVar8 = *(void **)((int)pvVar3 + -4), 0x1f < (uint)((int)pvVar3 + (-4 - (int)pvVar8)))) {
LAB_10002368:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar8);
  }
  *(void **)this = pvVar7;
  return (int **)this;
}



void __fastcall FUN_10002380(int **param_1)

{
  int *piVar1;
  void *local_10;
  undefined *puStack_c;
  undefined4 uStack_8;
  
  uStack_8 = 0xffffffff;
  puStack_c = &LAB_1000b740;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  piVar1 = *(int **)(*(int *)(**param_1 + 4) + 0x38 + (int)*param_1);
  if (piVar1 != (int *)0x0) {
    (**(code **)(*piVar1 + 8))(DAT_10012024 ^ (uint)&stack0xfffffffc);
  }
  ExceptionList = local_10;
  return;
}



// WARNING: Could not reconcile some variable overlaps

int * __fastcall FUN_100023d0(int *param_1,char *param_2)

{
  char cVar1;
  uint uVar2;
  bool bVar3;
  int iVar4;
  int *piVar5;
  char *pcVar6;
  uint uVar7;
  int iVar8;
  __int64 _Var9;
  int local_34;
  int iStack_30;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b770;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  pcVar6 = param_2;
  do {
    cVar1 = *pcVar6;
    pcVar6 = pcVar6 + 1;
  } while (cVar1 != '\0');
  iVar8 = *param_1;
  uVar7 = (int)pcVar6 - (int)(param_2 + 1);
  iVar4 = *(int *)(iVar8 + 4);
  iStack_30 = *(int *)((int)param_1 + iVar4 + 0x24);
  uVar2 = *(uint *)((int)param_1 + iVar4 + 0x20);
  if ((iStack_30 < 0) ||
     ((iStack_30 < 1 && (((uVar2 == 0 || (iStack_30 < 0)) || ((iStack_30 < 1 && (uVar2 <= uVar7)))))
      ))) {
    iStack_30 = 0;
    local_34 = 0;
  }
  else {
    local_34 = uVar2 - uVar7;
    iStack_30 = iStack_30 - (uint)(uVar2 < uVar7);
  }
  piVar5 = *(int **)((int)param_1 + iVar4 + 0x38);
  if (piVar5 != (int *)0x0) {
    (**(code **)(*piVar5 + 4))();
    iVar8 = *param_1;
  }
  local_8 = 0;
  iVar4 = *(int *)(iVar8 + 4);
  if ((*(int *)((int)param_1 + iVar4 + 0xc) == 0) && (*(int *)((int)param_1 + iVar4 + 0x3c) != 0)) {
    piVar5 = *(int **)((int)param_1 + iVar4 + 0x3c);
    if (piVar5 != param_1) {
      std::basic_ostream<char,struct_std::char_traits<char>_>::flush
                ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5);
      iVar8 = *param_1;
    }
  }
  local_8 = 1;
  if (*(int *)(*(int *)(iVar8 + 4) + 0xc + (int)param_1) != 0) {
    std::basic_ios<char,struct_std::char_traits<char>_>::setstate
              ((basic_ios_char_struct_std__char_traits_char___ *)
               (*(int *)(*param_1 + 4) + (int)param_1),4,false);
    local_8 = 4;
    bVar3 = std::uncaught_exception();
    if (!bVar3) {
      std::basic_ostream<char,struct_std::char_traits<char>_>::_Osfx
                ((basic_ostream_char_struct_std__char_traits_char___ *)param_1);
    }
    local_8 = CONCAT31(local_8._1_3_,5);
    piVar5 = *(int **)(*(int *)(*param_1 + 4) + 0x38 + (int)param_1);
    if (piVar5 != (int *)0x0) {
      (**(code **)(*piVar5 + 8))();
    }
    ExceptionList = local_10;
    return param_1;
  }
  local_8 = 2;
  if ((*(uint *)(*(int *)(iVar8 + 4) + 0x14 + (int)param_1) & 0x1c0) != 0x40) {
    for (; (-1 < iStack_30 && ((0 < iStack_30 || (local_34 != 0)))); local_34 = local_34 + -1) {
      iVar4 = std::basic_streambuf<char,struct_std::char_traits<char>_>::sputc
                        (*(basic_streambuf_char_struct_std__char_traits_char___ **)
                          (*(int *)(*param_1 + 4) + 0x38 + (int)param_1),
                         *(char *)(*(int *)(*param_1 + 4) + 0x40 + (int)param_1));
      if (iVar4 == -1) {
        iVar4 = 4;
        goto LAB_1000257e;
      }
      iStack_30 = iStack_30 + -1 + (uint)(local_34 != 0);
    }
    iVar8 = *param_1;
  }
  _Var9 = std::basic_streambuf<char,struct_std::char_traits<char>_>::sputn
                    (*(basic_streambuf_char_struct_std__char_traits_char___ **)
                      (*(int *)(iVar8 + 4) + 0x38 + (int)param_1),param_2,(ulonglong)uVar7);
  if (((uint)_Var9 == uVar7) && ((int)((ulonglong)_Var9 >> 0x20) == 0)) {
    for (; (-1 < iStack_30 && ((0 < iStack_30 || (local_34 != 0)))); local_34 = local_34 + -1) {
      iVar4 = std::basic_streambuf<char,struct_std::char_traits<char>_>::sputc
                        (*(basic_streambuf_char_struct_std__char_traits_char___ **)
                          (*(int *)(*param_1 + 4) + 0x38 + (int)param_1),
                         *(char *)(*(int *)(*param_1 + 4) + 0x40 + (int)param_1));
      if (iVar4 == -1) goto LAB_1000256d;
      iStack_30 = iStack_30 + -1 + (uint)(local_34 != 0);
    }
    iVar4 = 0;
  }
  else {
LAB_1000256d:
    iVar4 = 4;
  }
LAB_1000257e:
  iVar8 = *(int *)(*param_1 + 4);
  *(undefined4 *)(iVar8 + 0x20 + (int)param_1) = 0;
  *(undefined4 *)(iVar8 + 0x24 + (int)param_1) = 0;
  piVar5 = (int *)FUN_100025b5(iVar4);
  return piVar5;
}



undefined * Catch_All_10002595(void)

{
  int unaff_EBP;
  
  std::basic_ios<char,struct_std::char_traits<char>_>::setstate
            ((basic_ios_char_struct_std__char_traits_char___ *)
             (*(int *)(**(int **)(unaff_EBP + -0x14) + 4) + (int)*(int **)(unaff_EBP + -0x14)),4,
             true);
  return &DAT_100025af;
}



void __fastcall FUN_100025b5(int param_1)

{
  int *piVar1;
  bool bVar2;
  int *unaff_EBX;
  int unaff_EBP;
  
  *(undefined4 *)(unaff_EBP + -4) = 1;
  std::basic_ios<char,struct_std::char_traits<char>_>::setstate
            ((basic_ios_char_struct_std__char_traits_char___ *)
             (*(int *)(*unaff_EBX + 4) + (int)unaff_EBX),param_1,false);
  *(undefined4 *)(unaff_EBP + -4) = 4;
  bVar2 = std::uncaught_exception();
  piVar1 = *(int **)(unaff_EBP + -0x30);
  if (!bVar2) {
    std::basic_ostream<char,struct_std::char_traits<char>_>::_Osfx
              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar1);
  }
  *(undefined *)(unaff_EBP + -4) = 5;
  piVar1 = *(int **)(*(int *)(*piVar1 + 4) + 0x38 + (int)piVar1);
  if (piVar1 != (int *)0x0) {
    (**(code **)(*piVar1 + 8))();
  }
  ExceptionList = *(void **)(unaff_EBP + -0xc);
  return;
}



undefined4 * __fastcall FUN_10002620(undefined4 *param_1,char *param_2,undefined4 *param_3)

{
  char cVar1;
  int iVar2;
  undefined4 *puVar3;
  undefined4 *puVar4;
  char *pcVar5;
  uint uVar6;
  uint local_18;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000b7a9;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  param_1[4] = 0;
  param_1[5] = 0xf;
  *(undefined *)param_1 = 0;
  local_8 = 0;
  pcVar5 = param_2;
  do {
    cVar1 = *pcVar5;
    pcVar5 = pcVar5 + 1;
  } while (cVar1 != '\0');
  FUN_100028d0(param_1,pcVar5 + (param_3[4] - (int)(param_2 + 1)));
  pcVar5 = param_2;
  do {
    cVar1 = *pcVar5;
    pcVar5 = pcVar5 + 1;
  } while (cVar1 != '\0');
  uVar6 = (int)pcVar5 - (int)(param_2 + 1);
  iVar2 = param_1[4];
  if ((uint)(param_1[5] - iVar2) < uVar6) {
    local_18 = (uint)param_2 & 0xffffff00;
    FUN_10002770(param_1,uVar6,local_18,param_2,uVar6);
  }
  else {
    param_1[4] = iVar2 + uVar6;
    puVar3 = param_1;
    if (0xf < (uint)param_1[5]) {
      puVar3 = (undefined4 *)*param_1;
    }
    memmove((void *)((int)puVar3 + iVar2),param_2,uVar6);
    *(undefined *)((int)(void *)((int)puVar3 + iVar2) + uVar6) = 0;
  }
  puVar3 = param_3;
  if (0xf < (uint)param_3[5]) {
    puVar3 = (undefined4 *)*param_3;
  }
  iVar2 = param_1[4];
  uVar6 = param_3[4];
  if (uVar6 <= (uint)(param_1[5] - iVar2)) {
    param_1[4] = iVar2 + uVar6;
    puVar4 = param_1;
    if (0xf < (uint)param_1[5]) {
      puVar4 = (undefined4 *)*param_1;
    }
    memmove((void *)((int)puVar4 + iVar2),puVar3,uVar6);
    *(undefined *)((int)(void *)((int)puVar4 + iVar2) + uVar6) = 0;
    ExceptionList = local_10;
    return param_1;
  }
  param_3 = (undefined4 *)((uint)param_3 & 0xffffff00);
  FUN_10002770(param_1,uVar6,param_3,puVar3,uVar6);
  ExceptionList = local_10;
  return param_1;
}



void ** __thiscall
FUN_10002770(void *this,uint param_1,undefined4 param_2,void *param_3,size_t param_4)

{
  size_t _Size;
  uint uVar1;
  void *_Src;
  code *pcVar2;
  uint uVar3;
  uint uVar4;
  int iVar5;
  void **ppvVar6;
  void *_Dst;
  uint uVar7;
  void *pvVar8;
  
  _Size = *(size_t *)((int)this + 0x10);
  if (0x7fffffff - _Size < param_1) {
    FUN_100028c0();
    pcVar2 = (code *)swi(3);
    ppvVar6 = (void **)(*pcVar2)();
    return ppvVar6;
  }
  uVar1 = *(uint *)((int)this + 0x14);
  uVar7 = _Size + param_1 | 0xf;
  if (uVar7 < 0x80000000) {
    if (0x7fffffff - (uVar1 >> 1) < uVar1) {
      uVar7 = 0x7fffffff;
    }
    else {
      uVar3 = (uVar1 >> 1) + uVar1;
      if (uVar7 < uVar3) {
        uVar7 = uVar3;
      }
    }
  }
  else {
    uVar7 = 0x7fffffff;
  }
  uVar3 = uVar7 + 1;
  if (uVar3 < 0x1000) {
    if (uVar3 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_1000a4ab(uVar3);
    }
  }
  else {
    uVar4 = uVar7 + 0x24;
    if (uVar4 <= uVar3) {
      uVar4 = 0xffffffff;
    }
    iVar5 = FUN_1000a4ab(uVar4);
    if (iVar5 == 0) goto LAB_10002884;
    _Dst = (void *)(iVar5 + 0x23U & 0xffffffe0);
    *(int *)((int)_Dst - 4) = iVar5;
  }
  *(size_t *)((int)this + 0x10) = _Size + param_1;
  *(uint *)((int)this + 0x14) = uVar7;
  pvVar8 = (void *)((int)_Dst + _Size);
  if (uVar1 < 0x10) {
    memcpy(_Dst,this,_Size);
    memcpy(pvVar8,param_3,param_4);
    *(undefined *)(param_4 + (int)pvVar8) = 0;
    *(void **)this = _Dst;
    return (void **)this;
  }
                    // WARNING: Load size is inaccurate
  _Src = *this;
  memcpy(_Dst,_Src,_Size);
  memcpy(pvVar8,param_3,param_4);
  *(undefined *)(param_4 + (int)pvVar8) = 0;
  pvVar8 = _Src;
  if ((uVar1 + 1 < 0x1000) ||
     (pvVar8 = *(void **)((int)_Src + -4), (uint)((int)_Src + (-4 - (int)pvVar8)) < 0x20)) {
    FUN_1000a4db(pvVar8);
    *(void **)this = _Dst;
    return (void **)this;
  }
LAB_10002884:
                    // WARNING: Subroutine does not return
  _invalid_parameter_noinfo_noreturn();
}



void FUN_100028c0(void)

{
  code *pcVar1;
  
  std::_Xlength_error("string too long");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}



void __thiscall FUN_100028d0(void *this,void *param_1)

{
  uint uVar1;
  void *pvVar2;
  void *_Src;
  code *pcVar3;
  uint uVar4;
  int iVar5;
  void *_Dst;
  uint uVar6;
  void *pvVar7;
  void *pvVar8;
  
  pvVar8 = *(void **)((int)this + 0x10);
  if (param_1 < pvVar8) {
    return;
  }
  pvVar2 = *(void **)((int)this + 0x14);
  if (pvVar2 == param_1) {
    return;
  }
  if (pvVar2 < param_1) {
    if (0x7fffffffU - (int)pvVar8 < (uint)((int)param_1 - (int)pvVar8)) {
      FUN_100028c0();
      pcVar3 = (code *)swi(3);
      (*pcVar3)();
      return;
    }
    uVar6 = (uint)param_1 | 0xf;
    if (uVar6 < 0x80000000) {
      if ((void *)(0x7fffffff - ((uint)pvVar2 >> 1)) < pvVar2) {
        uVar6 = 0x7fffffff;
      }
      else {
        uVar1 = ((uint)pvVar2 >> 1) + (int)pvVar2;
        if (uVar6 < uVar1) {
          uVar6 = uVar1;
        }
      }
    }
    else {
      uVar6 = 0x7fffffff;
    }
    uVar1 = uVar6 + 1;
    if (uVar1 < 0x1000) {
      if (uVar1 == 0) {
        _Dst = (void *)0x0;
      }
      else {
        _Dst = (void *)FUN_1000a4ab(uVar1);
      }
    }
    else {
      uVar4 = uVar6 + 0x24;
      if (uVar4 <= uVar1) {
        uVar4 = 0xffffffff;
      }
      iVar5 = FUN_1000a4ab(uVar4);
      if (iVar5 == 0) goto LAB_10002a58;
      _Dst = (void *)(iVar5 + 0x23U & 0xffffffe0);
      *(int *)((int)_Dst - 4) = iVar5;
    }
    *(void **)((int)this + 0x10) = param_1;
    *(uint *)((int)this + 0x14) = uVar6;
    if (pvVar2 < (void *)0x10) {
      memcpy(_Dst,this,(int)pvVar8 + 1U);
      *(void **)this = _Dst;
      *(void **)((int)this + 0x10) = pvVar8;
      return;
    }
                    // WARNING: Load size is inaccurate
    _Src = *this;
    memcpy(_Dst,_Src,(int)pvVar8 + 1U);
    pvVar7 = _Src;
    if (((int)pvVar2 + 1U < 0x1000) ||
       (pvVar7 = *(void **)((int)_Src + -4), (uint)((int)_Src + (-4 - (int)pvVar7)) < 0x20)) {
      FUN_1000a4db(pvVar7);
      *(void **)this = _Dst;
      *(void **)((int)this + 0x10) = pvVar8;
      return;
    }
  }
  else {
    if ((void *)0xf < param_1) {
      return;
    }
    if (pvVar2 < (void *)0x10) {
      return;
    }
                    // WARNING: Load size is inaccurate
    pvVar2 = *this;
    memcpy(this,pvVar2,(int)pvVar8 + 1);
    pvVar8 = pvVar2;
    if ((*(int *)((int)this + 0x14) + 1U < 0x1000) ||
       (pvVar8 = *(void **)((int)pvVar2 + -4), (uint)((int)pvVar2 + (-4 - (int)pvVar8)) < 0x20)) {
      FUN_1000a4db(pvVar8);
      *(undefined4 *)((int)this + 0x14) = 0xf;
      return;
    }
  }
LAB_10002a58:
                    // WARNING: Subroutine does not return
  _invalid_parameter_noinfo_noreturn();
}



void __thiscall FUN_10002a64(void *this,byte param_1)

{
  FUN_10002150((void *)((int)this - *(int *)((int)this + -4)),param_1);
  return;
}



void __fastcall FUN_10002a70(longlong *param_1)

{
  uint uVar1;
  uint extraout_ECX;
  uint uVar2;
  undefined8 uVar3;
  ulonglong uVar4;
  longlong lVar5;
  
  uVar3 = _Query_perf_frequency();
  uVar2 = (uint)((ulonglong)uVar3 >> 0x20);
  uVar1 = (uint)uVar3;
  uVar3 = _Query_perf_counter();
  uVar3 = __alldvrm((uint)uVar3,(uint)((ulonglong)uVar3 >> 0x20),uVar1,uVar2);
  uVar4 = __allmul(extraout_ECX,uVar1,1000000000,0);
  lVar5 = __alldiv((uint)uVar4,(uint)(uVar4 >> 0x20),uVar1,uVar2);
  uVar4 = __allmul((uint)uVar3,(uint)((ulonglong)uVar3 >> 0x20),1000000000,0);
  *param_1 = lVar5 + uVar4;
  return;
}



void __fastcall FUN_10002af0(void *param_1,undefined4 *param_2,undefined4 param_3,int *param_4)

{
  void **ppvVar1;
  code *pcVar2;
  undefined *puVar3;
  void *pvVar4;
  int *piVar5;
  undefined4 *puVar6;
  int *piVar7;
  uint uVar8;
  int iVar9;
  undefined4 *local_50;
  int *local_44;
  undefined4 *local_40;
  void *local_3c;
  void *pvStack_38;
  void *pvStack_34;
  void *pvStack_30;
  undefined4 local_2c;
  uint uStack_28;
  uint local_24;
  undefined *puStack_20;
  void *local_1c;
  undefined *puStack_18;
  undefined4 local_14;
  
  puStack_20 = &stack0xfffffffc;
  local_14 = 0xffffffff;
  puStack_18 = &LAB_1000b7e0;
  local_1c = ExceptionList;
  local_24 = DAT_10012024 ^ (uint)&stack0xfffffff0;
  ExceptionList = &local_1c;
  local_44 = (int *)0x0;
  local_40 = param_2;
  if (0xf < (uint)param_2[5]) {
    local_40 = (undefined4 *)*param_2;
  }
  puVar3 = &stack0xfffffffc;
  if ((param_2[4] == 0) ||
     (pvVar4 = memchr(local_40,0x7c,param_2[4]), puVar3 = puStack_20, pvVar4 == (void *)0x0)) {
    puStack_20 = puVar3;
    iVar9 = -1;
  }
  else {
    iVar9 = (int)pvVar4 - (int)local_40;
  }
  if (iVar9 != -1) {
    do {
      local_2c = 0;
      uStack_28 = 0xf;
      local_3c = (void *)((uint)local_3c & 0xffffff00);
      if ((int *)param_2[4] < local_44) goto LAB_10002d7e;
      piVar5 = (int *)((int)(int *)param_2[4] - (int)local_44);
      piVar7 = (int *)(iVar9 - (int)local_44);
      if (piVar5 < (int *)(iVar9 - (int)local_44)) {
        piVar7 = piVar5;
      }
      puVar6 = param_2;
      if (0xf < (uint)param_2[5]) {
        puVar6 = (undefined4 *)*param_2;
      }
      FUN_10002250(&local_3c,(void *)((int)puVar6 + (int)local_44),piVar7);
      pvVar4 = local_3c;
      local_14 = 0;
      ppvVar1 = (void **)param_4[1];
      if ((void **)param_4[2] == ppvVar1) {
        FUN_100044f0(param_4,ppvVar1,&local_3c);
        uVar8 = uStack_28;
      }
      else {
        local_3c = (void *)((uint)local_3c & 0xffffff00);
        *ppvVar1 = pvVar4;
        ppvVar1[1] = pvStack_38;
        ppvVar1[2] = pvStack_34;
        ppvVar1[3] = pvStack_30;
        *(ulonglong *)(ppvVar1 + 4) = CONCAT44(uStack_28,local_2c);
        param_4[1] = param_4[1] + 0x18;
        uVar8 = 0xf;
      }
      local_14 = 0xffffffff;
      if (0xf < uVar8) {
        pvVar4 = local_3c;
        if ((0xfff < uVar8 + 1) &&
           (pvVar4 = *(void **)((int)local_3c + -4),
           0x1f < (uint)((int)local_3c + (-4 - (int)pvVar4)))) goto LAB_10002d78;
        FUN_1000a4db(pvVar4);
      }
      local_44 = (int *)(iVar9 + 1);
      local_50 = param_2;
      if (0xf < (uint)param_2[5]) {
        local_50 = (undefined4 *)*param_2;
      }
      piVar7 = (int *)param_2[4];
      if (local_44 < piVar7) {
        piVar5 = (int *)((int)piVar7 - (int)local_44);
        pvVar4 = memchr((void *)((int)local_50 + (int)local_44),0x7c,(size_t)piVar5);
        if (pvVar4 == (void *)0x0) goto LAB_10002c81;
        iVar9 = (int)pvVar4 - (int)local_50;
      }
      else {
        piVar5 = (int *)((int)piVar7 - (int)local_44);
LAB_10002c81:
        iVar9 = -1;
      }
    } while (iVar9 != -1);
    local_2c = 0;
    uStack_28 = 0xf;
    local_3c = (void *)((uint)local_3c & 0xffffff00);
    if (piVar7 < local_44) {
LAB_10002d7e:
      uStack_28 = 0xf;
      local_2c = 0;
      FUN_100044e0();
      pcVar2 = (code *)swi(3);
      (*pcVar2)();
      return;
    }
    if (piVar5 < piVar7) {
      piVar7 = piVar5;
    }
    if (0xf < (uint)param_2[5]) {
      param_2 = (undefined4 *)*param_2;
    }
    FUN_10002250(&local_3c,(void *)((int)param_2 + (int)local_44),piVar7);
    pvVar4 = local_3c;
    local_14 = 1;
    ppvVar1 = (void **)param_4[1];
    if ((void **)param_4[2] == ppvVar1) {
      FUN_100044f0(param_4,ppvVar1,&local_3c);
      uVar8 = uStack_28;
    }
    else {
      local_3c = (void *)((uint)local_3c & 0xffffff00);
      *ppvVar1 = pvVar4;
      ppvVar1[1] = pvStack_38;
      ppvVar1[2] = pvStack_34;
      ppvVar1[3] = pvStack_30;
      *(ulonglong *)(ppvVar1 + 4) = CONCAT44(uStack_28,local_2c);
      param_4[1] = param_4[1] + 0x18;
      uVar8 = 0xf;
    }
    local_14 = 0xffffffff;
    if (0xf < uVar8) {
      pvVar4 = local_3c;
      if ((0xfff < uVar8 + 1) &&
         (pvVar4 = *(void **)((int)local_3c + -4), 0x1f < (uint)((int)local_3c + (-4 - (int)pvVar4))
         )) {
LAB_10002d78:
        local_14 = 0xffffffff;
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar4);
    }
  }
  FUN_100043a0(param_1,(void **)(*param_4 + 0x18));
  ExceptionList = local_1c;
  ___security_check_cookie_4(local_24 ^ (uint)&stack0xfffffff0);
  return;
}



undefined4 _Java_com_vue_browserlock_win_natives_NativeProxy_getAllProcessIDs_8(int *param_1)

{
  code *pcVar1;
  void *pvVar2;
  void *pvVar3;
  undefined4 uVar4;
  uint uVar5;
  uint uVar6;
  bool bVar7;
  bool bVar8;
  void *local_14;
  int local_10;
  int local_c;
  undefined4 local_8;
  
                    // 0x2d90  7
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getAllProcessIDs@8
  local_14 = (void *)0x0;
  local_10 = 0;
  local_c = 0;
  FUN_10006720(&local_14);
  pvVar2 = local_14;
  uVar6 = local_10 - (int)local_14 >> 2;
  local_8 = (**(code **)(*param_1 + 0x2d0))(param_1,uVar6);
  pvVar3 = (void *)FUN_1000a4e9(-(uint)((int)((ulonglong)uVar6 * 8 >> 0x20) != 0) |
                                (uint)((ulonglong)uVar6 * 8));
  uVar4 = local_8;
  uVar5 = 0;
  if (0 < (int)uVar6) {
    bVar7 = false;
    bVar8 = uVar6 == 0;
    do {
      if (bVar7 || bVar8) {
        FUN_10004460();
        pcVar1 = (code *)swi(3);
        uVar4 = (*pcVar1)();
        return uVar4;
      }
      *(undefined4 *)((int)pvVar3 + uVar5 * 8) = *(undefined4 *)((int)pvVar2 + uVar5 * 4);
      *(undefined4 *)((int)pvVar3 + uVar5 * 8 + 4) = 0;
      uVar5 = uVar5 + 1;
      bVar7 = uVar6 < uVar5;
      bVar8 = uVar6 == uVar5;
    } while (!bVar8 && (int)uVar5 <= (int)uVar6);
  }
  (**(code **)(*param_1 + 0x350))(param_1,local_8,0,uVar6,pvVar3);
  free(pvVar3);
  if (pvVar2 != (void *)0x0) {
    pvVar3 = pvVar2;
    if (0xfff < (local_c - (int)pvVar2 & 0xfffffffcU)) {
      pvVar3 = *(void **)((int)pvVar2 + -4);
      if (0x1f < (uint)((int)pvVar2 + (-4 - (int)pvVar3))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar3);
  }
  return uVar4;
}



// WARNING: Removing unreachable block (ram,0x100031cf)
// WARNING: Removing unreachable block (ram,0x10003205)
// WARNING: Removing unreachable block (ram,0x10003215)

void _Java_com_vue_browserlock_win_natives_NativeProxy_getBackgroundProcessData_24
               (int *param_1,undefined4 param_2,DWORD param_3,undefined4 param_4,int param_5,
               byte param_6)

{
  char cVar1;
  void *pvVar2;
  undefined4 uVar3;
  char *pcVar4;
  int *piVar5;
  char *pcVar6;
  undefined4 extraout_ECX;
  undefined4 ****ppppuVar7;
  uint unaff_EBX;
  undefined4 unaff_EDI;
  undefined8 uVar8;
  undefined4 *in_stack_fffffe10;
  undefined auStack_1d8 [4];
  undefined4 uStack_1d4;
  undefined4 *puVar9;
  undefined *puVar10;
  int iStack_1a4;
  uint local_1a0;
  int iStack_19c;
  undefined8 local_198;
  int iStack_18c;
  int local_188 [2];
  undefined4 auStack_180 [2];
  basic_iostream_char_struct_std__char_traits_char___ abStack_178 [72];
  basic_ios_char_struct_std__char_traits_char___ abStack_130 [68];
  undefined uStack_ec;
  void *pvStack_e8;
  void *pvStack_e0;
  undefined4 uStack_dc;
  undefined4 local_d8;
  undefined4 ****ppppuStack_d4;
  void *pvStack_d0;
  uint uStack_cc;
  uint uStack_c4;
  uint uStack_c0;
  uint uStack_bc;
  void *pvStack_b0;
  undefined local_a8 [8];
  undefined4 uStack_a0;
  uint uStack_9c;
  undefined auStack_98 [8];
  DWORD local_90 [29];
  uint uStack_1c;
  uint uStack_14;
  uint local_c;
  
                    // 0x2e80  8
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getBackgroundProcessData@24
  local_c = DAT_10012024 ^ (uint)&iStack_1a4;
  local_198._4_4_ = param_4;
  local_1a0 = local_1a0 & 0xffffff00 | (uint)param_6;
  if (param_5 != 0) {
    puVar9 = &local_d8;
    pvVar2 = (void *)FUN_100067b0(local_90,param_3,param_6);
    FUN_10005b30(pvVar2,(undefined *)puVar9);
    (**(code **)(*param_1 + 0x29c))();
    if (0xf < uStack_cc) {
      pvVar2 = pvStack_e0;
      if ((0xfff < uStack_cc + 1) &&
         (pvVar2 = *(void **)((int)pvStack_e0 + -4),
         0x1f < (uint)((int)pvStack_e0 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar2);
    }
    pvStack_d0 = (void *)0x0;
    uStack_cc = 0xf;
    pvStack_e0 = (void *)((uint)pvStack_e0 & 0xffffff00);
    FUN_100059c0((int)auStack_98);
    ___security_check_cookie_4(uStack_14 ^ (uint)&stack0xfffffe54);
    return;
  }
  FUN_10001b00(local_188);
  FUN_10002a70(&local_198);
  puVar10 = local_a8;
  pvVar2 = (void *)FUN_100067b0(local_90,param_3,(char)local_1a0);
  FUN_10005b30(pvVar2,puVar10);
  (**(code **)(*param_1 + 0x29c))();
  if (0xf < uStack_9c) {
    pvVar2 = pvStack_b0;
    if ((0xfff < uStack_9c + 1) &&
       (pvVar2 = *(void **)((int)pvStack_b0 + -4),
       0x1f < (uint)((int)pvStack_b0 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  uStack_a0 = 0;
  uStack_9c = 0xf;
  pvStack_b0 = (void *)((uint)pvStack_b0 & 0xffffff00);
  FUN_100059c0((int)auStack_98);
  FUN_10002a70((longlong *)&stack0xfffffe58);
  uVar8 = __alldiv(unaff_EBX - local_1a0,(iStack_1a4 - iStack_19c) - (uint)(unaff_EBX < local_1a0),
                   1000000,0);
  uVar3 = (undefined4)uVar8;
  pcVar4 = (char *)(**(code **)(*param_1 + 0x2a4))();
  uStack_dc = 0;
  local_d8 = 0xf;
  uStack_ec = 0;
  pcVar6 = pcVar4;
  do {
    cVar1 = *pcVar6;
    pcVar6 = pcVar6 + 1;
  } while (cVar1 != '\0');
  FUN_10002250(&uStack_ec,pcVar4,(int *)(pcVar6 + -(int)(pcVar4 + 1)));
  iStack_1a4 = 0;
  FUN_10002af0(&ppppuStack_d4,(undefined4 *)&uStack_ec,extraout_ECX,(int *)&stack0xfffffe54);
  piVar5 = FUN_100023d0(&iStack_18c,"Time taken to fetch the process details for ");
  ppppuVar7 = &ppppuStack_d4;
  if (0xf < uStack_c0) {
    ppppuVar7 = ppppuStack_d4;
  }
  uStack_1d4 = 0x1000310e;
  piVar5 = FUN_10004740(piVar5,(char *)ppppuVar7,uStack_c4);
  piVar5 = FUN_100023d0(piVar5," process from native is: processFetchTime=");
  piVar5 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                            ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,
                             CONCAT44(unaff_EDI,uVar3));
  FUN_100023d0(piVar5," ms");
  auStack_1d8[0] = 0;
  FUN_10002250(auStack_1d8,&DAT_1000d57c,(int *)0x4);
  FUN_10001a40(&local_198,&stack0xfffffe10);
  FUN_10005830(in_stack_fffffe10);
  if (0xf < uStack_bc) {
    pvVar2 = pvStack_d0;
    if ((0xfff < uStack_bc + 1) &&
       (pvVar2 = *(void **)((int)pvStack_d0 + -4),
       0x1f < (uint)((int)pvStack_d0 + (-4 - (int)pvVar2)))) goto LAB_1000324d;
    FUN_1000a4db(pvVar2);
  }
  pvStack_d0 = (void *)((uint)pvStack_d0 & 0xffffff00);
  uStack_bc = 0xf;
  uStack_c0 = 0;
  if ((undefined4 ****)0xf < ppppuStack_d4) {
    pvVar2 = pvStack_e8;
    if (((char *)0xfff < (char *)((int)ppppuStack_d4 + 1)) &&
       (pvVar2 = *(void **)((int)pvStack_e8 + -4),
       0x1f < (uint)((int)pvStack_e8 + (-4 - (int)pvVar2)))) {
LAB_1000324d:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  local_d8 = 0;
  ppppuStack_d4 = (undefined4 ****)0xf;
  pvStack_e8 = (void *)((uint)pvStack_e8 & 0xffffff00);
  *(undefined ***)((int)&local_198 + *(int *)((int)local_198 + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)&iStack_19c + *(int *)((int)local_198 + 4)) = *(int *)((int)local_198 + 4) + -0x68;
  FUN_100020a0(auStack_180);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(abStack_178);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(abStack_130);
  ___security_check_cookie_4(uStack_1c ^ (uint)&stack0xfffffe4c);
  return;
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address

void _Java_com_vue_browserlock_win_natives_NativeProxy_queryCIMV2Object_16
               (int *param_1,undefined4 param_2,uint param_3,uint param_4)

{
  char cVar1;
  short sVar2;
  char *pcVar3;
  char *pcVar4;
  size_t sVar5;
  char *pcVar6;
  int *piVar7;
  size_t _MaxCount;
  void *pvVar8;
  void *in_stack_ffffff60;
  int *piStack_88;
  uint uStack_84;
  char *pcStack_80;
  int *piStack_7c;
  undefined auStack_4c [4];
  uint local_48;
  uint local_44;
  int *local_40;
  void *apvStack_3c [3];
  undefined auStack_30 [16];
  undefined4 uStack_20;
  undefined4 uStack_1c;
  uint local_c;
  
                    // 0x32e0  20
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_queryCIMV2Object@16
  local_c = DAT_10012024 ^ (uint)auStack_4c;
  local_40 = param_1;
  local_44 = param_3;
  local_48 = param_4;
  pcVar3 = (char *)(**(code **)(*param_1 + 0x2a4))();
  uStack_20 = 0;
  uStack_1c = 0xf;
  auStack_30[0] = 0;
  pcVar6 = pcVar3;
  do {
    cVar1 = *pcVar6;
    pcVar6 = pcVar6 + 1;
  } while (cVar1 != '\0');
  FUN_10002250(auStack_30,pcVar3,(int *)(pcVar6 + -(int)(pcVar3 + 1)));
  pcVar4 = (char *)(**(code **)(*param_1 + 0x2a4))();
  local_44 = 0;
  local_40 = (int *)0xf;
  pcVar6 = pcVar4;
  do {
    cVar1 = *pcVar6;
    pcVar6 = pcVar6 + 1;
  } while (cVar1 != '\0');
  piStack_7c = (int *)0x10003388;
  FUN_10002250(&stack0xffffffac,pcVar4,(int *)(pcVar6 + -(int)(pcVar4 + 1)));
  uStack_84 = param_4;
  if (_DAT_100126c0 == 0) {
    _DAT_100126c0 = FUN_1000a4ab(1);
    uStack_84 = param_4;
  }
  FUN_100043a0(&piStack_88,(void **)&stack0xffffffac);
  FUN_100043a0(&stack0xffffff60,apvStack_3c);
  FUN_100011e0(in_stack_ffffff60);
  piStack_7c = param_1;
  pcStack_80 = (char *)0x100033d7;
  (**(code **)(*param_1 + 0x2a8))();
  piStack_88 = param_1;
  pcStack_80 = pcVar4;
  (**(code **)(*param_1 + 0x2a8))();
  piVar7 = piStack_7c;
  do {
    sVar2 = *(short *)piVar7;
    piVar7 = (int *)((int)piVar7 + 2);
  } while (sVar2 != 0);
  _MaxCount = (int)piVar7 - ((int)piStack_7c + 2) >> 1;
  sVar5 = wcstombs((char *)0x0,(wchar_t *)piStack_7c,_MaxCount);
  pcVar6 = (char *)FUN_1000a4e9(sVar5 + 1);
  wcstombs(pcVar6,(wchar_t *)piStack_7c,_MaxCount);
  pcVar6[sVar5] = '\0';
  (**(code **)(*param_1 + 0x29c))();
  free(pcVar6);
  if (0xf < param_3) {
    pcVar6 = pcVar3;
    if (0xfff < param_3 + 1) {
      pcVar6 = *(char **)(pcVar3 + -4);
      if ((char *)0x1f < pcVar3 + (-4 - (int)pcVar6)) goto LAB_100034a9;
    }
    FUN_1000a4db(pcVar6);
  }
  if (0xf < local_48) {
    pvVar8 = (void *)0x0;
    if (0xfff < local_48 + 1) {
      pvVar8 = pvRamfffffffc;
      if (0x1f < 0xfffffffcU - (int)pvRamfffffffc) {
LAB_100034a9:
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar8);
  }
  piStack_88 = (int *)0x100034c9;
  ___security_check_cookie_4(local_44 ^ (uint)&uStack_84);
  return;
}



uint _Java_com_vue_browserlock_win_natives_NativeProxy_terminateProcess_16
               (undefined4 param_1,undefined4 param_2,DWORD param_3)

{
  HANDLE hObject;
  undefined *puVar1;
  HMODULE hModule;
  FARPROC pFVar2;
  int iVar3;
  byte *pbVar4;
  byte bVar5;
  uint in_stack_ffffffc4;
  undefined4 *puVar6;
  undefined local_24 [8];
  undefined4 uStack_1c;
  char *lpProcName;
  
                    // 0x34d0  25
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_terminateProcess@16
  uStack_1c = 0x100034e7;
  hObject = OpenProcess(0x1fffff,0,param_3);
  if (hObject == (HANDLE)0x0) {
    puVar1 = (undefined *)FUN_1000a4ab(1);
    *puVar1 = 0;
    return (uint)puVar1 & 0xffffff00;
  }
  lpProcName = "NtTerminateProcess";
  hModule = GetModuleHandleA("ntdll");
  pFVar2 = GetProcAddress(hModule,lpProcName);
  if (pFVar2 == (FARPROC)0x0) {
    local_24[0] = 0;
    FUN_10002250(local_24,"ERROR",(int *)0x5);
    puVar6 = (undefined4 *)(in_stack_ffffffc4 & 0xffffff00);
    FUN_10002250(&stack0xffffffc4,"Error finding function: NtTerminateProcess",(int *)0x2a);
    FUN_10005830(puVar6);
    bVar5 = 0;
  }
  else {
    iVar3 = (*pFVar2)();
    bVar5 = 1;
    if (iVar3 < 0) {
      bVar5 = 0;
    }
  }
  CloseHandle(hObject);
  pbVar4 = (byte *)FUN_1000a4ab(1);
  *pbVar4 = bVar5;
  return (uint)pbVar4 & 0xffffff00 | (uint)bVar5;
}



// WARNING: Could not reconcile some variable overlaps

void _Java_com_vue_browserlock_win_natives_NativeProxy_suspendProcess_16
               (undefined4 param_1,undefined4 param_2,DWORD param_3)

{
  HANDLE hObject;
  HMODULE hModule;
  FARPROC pFVar1;
  uint uVar2;
  int iVar3;
  int *piVar4;
  char *pcVar5;
  uint extraout_ECX;
  uint extraout_ECX_00;
  void *pvVar6;
  uint uVar7;
  undefined4 *****pppppuVar8;
  char cVar9;
  undefined8 uVar10;
  undefined8 uVar11;
  ulonglong uVar12;
  ulonglong uVar13;
  longlong lVar14;
  longlong lVar15;
  __int64 _Var16;
  uint in_stack_fffffec8;
  undefined4 *puVar17;
  undefined4 *in_stack_fffffecc;
  uint local_fc;
  undefined8 local_f8;
  uint local_f0;
  DWORD local_ec;
  undefined4 local_e8;
  int local_dc [2];
  undefined auStack_d4 [12];
  int local_c8 [2];
  undefined4 auStack_c0 [2];
  basic_iostream_char_struct_std__char_traits_char___ abStack_b8 [72];
  basic_ios_char_struct_std__char_traits_char___ abStack_70 [76];
  undefined4 *****local_24;
  void *pvStack_20;
  uint uStack_14;
  uint uStack_10;
  uint local_c;
  
                    // 0x35a0  24
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_suspendProcess@16
  local_c = DAT_10012024 ^ (uint)&local_fc;
  local_ec = param_3;
  FUN_10001b00(local_dc + 1);
  uVar10 = _Query_perf_frequency();
  uVar7 = (uint)((ulonglong)uVar10 >> 0x20);
  uVar2 = (uint)uVar10;
  uVar11 = _Query_perf_counter();
  local_fc = (uint)((ulonglong)uVar10 >> 0x20);
  local_f8._0_4_ = (uint)uVar10;
  uVar11 = __alldvrm((uint)uVar11,(uint)((ulonglong)uVar11 >> 0x20),uVar2,uVar7);
  local_fc = (uint)((ulonglong)uVar10 >> 0x20);
  local_f8._0_4_ = (uint)uVar10;
  uVar12 = __allmul((uint)uVar11,(uint)((ulonglong)uVar11 >> 0x20),1000000000,0);
  local_fc = (uint)((ulonglong)uVar10 >> 0x20);
  local_f8._0_4_ = (uint)uVar10;
  local_f8._4_4_ = (uint)(uVar12 >> 0x20);
  uVar13 = __allmul(extraout_ECX,uVar7,1000000000,0);
  local_fc = (uint)((ulonglong)uVar10 >> 0x20);
  local_f8._0_4_ = (uint)uVar10;
  lVar14 = __alldiv((uint)uVar13,(uint)(uVar13 >> 0x20),(uint)local_f8,local_fc);
  local_fc = (uint)((ulonglong)uVar10 >> 0x20);
  local_f8._0_4_ = (uint)uVar10;
  lVar14 = lVar14 + (uVar12 & 0xffffffff | (ulonglong)local_f8._4_4_ << 0x20);
  hObject = OpenProcess(0x1fffff,0,local_ec);
  local_fc = (uint)((ulonglong)uVar10 >> 0x20);
  local_f8._0_4_ = (uint)uVar10;
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  if (hObject == (HANDLE)0x0) {
    local_fc = 0;
  }
  else {
    pcVar5 = "NtSuspendProcess";
    hModule = GetModuleHandleA("ntdll");
    local_fc = (uint)((ulonglong)uVar10 >> 0x20);
    local_f8._0_4_ = (uint)uVar10;
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    pFVar1 = GetProcAddress(hModule,pcVar5);
    local_fc = (uint)((ulonglong)uVar10 >> 0x20);
    local_f8._0_4_ = (uint)uVar10;
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    if (pFVar1 == (FARPROC)0x0) {
      FUN_10002250(&stack0xfffffee0,"ERROR",(int *)0x5);
      local_fc = (uint)((ulonglong)uVar10 >> 0x20);
      local_f8._0_4_ = (uint)uVar10;
      local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
      local_dc[0] = (int)lVar14;
      puVar17 = (undefined4 *)(in_stack_fffffec8 & 0xffffff00);
      FUN_10002250(&stack0xfffffec8,"Error finding function: NtSuspendProcess",(int *)0x28);
      local_fc = (uint)((ulonglong)uVar10 >> 0x20);
      local_f8._0_4_ = (uint)uVar10;
      local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
      local_dc[0] = (int)lVar14;
      uVar2 = FUN_10005830(puVar17);
      local_fc = (uint)((ulonglong)uVar10 >> 0x20);
      local_f8._0_4_ = (uint)uVar10;
      local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
      local_dc[0] = (int)lVar14;
      local_fc = uVar2 & 0xffffff00;
    }
    else {
      iVar3 = (*pFVar1)();
      local_fc = (uint)((ulonglong)uVar10 >> 0x20);
      local_f8._0_4_ = (uint)uVar10;
      local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
      local_dc[0] = (int)lVar14;
      local_fc = (uint)(-1 < iVar3);
    }
    CloseHandle(hObject);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
  }
  local_f8 = _Query_perf_frequency();
  uVar7 = (uint)((ulonglong)local_f8 >> 0x20);
  uVar2 = (uint)local_f8;
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  uVar10 = _Query_perf_counter();
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  uVar10 = __alldvrm((uint)uVar10,(uint)((ulonglong)uVar10 >> 0x20),uVar2,uVar7);
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  uVar12 = __allmul((uint)uVar10,(uint)((ulonglong)uVar10 >> 0x20),1000000000,0);
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  local_f0 = (uint)(uVar12 >> 0x20);
  uVar13 = __allmul(extraout_ECX_00,uVar7,1000000000,0);
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  lVar15 = __alldiv((uint)uVar13,(uint)(uVar13 >> 0x20),(uint)local_f8,local_f8._4_4_);
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  lVar15 = (lVar15 + (uVar12 & 0xffffffff | (ulonglong)local_f0 << 0x20)) - lVar14;
  _Var16 = __alldiv((uint)lVar15,(uint)((ulonglong)lVar15 >> 0x20),1000,0);
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  cVar9 = (char)local_fc;
  if (cVar9 != '\0') {
    FUN_10006240(&local_24,local_ec);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    piVar4 = FUN_100023d0(local_c8,"Time taken to suspend the process ");
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    pppppuVar8 = &local_24;
    if (0xf < uStack_10) {
      pppppuVar8 = local_24;
    }
    piVar4 = FUN_10004740(piVar4,(char *)pppppuVar8,uStack_14);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    piVar4 = FUN_100023d0(piVar4," from native is: processSuspendTime=");
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    piVar4 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar4,_Var16);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    FUN_100023d0(piVar4," microseconds");
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    FUN_10002250(&stack0xfffffee4,&DAT_1000d57c,(int *)0x4);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    FUN_10001a40(auStack_d4,&stack0xfffffecc);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    FUN_10005830(in_stack_fffffecc);
    local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
    local_dc[0] = (int)lVar14;
    if (0xf < local_c) {
      pvVar6 = pvStack_20;
      if ((0xfff < local_c + 1) &&
         (pvVar6 = *(void **)((int)pvStack_20 + -4),
         0x1f < (uint)((int)pvStack_20 + (-4 - (int)pvVar6)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
        local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
        local_dc[0] = (int)lVar14;
      }
      FUN_1000a4db(pvVar6);
      local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
      local_dc[0] = (int)lVar14;
    }
  }
  pcVar5 = (char *)FUN_1000a4ab(1);
  local_e8 = (undefined4)((ulonglong)lVar14 >> 0x20);
  local_dc[0] = (int)lVar14;
  *pcVar5 = cVar9;
  *(undefined ***)(auStack_d4 + *(int *)(local_dc[1] + 4) + -4) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_dc + *(int *)(local_dc[1] + 4)) = *(int *)(local_dc[1] + 4) + -0x68;
  FUN_100020a0(auStack_c0);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(abStack_b8);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(abStack_70);
  ___security_check_cookie_4(local_c ^ (uint)&local_fc);
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_getWindowProcesses_8(int *param_1)

{
  undefined4 uVar1;
  undefined4 *puVar2;
  void *pvVar3;
  int iVar4;
  int *piVar5;
  int unaff_EDI;
  int iVar6;
  int iStack_10c;
  int *piVar7;
  char *pcVar8;
  int iStack_f4;
  undefined **local_f0;
  int local_ec;
  undefined4 local_e8;
  undefined4 local_e4;
  undefined *puStack_e0;
  undefined **appuStack_d8 [2];
  basic_iostream_char_struct_std__char_traits_char___ abStack_d0 [48];
  undefined4 uStack_a0;
  undefined4 uStack_9c;
  basic_ios_char_struct_std__char_traits_char___ abStack_88 [76];
  void *apvStack_3c [4];
  undefined4 uStack_2c;
  uint uStack_28;
  uint uStack_24;
  uint local_c;
  
                    // 0x38b0  15
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getWindowProcesses@8
  local_c = DAT_10012024 ^ (uint)&iStack_f4;
  local_e4 = 0;
  local_f0 = (undefined **)0x0;
  local_ec = 0;
  local_e8 = 0;
  iStack_10c = 0x10003900;
  EnumWindows(FUN_10006b00,(LPARAM)&local_f0);
  pcVar8 = "java/lang/String";
  iVar4 = local_ec - (int)local_f0 >> 7;
  iStack_10c = 0x10003918;
  piVar5 = param_1;
  uVar1 = (**(code **)(*param_1 + 0x18))();
  iStack_10c = 0;
  uVar1 = (**(code **)(*param_1 + 0x2b0))(param_1,iVar4,uVar1);
  iVar6 = 0;
  if (0 < iVar4) {
    iStack_10c = 0;
    do {
      local_f0 = &PTR_1000d508;
      puStack_e0 = &DAT_1000d4b8;
      std::basic_ios<char,struct_std::char_traits<char>_>::
      basic_ios_char_struct_std__char_traits_char___(abStack_88);
      std::basic_iostream<char,struct_std::char_traits<char>_>::
      basic_iostream_char_struct_std__char_traits_char___
                ((basic_iostream_char_struct_std__char_traits_char___ *)&local_f0,
                 (basic_streambuf_char_struct_std__char_traits_char___ *)appuStack_d8);
      *(undefined ***)((int)&local_f0 + (int)local_f0[1]) =
           std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
           vftable;
      *(undefined **)((int)&iStack_f4 + (int)local_f0[1]) = local_f0[1] + -0x68;
      std::basic_streambuf<char,struct_std::char_traits<char>_>::
      basic_streambuf_char_struct_std__char_traits_char___
                ((basic_streambuf_char_struct_std__char_traits_char___ *)appuStack_d8);
      appuStack_d8[0] =
           std::basic_stringbuf<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
           vftable;
      uStack_a0 = 0;
      uStack_9c = 0;
      puVar2 = (undefined4 *)
               FUN_10005b30((void *)(iStack_10c + (int)piVar5),(undefined *)apvStack_3c);
      if (0xf < (uint)puVar2[5]) {
        puVar2 = (undefined4 *)*puVar2;
      }
      iStack_f4 = (**(code **)(*param_1 + 0x29c))(param_1,puVar2);
      if (0xf < uStack_28) {
        pvVar3 = apvStack_3c[0];
        if ((0xfff < uStack_28 + 1) &&
           (pvVar3 = *(void **)((int)apvStack_3c[0] + -4),
           0x1f < (uint)((int)apvStack_3c[0] + (-4 - (int)pvVar3)))) goto LAB_10003ae5;
        FUN_1000a4db(pvVar3);
      }
      uStack_2c = 0;
      uStack_28 = 0xf;
      apvStack_3c[0] = (void *)((uint)apvStack_3c[0] & 0xffffff00);
      (**(code **)(*param_1 + 0x2b8))(param_1,uVar1,iVar6,iStack_f4);
      *(undefined ***)((int)&local_f0 + (int)local_f0[1]) =
           std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
           vftable;
      *(undefined **)((int)&iStack_f4 + (int)local_f0[1]) = local_f0[1] + -0x68;
      FUN_100020a0(appuStack_d8);
      std::basic_iostream<char,struct_std::char_traits<char>_>::
      _basic_iostream_char_struct_std__char_traits_char___(abStack_d0);
      std::basic_ios<char,struct_std::char_traits<char>_>::
      _basic_ios_char_struct_std__char_traits_char___(abStack_88);
      iStack_10c = iStack_10c + 0x80;
      iVar6 = iVar6 + 1;
    } while (iVar6 < iVar4);
  }
  piVar7 = piVar5;
  if (piVar5 != (int *)0x0) {
    for (; piVar5 != (int *)pcVar8; piVar5 = piVar5 + 0x20) {
      FUN_100059c0((int)piVar5);
    }
    piVar5 = piVar7;
    if ((0xfff < (unaff_EDI - (int)piVar7 & 0xffffff80U)) &&
       (piVar5 = (int *)piVar7[-1], 0x1f < (uint)((int)piVar7 + (-4 - (int)piVar5)))) {
LAB_10003ae5:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(piVar5);
  }
  ___security_check_cookie_4(uStack_24 ^ (uint)&iStack_10c);
  return;
}



uint _Java_com_vue_browserlock_win_natives_NativeProxy_resumeProcess_16
               (undefined4 param_1,undefined4 param_2,DWORD param_3)

{
  HANDLE hObject;
  undefined *puVar1;
  HMODULE hModule;
  FARPROC pFVar2;
  int iVar3;
  byte *pbVar4;
  byte bVar5;
  char *lpProcName;
  
                    // 0x3b10  22
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_resumeProcess@16
  hObject = OpenProcess(0x1fffff,0,param_3);
  if (hObject == (HANDLE)0x0) {
    puVar1 = (undefined *)FUN_1000a4ab(1);
    *puVar1 = 0;
    return (uint)puVar1 & 0xffffff00;
  }
  lpProcName = "NtResumeProcess";
  hModule = GetModuleHandleA("ntdll");
  pFVar2 = GetProcAddress(hModule,lpProcName);
  if (pFVar2 == (FARPROC)0x0) {
    bVar5 = 0;
  }
  else {
    iVar3 = (*pFVar2)(hObject);
    bVar5 = 1;
    if (iVar3 < 0) {
      bVar5 = 0;
    }
  }
  CloseHandle(hObject);
  pbVar4 = (byte *)FUN_1000a4ab(1);
  *pbVar4 = bVar5;
  return (uint)pbVar4 & 0xffffff00 | (uint)bVar5;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_disableEaseOfAccessKeys_8(void)

{
  char *pcVar1;
  
                    // 0x3b90  5
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_disableEaseOfAccessKeys@8
  pcVar1 = DAT_100126c4;
  if (DAT_100126c4 == (char *)0x0) {
    pcVar1 = (char *)FUN_1000a4ab(0x1c);
    DAT_100126c4 = pcVar1;
    *pcVar1 = '\0';
    *(undefined4 *)(pcVar1 + 0x14) = 0;
    *(undefined4 *)(pcVar1 + 0x18) = 0xf;
    pcVar1[4] = '\0';
  }
  FUN_100049d0(pcVar1);
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_enableEaseOfAccessKeys_8(void)

{
  char *pcVar1;
  
                    // 0x3bd0  6
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_enableEaseOfAccessKeys@8
  pcVar1 = DAT_100126c4;
  if (DAT_100126c4 == (char *)0x0) {
    pcVar1 = (char *)FUN_1000a4ab(0x1c);
    DAT_100126c4 = pcVar1;
    *pcVar1 = '\0';
    *(undefined4 *)(pcVar1 + 0x14) = 0;
    *(undefined4 *)(pcVar1 + 0x18) = 0xf;
    pcVar1[4] = '\0';
  }
  FUN_100052e0(pcVar1);
  return;
}



undefined4 _Java_com_vue_browserlock_win_natives_NativeProxy_hideTaskBar_8(void)

{
  LPARAM lParam;
  BOOL BVar1;
  uint in_stack_ffffffc4;
  undefined4 *puVar2;
  undefined local_24 [12];
  undefined4 uStack_18;
  
                    // 0x3c10  16  _Java_com_vue_browserlock_win_natives_NativeProxy_hideTaskBar@8
  if (DAT_100126d4 == 0) {
    DAT_100126d4 = FUN_1000a4ab(1);
  }
  lParam = DAT_100126d4;
  local_24[0] = 0;
  FUN_10002250(local_24,&DAT_1000d57c,(int *)0x4);
  puVar2 = (undefined4 *)(in_stack_ffffffc4 & 0xffffff00);
  FUN_10002250(&stack0xffffffc4,"Hiding Taskbar.",(int *)0xf);
  FUN_10005830(puVar2);
  uStack_18 = 0x10003c89;
  BVar1 = EnumWindows(FUN_10008520,lParam);
  return CONCAT31((int3)((uint)BVar1 >> 8),1);
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_showTaskBar_8(void)

{
                    // 0x3ca0  23  _Java_com_vue_browserlock_win_natives_NativeProxy_showTaskBar@8
  if (DAT_100126d4 == 0) {
    DAT_100126d4 = FUN_1000a4ab(1);
  }
  FUN_10008440();
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_getCurrentProcessId_8(void)

{
                    // 0x3cc0  9
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getCurrentProcessId@8
  GetCurrentProcessId();
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_getProcessIdFromName_12
               (int *param_1,undefined4 param_2,uint param_3)

{
  char cVar1;
  char *pcVar2;
  char *pcVar3;
  void *pvVar4;
  undefined4 unaff_ESI;
  int *piStack_44;
  uint uStack_40;
  void *pvStack_3c;
  undefined auStack_2c [4];
  uint local_28;
  uint uStack_24;
  undefined4 uStack_20;
  undefined4 uStack_1c;
  uint local_c;
  
                    // 0x3cd0  14
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getProcessIdFromName@12
  local_c = DAT_10012024 ^ (uint)auStack_2c;
  pvStack_3c = (void *)0x0;
  uStack_40 = param_3;
  piStack_44 = param_1;
  local_28 = param_3;
  pcVar2 = (char *)(**(code **)(*param_1 + 0x2a4))();
  uStack_20 = 0;
  uStack_1c = 0xf;
  pcVar3 = pcVar2;
  do {
    cVar1 = *pcVar3;
    pcVar3 = pcVar3 + 1;
  } while (cVar1 != '\0');
  FUN_10002250(&stack0xffffffd0,pcVar2,(int *)(pcVar3 + -(int)(pcVar2 + 1)));
  FUN_100063b0((void **)&stack0xffffffd0);
  (**(code **)(*param_1 + 0x2a8))(param_1,unaff_ESI,pcVar2);
  if (0xf < local_28) {
    pvVar4 = pvStack_3c;
    if (0xfff < local_28 + 1) {
      pvVar4 = *(void **)((int)pvStack_3c + -4);
      if (0x1f < (uint)((int)pvStack_3c + (-4 - (int)pvVar4))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar4);
  }
  ___security_check_cookie_4(uStack_24 ^ (uint)&piStack_44);
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_clearClipboard_8(int *param_1)

{
  BOOL BVar1;
  DWORD DVar2;
  int *piVar3;
  void *pvVar4;
  int aiStack_dc [5];
  int local_c8 [2];
  undefined4 auStack_c0 [2];
  basic_iostream_char_struct_std__char_traits_char___ abStack_b8 [72];
  basic_ios_char_struct_std__char_traits_char___ abStack_70 [68];
  void *pvStack_2c;
  uint local_24 [3];
  uint uStack_18;
  uint local_14;
  undefined4 local_10;
  uint local_c;
  
                    // 0x3db0  3  _Java_com_vue_browserlock_win_natives_NativeProxy_clearClipboard@8
  local_c = DAT_10012024 ^ (uint)aiStack_dc;
  OpenClipboard((HWND)0x0);
  BVar1 = EmptyClipboard();
  if (BVar1 == 0) {
    FUN_10001b00(aiStack_dc + 1);
    DVar2 = GetLastError();
    piVar3 = FUN_100023d0(local_c8,"Failed to clear the clipboard [error code: ");
    piVar3 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,DVar2);
    FUN_100023d0(piVar3,"].");
    CloseClipboard();
    FUN_10001a40(aiStack_dc + 1,(undefined *)local_24);
    *(undefined ***)((int)aiStack_dc + *(int *)(aiStack_dc[1] + 4) + 4) =
         std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
         vftable;
    *(int *)((int)aiStack_dc + *(int *)(aiStack_dc[1] + 4)) = *(int *)(aiStack_dc[1] + 4) + -0x68;
    FUN_100020a0(auStack_c0);
    std::basic_iostream<char,struct_std::char_traits<char>_>::
    _basic_iostream_char_struct_std__char_traits_char___(abStack_b8);
    std::basic_ios<char,struct_std::char_traits<char>_>::
    _basic_ios_char_struct_std__char_traits_char___(abStack_70);
  }
  else {
    CloseClipboard();
    local_14 = 0;
    local_10 = 0xf;
    local_24[0] = local_24[0] & 0xffffff00;
    FUN_10002250(local_24,&DAT_1000d90e,(int *)0x0);
  }
  (**(code **)(*param_1 + 0x29c))(param_1);
  if (0xf < uStack_18) {
    pvVar4 = pvStack_2c;
    if ((0xfff < uStack_18 + 1) &&
       (pvVar4 = *(void **)((int)pvStack_2c + -4),
       0x1f < (uint)((int)pvStack_2c + (-4 - (int)pvVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar4);
  }
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xffffff1c);
  return;
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address

void _Java_com_vue_browserlock_win_natives_NativeProxy_isVirtualMachine_8(void)

{
                    // 0x3f30  19
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_isVirtualMachine@8
  if (_DAT_100126d8 == 0) {
    _DAT_100126d8 = FUN_1000a4ab(1);
  }
  FUN_10008910();
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_getDisplayCountSystemMetrics_8(void)

{
  undefined (*pauVar1) [16];
  
                    // 0x3f50  11
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getDisplayCountSystemMetrics@8
  if (DAT_100126dc == (undefined (*) [16])0x0) {
    pauVar1 = (undefined (*) [16])FUN_1000a4ab(0x18);
    DAT_100126dc = pauVar1;
    *pauVar1 = ZEXT816(0);
    *(undefined8 *)pauVar1[1] = 0;
  }
  GetSystemMetrics(0x50);
  return;
}



int _Java_com_vue_browserlock_win_natives_NativeProxy_getDisplayCountEnumDisplay_8(void)

{
  undefined (*pauVar1) [16];
  void *pvVar2;
  int iVar3;
  void *local_10;
  int local_c;
  int local_8;
  
                    // 0x3f80  10
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getDisplayCountEnumDisplay@8
  if (DAT_100126dc == (undefined (*) [16])0x0) {
    pauVar1 = (undefined (*) [16])FUN_1000a4ab(0x18);
    DAT_100126dc = pauVar1;
    *pauVar1 = ZEXT816(0);
    *(undefined8 *)pauVar1[1] = 0;
  }
  local_10 = (void *)0x0;
  local_c = 0;
  local_8 = 0;
  EnumDisplayMonitors((HDC)0x0,(LPCRECT)0x0,FUN_10008c30,(LPARAM)&local_10);
  iVar3 = local_c - (int)local_10;
  if (local_10 != (void *)0x0) {
    pvVar2 = local_10;
    if (0xfff < (local_8 - (int)local_10 & 0xfffffff0U)) {
      pvVar2 = *(void **)((int)local_10 + -4);
      if (0x1f < (uint)((int)local_10 + (-4 - (int)pvVar2))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar2);
  }
  return iVar3 >> 4;
}



undefined4 _Java_com_vue_browserlock_win_natives_NativeProxy_getDuplicateDisplayCount_8(void)

{
  undefined (*pauVar1) [16];
  HWND hwnd;
  HMONITOR pHVar2;
  undefined4 local_8;
  
                    // 0x4020  12
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getDuplicateDisplayCount@8
  if (DAT_100126dc == (undefined (*) [16])0x0) {
    pauVar1 = (undefined (*) [16])FUN_1000a4ab(0x18);
    DAT_100126dc = pauVar1;
    *pauVar1 = ZEXT816(0);
    *(undefined8 *)pauVar1[1] = 0;
  }
  hwnd = GetDesktopWindow();
  pHVar2 = MonitorFromWindow(hwnd,1);
  if (pHVar2 != (HMONITOR)0x0) {
    GetNumberOfPhysicalMonitorsFromHMONITOR(pHVar2,&local_8);
    return local_8;
  }
  return local_8;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_isDisplayHdcpCompliant_8(void)

{
  undefined (*pauVar1) [16];
  
                    // 0x4080  17
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_isDisplayHdcpCompliant@8
  if (DAT_100126dc == (undefined (*) [16])0x0) {
    pauVar1 = (undefined (*) [16])FUN_1000a4ab(0x18);
    DAT_100126dc = pauVar1;
    *pauVar1 = ZEXT816(0);
    *(undefined8 *)pauVar1[1] = 0;
  }
  FUN_10008e20();
  return;
}



undefined4 _Java_com_vue_browserlock_win_natives_NativeProxy_blockScreenCapture_8(void)

{
  undefined *puVar1;
  HWND hWnd;
  HWND hWnd_00;
  HWND pHVar2;
  
                    // 0x40b0  2
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_blockScreenCapture@8
  if (DAT_100126c4 == (undefined *)0x0) {
    puVar1 = (undefined *)FUN_1000a4ab(0x1c);
    DAT_100126c4 = puVar1;
    *puVar1 = 0;
    *(undefined4 *)(puVar1 + 0x14) = 0;
    *(undefined4 *)(puVar1 + 0x18) = 0xf;
    puVar1[4] = 0;
  }
  hWnd = GetForegroundWindow();
  hWnd_00 = GetWindow(hWnd,0);
  pHVar2 = hWnd_00;
  if (hWnd != (HWND)0x0) {
    pHVar2 = (HWND)SetWindowDisplayAffinity(hWnd,0x11);
  }
  if (hWnd_00 != (HWND)0x0) {
    pHVar2 = (HWND)SetWindowDisplayAffinity(hWnd_00,0x11);
  }
  return CONCAT31((int3)((uint)pHVar2 >> 8),1);
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address

void _Java_com_vue_browserlock_win_natives_NativeProxy_clearClipboardHistory_8(void)

{
  int *piVar1;
  char cVar2;
  uint in_stack_ffffffa8;
  undefined4 *puVar3;
  undefined *local_40;
  int **ppiStack_3c;
  wchar_t *pwStack_38;
  undefined4 uStack_34;
  undefined *local_30;
  int *local_24;
  undefined local_1d;
  undefined local_1c [20];
  uint local_8;
  
                    // 0x4120  4
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_clearClipboardHistory@8
  local_8 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  if (_DAT_100126e0 == 0) {
    local_30 = (undefined *)0x10004140;
    _DAT_100126e0 = FUN_1000a4ab(1);
  }
  cVar2 = FUN_10009be0();
  if (cVar2 != '\0') {
    local_30 = (undefined *)0x0;
    local_40 = (undefined *)((uint)local_40 & 0xffffff00);
    FUN_10002250(&local_40,&DAT_1000d57c,(int *)0x4);
    puVar3 = (undefined4 *)(in_stack_ffffffa8 & 0xffffff00);
    FUN_10002250(&stack0xffffffa8,"Clearing the clipboard",(int *)0x16);
    FUN_10005830(puVar3);
    local_30 = (undefined *)0x100041a9;
    CoInitialize((LPVOID)0x0);
    local_30 = local_1c;
    uStack_34 = 0x2f;
    pwStack_38 = L"Windows.ApplicationModel.DataTransfer.Clipboard";
    ppiStack_3c = (int **)0x100041be;
    WindowsCreateStringReference();
    ppiStack_3c = &local_24;
    local_24 = (int *)0x0;
    local_40 = &DAT_1000dd78;
    RoGetActivationFactory();
    local_1d = 0;
    (**(code **)(*local_24 + 0x1c))();
    piVar1 = local_24;
    if (local_24 != (int *)0x0) {
      local_24 = (int *)0x0;
      local_30 = (undefined *)0x100041fc;
      (**(code **)(*piVar1 + 8))();
    }
    CoUninitialize();
  }
  ___security_check_cookie_4(local_8 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address

void _Java_com_vue_browserlock_win_natives_NativeProxy_isSystemSettingsSuspended_16
               (undefined4 param_1,undefined4 param_2,int param_3)

{
                    // 0x4220  18
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_isSystemSettingsSuspended@16
  if (_DAT_100126e4 == 0) {
    _DAT_100126e4 = FUN_1000a4ab(1);
  }
  FUN_10009ec0(param_3);
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_restoreMinimizedProcess_12
               (int *param_1,undefined4 param_2,void *param_3)

{
  char cVar1;
  char *pcVar2;
  char *pcVar3;
  void *pvVar4;
  void *pvStack_30;
  undefined4 uStack_2c;
  undefined auStack_24 [4];
  undefined4 uStack_20;
  uint uStack_1c;
  uint uStack_18;
  uint local_c;
  
                    // 0x4250  21
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_restoreMinimizedProcess@12
  local_c = DAT_10012024 ^ (uint)auStack_24;
  uStack_2c = 0;
  pvStack_30 = param_3;
  pcVar2 = (char *)(**(code **)(*param_1 + 0x2a4))(param_1);
  uStack_20 = 0;
  uStack_1c = 0xf;
  pvStack_30 = (void *)((uint)pvStack_30 & 0xffffff00);
  pcVar3 = pcVar2;
  do {
    cVar1 = *pcVar3;
    pcVar3 = pcVar3 + 1;
  } while (cVar1 != '\0');
  FUN_10002250(&pvStack_30,pcVar2,(int *)(pcVar3 + -(int)(pcVar2 + 1)));
  FUN_10007120(&pvStack_30);
  if (0xf < uStack_1c) {
    pvVar4 = pvStack_30;
    if (0xfff < uStack_1c + 1) {
      pvVar4 = *(void **)((int)pvStack_30 + -4);
      if (0x1f < (uint)((int)pvStack_30 + (-4 - (int)pvVar4))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar4);
  }
  ___security_check_cookie_4(uStack_18 ^ (uint)&pvStack_30);
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_allowToggle_8(void)

{
                    // 0x4300  1  _Java_com_vue_browserlock_win_natives_NativeProxy_allowToggle@8
  FUN_10007810();
  return;
}



void _Java_com_vue_browserlock_win_natives_NativeProxy_getNameFromProcessId_16
               (int *param_1,undefined4 param_2,int param_3)

{
  void *pvVar1;
  undefined4 *puStack_3c;
  undefined auStack_34 [8];
  void *pvStack_2c;
  undefined4 local_24 [3];
  uint uStack_18;
  uint uStack_14;
  uint local_c;
  
                    // 0x4310  13
                    // _Java_com_vue_browserlock_win_natives_NativeProxy_getNameFromProcessId@16
  local_c = DAT_10012024 ^ (uint)auStack_34;
  puStack_3c = (undefined4 *)0x10004334;
  puStack_3c = (undefined4 *)FUN_10006240(local_24,param_3);
  if (0xf < (uint)puStack_3c[5]) {
    puStack_3c = (undefined4 *)*puStack_3c;
  }
  (**(code **)(*param_1 + 0x29c))(param_1);
  if (0xf < uStack_18) {
    pvVar1 = pvStack_2c;
    if (0xfff < uStack_18 + 1) {
      pvVar1 = *(void **)((int)pvStack_2c + -4);
      if (0x1f < (uint)((int)pvStack_2c + (-4 - (int)pvVar1))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar1);
  }
  ___security_check_cookie_4(uStack_14 ^ (uint)&puStack_3c);
  return;
}



void ** __thiscall FUN_100043a0(void *this,void **param_1)

{
  uint uVar1;
  void *pvVar2;
  void *pvVar3;
  void *pvVar4;
  uint uVar5;
  int iVar6;
  void *pvVar7;
  uint uVar8;
  
  *(undefined4 *)((int)this + 0x10) = 0;
  *(undefined4 *)((int)this + 0x14) = 0;
  pvVar2 = param_1[4];
  if ((void *)0xf < param_1[5]) {
    param_1 = (void **)*param_1;
  }
  if (pvVar2 < (void *)0x10) {
    pvVar7 = param_1[1];
    pvVar3 = param_1[2];
    pvVar4 = param_1[3];
    *(void **)this = *param_1;
    *(void **)((int)this + 4) = pvVar7;
    *(void **)((int)this + 8) = pvVar3;
    *(void **)((int)this + 0xc) = pvVar4;
    *(void **)((int)this + 0x10) = pvVar2;
    *(undefined4 *)((int)this + 0x14) = 0xf;
    return (void **)this;
  }
  uVar8 = (uint)pvVar2 | 0xf;
  if (0x7fffffff < uVar8) {
    uVar8 = 0x7fffffff;
  }
  uVar1 = uVar8 + 1;
  if (uVar1 < 0x1000) {
    if (uVar1 == 0) {
      pvVar7 = (void *)0x0;
    }
    else {
      pvVar7 = (void *)FUN_1000a4ab(uVar1);
    }
  }
  else {
    uVar5 = uVar8 + 0x24;
    if (uVar5 <= uVar1) {
      uVar5 = 0xffffffff;
    }
    iVar6 = FUN_1000a4ab(uVar5);
    if (iVar6 == 0) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    pvVar7 = (void *)(iVar6 + 0x23U & 0xffffffe0);
    *(int *)((int)pvVar7 - 4) = iVar6;
  }
  *(void **)this = pvVar7;
  memcpy(pvVar7,param_1,(int)pvVar2 + 1);
  *(void **)((int)this + 0x10) = pvVar2;
  *(uint *)((int)this + 0x14) = uVar8;
  return (void **)this;
}



void FUN_10004460(void)

{
  code *pcVar1;
  
  std::_Xout_of_range("invalid vector<T> subscript");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}



void FUN_10004470(int param_1,int param_2)

{
  if (param_1 != param_2) {
    do {
      FUN_100059c0(param_1);
      param_1 = param_1 + 0x80;
    } while (param_1 != param_2);
  }
  return;
}



void FUN_100044a0(void *param_1,int param_2)

{
  void *pvVar1;
  
  pvVar1 = param_1;
  if ((0xfff < (uint)(param_2 * 0x80)) &&
     (pvVar1 = *(void **)((int)param_1 + -4), 0x1f < (uint)((int)param_1 + (-4 - (int)pvVar1)))) {
                    // WARNING: Subroutine does not return
    _invalid_parameter_noinfo_noreturn();
  }
  FUN_1000a4db(pvVar1);
  return;
}



void FUN_100044e0(void)

{
  code *pcVar1;
  
  std::_Xout_of_range("invalid string position");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}



void * __thiscall FUN_100044f0(void *this,void **param_1,void **param_2)

{
  int iVar1;
  code *pcVar2;
  int iVar3;
  int iVar4;
  void *pvVar5;
  uint uVar6;
  uint uVar7;
  void *pvVar8;
  uint uVar9;
  void **ppvVar10;
  void **ppvVar11;
  uint uVar12;
  void *pvVar13;
  void **ppvVar14;
  void **ppvVar15;
  
                    // WARNING: Load size is inaccurate
  iVar1 = *this;
  iVar3 = ((int)param_1 - iVar1) / 0x18;
  iVar4 = (*(int *)((int)this + 4) - iVar1) / 0x18;
  if (iVar4 == 0xaaaaaaa) {
    FUN_10004730();
    pcVar2 = (code *)swi(3);
    pvVar8 = (void *)(*pcVar2)();
    return pvVar8;
  }
  uVar12 = iVar4 + 1;
  uVar9 = (*(int *)((int)this + 8) - iVar1) / 0x18;
  uVar6 = uVar12;
  if ((uVar9 <= 0xaaaaaaa - (uVar9 >> 1)) && (uVar6 = (uVar9 >> 1) + uVar9, uVar6 < uVar12)) {
    uVar6 = uVar12;
  }
  uVar9 = uVar6 * 0x18;
  if (uVar6 < 0xaaaaaab) {
    if (0xfff < uVar9) goto LAB_1000458a;
    if (uVar9 == 0) {
      ppvVar14 = (void **)0x0;
    }
    else {
      ppvVar14 = (void **)FUN_1000a4ab(uVar9);
    }
  }
  else {
    uVar9 = 0xffffffff;
LAB_1000458a:
    uVar7 = uVar9 + 0x23;
    if (uVar7 <= uVar9) {
      uVar7 = 0xffffffff;
    }
    pvVar8 = (void *)FUN_1000a4ab(uVar7);
    if (pvVar8 == (void *)0x0) goto LAB_100046ad;
    ppvVar14 = (void **)((int)pvVar8 + 0x23U & 0xffffffe0);
    ppvVar14[-1] = pvVar8;
  }
  ppvVar14[iVar3 * 6 + 4] = (void *)0x0;
  ppvVar14[iVar3 * 6 + 5] = (void *)0x0;
  pvVar8 = param_2[1];
  pvVar13 = param_2[2];
  pvVar5 = param_2[3];
  ppvVar11 = ppvVar14 + iVar3 * 6;
  *ppvVar11 = *param_2;
  ppvVar11[1] = pvVar8;
  ppvVar11[2] = pvVar13;
  ppvVar11[3] = pvVar5;
  *(undefined8 *)(ppvVar14 + iVar3 * 6 + 4) = *(undefined8 *)(param_2 + 4);
  param_2[4] = (void *)0x0;
  param_2[5] = (void *)0xf;
  *(undefined *)param_2 = 0;
                    // WARNING: Load size is inaccurate
  ppvVar11 = *(void ***)((int)this + 4);
  ppvVar10 = *this;
  ppvVar15 = ppvVar14;
  if (param_1 != ppvVar11) {
    FUN_10004960(*this,param_1,ppvVar14);
    ppvVar11 = *(void ***)((int)this + 4);
    ppvVar15 = ppvVar14 + iVar3 * 6 + 6;
    ppvVar10 = param_1;
  }
  FUN_10004960(ppvVar10,ppvVar11,ppvVar15);
                    // WARNING: Load size is inaccurate
  if (*this != (void **)0x0) {
    FUN_100046c0(*this,*(void ***)((int)this + 4));
                    // WARNING: Load size is inaccurate
    pvVar8 = *this;
    pvVar13 = pvVar8;
    if ((0xfff < (uint)(((*(int *)((int)this + 8) - (int)pvVar8) / 0x18) * 0x18)) &&
       (pvVar13 = *(void **)((int)pvVar8 + -4), 0x1f < (uint)((int)pvVar8 + (-4 - (int)pvVar13)))) {
LAB_100046ad:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar13);
  }
  *(void ***)this = ppvVar14;
  *(void ***)((int)this + 4) = ppvVar14 + uVar12 * 6;
  *(void ***)((int)this + 8) = ppvVar14 + uVar6 * 6;
                    // WARNING: Load size is inaccurate
  return (void *)(*this + iVar3 * 0x18);
}



void __fastcall FUN_100046c0(void **param_1,void **param_2)

{
  void *pvVar1;
  void *pvVar2;
  
  if (param_1 != param_2) {
    do {
      if ((void *)0xf < param_1[5]) {
        pvVar1 = *param_1;
        pvVar2 = pvVar1;
        if ((0xfff < (int)param_1[5] + 1U) &&
           (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2))))
        {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
        FUN_1000a4db(pvVar2);
      }
      param_1[4] = (void *)0x0;
      param_1[5] = (void *)0xf;
      *(undefined *)param_1 = 0;
      param_1 = param_1 + 6;
    } while (param_1 != param_2);
  }
  return;
}



void FUN_10004730(void)

{
  code *pcVar1;
  
  std::_Xlength_error("vector<T> too long");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}



// WARNING: Could not reconcile some variable overlaps

int * __fastcall FUN_10004740(int *param_1,char *param_2,uint param_3)

{
  uint uVar1;
  bool bVar2;
  int iVar3;
  int *piVar4;
  int iVar5;
  int iVar6;
  __int64 _Var7;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b820;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  iVar5 = *param_1;
  iVar3 = *(int *)(iVar5 + 4);
  uVar1 = *(uint *)((int)param_1 + iVar3 + 0x20);
  iVar6 = *(int *)((int)param_1 + iVar3 + 0x24);
  if ((iVar6 < 0) || (((iVar6 < 1 && (uVar1 == 0)) || (uVar1 <= param_3)))) {
    iVar6 = 0;
  }
  else {
    iVar6 = uVar1 - param_3;
  }
  piVar4 = *(int **)((int)param_1 + iVar3 + 0x38);
  if (piVar4 != (int *)0x0) {
    (**(code **)(*piVar4 + 4))();
    iVar5 = *param_1;
  }
  local_8 = 0;
  iVar3 = *(int *)(iVar5 + 4);
  if (((*(int *)((int)param_1 + iVar3 + 0xc) == 0) && (*(int *)((int)param_1 + iVar3 + 0x3c) != 0))
     && (piVar4 = *(int **)((int)param_1 + iVar3 + 0x3c), piVar4 != param_1)) {
    std::basic_ostream<char,struct_std::char_traits<char>_>::flush
              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar4);
    iVar5 = *param_1;
  }
  local_8 = 1;
  if (*(int *)(*(int *)(iVar5 + 4) + 0xc + (int)param_1) != 0) {
    std::basic_ios<char,struct_std::char_traits<char>_>::setstate
              ((basic_ios_char_struct_std__char_traits_char___ *)
               (*(int *)(*param_1 + 4) + (int)param_1),4,false);
    local_8 = 4;
    bVar2 = std::uncaught_exception();
    if (!bVar2) {
      std::basic_ostream<char,struct_std::char_traits<char>_>::_Osfx
                ((basic_ostream_char_struct_std__char_traits_char___ *)param_1);
    }
    local_8 = CONCAT31(local_8._1_3_,5);
    piVar4 = *(int **)(*(int *)(*param_1 + 4) + 0x38 + (int)param_1);
    if (piVar4 != (int *)0x0) {
      (**(code **)(*piVar4 + 8))();
    }
    ExceptionList = local_10;
    return param_1;
  }
  local_8 = 2;
  if ((*(uint *)(*(int *)(iVar5 + 4) + 0x14 + (int)param_1) & 0x1c0) != 0x40) {
    for (; iVar6 != 0; iVar6 = iVar6 + -1) {
      iVar3 = std::basic_streambuf<char,struct_std::char_traits<char>_>::sputc
                        (*(basic_streambuf_char_struct_std__char_traits_char___ **)
                          (*(int *)(*param_1 + 4) + 0x38 + (int)param_1),
                         *(char *)(*(int *)(*param_1 + 4) + 0x40 + (int)param_1));
      if (iVar3 == -1) goto LAB_10004890;
    }
    iVar5 = *param_1;
  }
  _Var7 = std::basic_streambuf<char,struct_std::char_traits<char>_>::sputn
                    (*(basic_streambuf_char_struct_std__char_traits_char___ **)
                      (*(int *)(iVar5 + 4) + 0x38 + (int)param_1),param_2,(ulonglong)param_3);
  if (((uint)_Var7 == param_3) && ((int)((ulonglong)_Var7 >> 0x20) == 0)) {
LAB_10004890:
    while ((iVar6 != 0 &&
           (iVar3 = std::basic_streambuf<char,struct_std::char_traits<char>_>::sputc
                              (*(basic_streambuf_char_struct_std__char_traits_char___ **)
                                (*(int *)(*param_1 + 4) + 0x38 + (int)param_1),
                               *(char *)(*(int *)(*param_1 + 4) + 0x40 + (int)param_1)), iVar3 != -1
           ))) {
      iVar6 = iVar6 + -1;
    }
  }
  iVar3 = *(int *)(*param_1 + 4);
  *(undefined4 *)(iVar3 + 0x20 + (int)param_1) = 0;
  *(undefined4 *)(iVar3 + 0x24 + (int)param_1) = 0;
  piVar4 = (int *)FUN_100048f6();
  return piVar4;
}



undefined * Catch_All_100048d6(void)

{
  int unaff_EBP;
  
  std::basic_ios<char,struct_std::char_traits<char>_>::setstate
            ((basic_ios_char_struct_std__char_traits_char___ *)
             (*(int *)(**(int **)(unaff_EBP + -0x1c) + 4) + (int)*(int **)(unaff_EBP + -0x1c)),4,
             true);
  return &DAT_100048f0;
}



void FUN_100048f6(void)

{
  int *piVar1;
  bool bVar2;
  int *unaff_EBX;
  int unaff_EBP;
  int unaff_EDI;
  
  *(undefined4 *)(unaff_EBP + -4) = 1;
  std::basic_ios<char,struct_std::char_traits<char>_>::setstate
            ((basic_ios_char_struct_std__char_traits_char___ *)
             (*(int *)(*unaff_EBX + 4) + (int)unaff_EBX),unaff_EDI,false);
  *(undefined4 *)(unaff_EBP + -4) = 4;
  bVar2 = std::uncaught_exception();
  piVar1 = *(int **)(unaff_EBP + -0x2c);
  if (!bVar2) {
    std::basic_ostream<char,struct_std::char_traits<char>_>::_Osfx
              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar1);
  }
  *(undefined *)(unaff_EBP + -4) = 5;
  piVar1 = *(int **)(*(int *)(*piVar1 + 4) + 0x38 + (int)piVar1);
  if (piVar1 != (int *)0x0) {
    (**(code **)(*piVar1 + 8))();
  }
  ExceptionList = *(void **)(unaff_EBP + -0xc);
  return;
}



void ** __fastcall FUN_10004960(void **param_1,void **param_2,void **param_3)

{
  void *pvVar1;
  void *pvVar2;
  void *pvVar3;
  void **ppvVar4;
  void **ppvVar5;
  
  ppvVar5 = param_3;
  if (param_1 != param_2) {
    ppvVar4 = param_1;
    do {
      ppvVar5[4] = (void *)0x0;
      *(undefined4 *)((int)param_3 + (0x14 - (int)param_1) + (int)ppvVar4) = 0;
      pvVar1 = ppvVar4[1];
      pvVar2 = ppvVar4[2];
      pvVar3 = ppvVar4[3];
      *ppvVar5 = *ppvVar4;
      ppvVar5[1] = pvVar1;
      ppvVar5[2] = pvVar2;
      ppvVar5[3] = pvVar3;
      *(undefined8 *)(ppvVar5 + 4) = *(undefined8 *)(ppvVar4 + 4);
      ppvVar5 = ppvVar5 + 6;
      ppvVar4[4] = (void *)0x0;
      ppvVar4[5] = (void *)0xf;
      *(undefined *)ppvVar4 = 0;
      ppvVar4 = ppvVar4 + 6;
    } while (ppvVar4 != param_2);
  }
  FUN_100046c0(ppvVar5,ppvVar5);
  return ppvVar5;
}



undefined4 FUN_100049c0(void)

{
  return 1;
}



void __fastcall FUN_100049d0(char *param_1)

{
  char cVar1;
  HWND hWnd;
  undefined4 *puVar2;
  undefined4 ****ppppuVar3;
  undefined4 ****ppppuVar4;
  undefined4 ****_Src;
  undefined4 *in_stack_ffffff88;
  undefined local_60 [4];
  undefined4 uStack_5c;
  char *lpCaption;
  UINT uType;
  undefined4 ****local_34;
  char local_2d;
  undefined4 ****local_2c [4];
  size_t local_1c;
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b858;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  cVar1 = FUN_10004c00(param_1);
  *param_1 = cVar1;
  local_2d = '\0';
  if (cVar1 == '\0') {
    local_1c = 0;
    local_18 = 0xf;
    local_2c[0] = (undefined4 ****)((uint)local_2c[0] & 0xffffff00);
    FUN_10002250(local_2c,
                 "Ease of access configurations cannot be saved. Please reboot your PC and restart BrowserLock."
                 ,(int *)0x5d);
    local_8 = 1;
    puVar2 = (undefined4 *)(param_1 + 4);
    ppppuVar4 = *(undefined4 *****)(param_1 + 0x14);
    _Src = local_2c;
    if (0xf < local_18) {
      _Src = local_2c[0];
    }
    local_34 = ppppuVar4;
    if (local_1c <= (uint)(*(int *)(param_1 + 0x18) - (int)ppppuVar4)) {
      *(size_t *)(param_1 + 0x14) = local_1c + (int)ppppuVar4;
      if (0xf < *(uint *)(param_1 + 0x18)) {
        puVar2 = (undefined4 *)*puVar2;
      }
      goto LAB_10004a85;
    }
LAB_10004a99:
    local_34 = (undefined4 ****)((uint)local_34 & 0xffffff00);
    uStack_5c = 0x10004aa8;
    FUN_10002770(param_1 + 4,local_1c,local_34,_Src,local_1c);
    ppppuVar3 = local_2c[0];
  }
  else {
    local_2d = FUN_10004f20(param_1);
    if (local_2d != '\0') goto LAB_10004b5d;
    local_1c = 0;
    local_18 = 0xf;
    local_2c[0] = (undefined4 ****)((uint)local_2c[0] & 0xffffff00);
    FUN_10002250(local_2c,
                 "Accessibility features cannot be turned off. Please reboot your PC and restart BrowserLock."
                 ,(int *)0x5b);
    local_8 = 0;
    puVar2 = (undefined4 *)(param_1 + 4);
    ppppuVar4 = *(undefined4 *****)(param_1 + 0x14);
    _Src = local_2c;
    if (0xf < local_18) {
      _Src = local_2c[0];
    }
    local_34 = _Src;
    if ((uint)(*(int *)(param_1 + 0x18) - (int)ppppuVar4) < local_1c) goto LAB_10004a99;
    *(size_t *)(param_1 + 0x14) = local_1c + (int)ppppuVar4;
    if (0xf < *(uint *)(param_1 + 0x18)) {
      puVar2 = (undefined4 *)*puVar2;
    }
LAB_10004a85:
    ppppuVar3 = local_2c[0];
    memmove((void *)((int)ppppuVar4 + (int)puVar2),_Src,local_1c);
    *(undefined *)((int)(void *)((int)ppppuVar4 + (int)puVar2) + local_1c) = 0;
  }
  local_8 = 0xffffffff;
  if (0xf < local_18) {
    ppppuVar4 = ppppuVar3;
    if ((0xfff < local_18 + 1) &&
       (ppppuVar4 = (undefined4 ****)ppppuVar3[-1],
       0x1f < (uint)((int)ppppuVar3 + (-4 - (int)ppppuVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(ppppuVar4);
  }
LAB_10004b5d:
  if ((*param_1 == '\0') || (local_2d == '\0')) {
    local_60[0] = 0;
    FUN_10002250(local_60,&DAT_1000d700,(int *)0x4);
    local_8 = 2;
    puVar2 = (undefined4 *)(param_1 + 4);
    FUN_10002620((undefined4 *)&stack0xffffff88,"BrowserLock - Ease of Access Warning: ",puVar2);
    local_8 = 0xffffffff;
    FUN_10005830(in_stack_ffffff88);
    if (0xf < *(uint *)(param_1 + 0x18)) {
      puVar2 = (undefined4 *)*puVar2;
    }
    uType = 0x1010;
    lpCaption = "BrowserLock - Ease of Access Warning";
    hWnd = GetForegroundWindow();
    uStack_5c = 0x10004bd8;
    MessageBoxA(hWnd,(LPCSTR)puVar2,lpCaption,uType);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps
// WARNING: Globals starting with '_' overlap smaller symbols at the same address

void __fastcall FUN_10004c00(undefined *param_1)

{
  undefined *puVar1;
  BOOL BVar2;
  void **ppvVar3;
  int *piVar4;
  DWORD DVar5;
  void *pvVar6;
  undefined4 *puVar7;
  bool bVar8;
  undefined4 *in_stack_fffffee0;
  uint uStack_108;
  int local_e4 [4];
  int local_d4 [2];
  undefined4 local_cc [2];
  basic_iostream_char_struct_std__char_traits_char___ local_c4 [72];
  basic_ios_char_struct_std__char_traits_char___ local_7c [76];
  uint *local_30;
  void *local_2c [5];
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = -1;
  puStack_c = &LAB_1000b893;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  uStack_108 = 0x10004c48;
  local_30 = (uint *)param_1;
  BVar2 = SystemParametersInfoA(0x3a,8,&DAT_1001205c,0);
  puVar7 = (undefined4 *)(param_1 + 4);
  bVar8 = BVar2 != 0;
  if (!bVar8) {
    FUN_10002250(puVar7,"Sticky Keys ",(int *)0xc);
  }
  uStack_108 = 0x10004c6c;
  BVar2 = SystemParametersInfoA(0x34,8,&DAT_10012064,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"Toggle Keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar6 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar6);
    }
    bVar8 = false;
  }
  uStack_108 = 0x10004ccf;
  BVar2 = SystemParametersInfoA(0x32,0x18,&DAT_1001206c,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"Filter Keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar6 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar6);
    }
    bVar8 = false;
  }
  uStack_108 = 0x10004d32;
  BVar2 = SystemParametersInfoA(0x36,0x1c,&DAT_10012034,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"Mouse Keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar6 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar6);
    }
    bVar8 = false;
  }
  uStack_108 = 0x10004d95;
  BVar2 = SystemParametersInfoA(0x42,0xc,&DAT_10012050,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"HighContrast Keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (pvVar6 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar6);
    }
  }
  else {
    _DAT_10012058 = 0;
    if (bVar8) goto LAB_10004ef6;
  }
  FUN_10001b00(local_e4);
  puVar1 = (undefined *)local_30;
  local_8 = 0;
  puVar7 = (undefined4 *)((int)local_30 + 4);
  piVar4 = FUN_100023d0(local_d4,"Failed to save accessibility features: ");
  if (0xf < *(uint *)(puVar1 + 0x18)) {
    puVar7 = (undefined4 *)*puVar7;
  }
  piVar4 = FUN_10004740(piVar4,(char *)puVar7,*(uint *)(puVar1 + 0x14));
  DVar5 = GetLastError();
  piVar4 = FUN_100023d0(piVar4,"SystemParametersInfo [error code: ");
  piVar4 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                            ((basic_ostream_char_struct_std__char_traits_char___ *)piVar4,DVar5);
  FUN_100023d0(piVar4,"].");
  local_30 = &uStack_108;
  uStack_108 = uStack_108 & 0xffffff00;
  FUN_10002250(&uStack_108,"ERROR",(int *)0x5);
  local_8._0_1_ = 1;
  FUN_10001a40(local_e4,&stack0xfffffee0);
  local_8 = (uint)local_8._1_3_ << 8;
  FUN_10005830(in_stack_fffffee0);
  *(undefined ***)((int)local_e4 + *(int *)(local_e4[0] + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_cc + *(int *)(local_e4[0] + 4) + -0x1c) = *(int *)(local_e4[0] + 4) + -0x68;
  FUN_100020a0(local_cc);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(local_c4);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(local_7c);
LAB_10004ef6:
  ExceptionList = local_10;
  local_e4[0] = 0x10004f10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall FUN_10004f20(undefined *param_1)

{
  undefined *puVar1;
  BOOL BVar2;
  void **ppvVar3;
  int *piVar4;
  DWORD DVar5;
  void *pvVar6;
  undefined4 *puVar7;
  undefined4 *in_stack_fffffe90;
  uint uStack_158;
  int local_138 [4];
  int local_128 [2];
  undefined4 local_120 [2];
  basic_iostream_char_struct_std__char_traits_char___ local_118 [72];
  basic_ios_char_struct_std__char_traits_char___ local_d0 [76];
  undefined4 local_84;
  uint local_80;
  undefined4 local_7c;
  undefined4 local_78;
  uint local_74;
  undefined4 local_70;
  uint local_6c;
  uint *local_68;
  char local_61;
  undefined4 local_60;
  uint local_5c;
  undefined local_58 [16];
  undefined4 local_48;
  uint local_44;
  undefined local_40 [16];
  undefined4 local_30;
  void *local_2c [5];
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = -1;
  puStack_c = &LAB_1000b8d3;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  local_6c = DAT_10012060 & 0xfffffffb;
  local_74 = DAT_10012068 & 0xfffffffb;
  local_5c = DAT_10012070 & 0xfffffffb;
  local_61 = '\x01';
  local_80 = DAT_10012054 & 0xfffffffb;
  local_70 = 8;
  local_44 = DAT_10012038 & 0xfffffffb;
  local_78 = 8;
  local_40._0_12_ = ZEXT412(DAT_10012044) << 0x40;
  local_40 = CONCAT124(local_40._0_12_ >> 0x20,DAT_1001203c) & (undefined  [16])0xffffffffffffffff;
  local_40 = CONCAT412(DAT_10012048,local_40._0_12_);
  local_30 = DAT_1001204c;
  local_58 = ZEXT816(0);
  local_60 = 0x18;
  local_7c = 0;
  local_84 = 0xc;
  local_48 = 0x1c;
  uStack_158 = 0x10005003;
  local_68 = (uint *)param_1;
  BVar2 = SystemParametersInfoA(0x3b,8,&local_70,0);
  puVar7 = (undefined4 *)(param_1 + 4);
  if (BVar2 == 0) {
    FUN_10002250(puVar7,"sticky keys ",(int *)0xc);
    local_61 = '\0';
  }
  uStack_158 = 0x10005028;
  BVar2 = SystemParametersInfoA(0x35,8,&local_78,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"toggle keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if (0xfff < local_18 + 1) {
        pvVar6 = *(void **)((int)local_2c[0] + -4);
        if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar6);
    }
    local_61 = '\0';
  }
  uStack_158 = 0x1000508c;
  BVar2 = SystemParametersInfoA(0x33,0x18,&local_60,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"filter keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if (0xfff < local_18 + 1) {
        pvVar6 = *(void **)((int)local_2c[0] + -4);
        if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar6);
    }
    local_61 = '\0';
  }
  uStack_158 = 0x100050f0;
  BVar2 = SystemParametersInfoA(0x43,0xc,&local_84,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"hight contrast keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if (0xfff < local_18 + 1) {
        pvVar6 = *(void **)((int)local_2c[0] + -4);
        if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar6);
    }
    local_61 = '\0';
  }
  uStack_158 = 0x10005154;
  BVar2 = SystemParametersInfoA(0x37,0x1c,&local_48,0);
  if (BVar2 == 0) {
    ppvVar3 = (void **)FUN_100056c0(local_2c,puVar7,"mouse keys ");
    FUN_10005640(puVar7,ppvVar3);
    if (0xf < local_18) {
      pvVar6 = local_2c[0];
      if (0xfff < local_18 + 1) {
        pvVar6 = *(void **)((int)local_2c[0] + -4);
        if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar6))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar6);
    }
    local_61 = '\0';
  }
  else if (local_61 != '\0') goto LAB_100052b6;
  FUN_10001b00(local_138);
  puVar1 = (undefined *)local_68;
  local_8 = 0;
  puVar7 = (undefined4 *)((int)local_68 + 4);
  piVar4 = FUN_100023d0(local_128,"Failed to disable ");
  if (0xf < *(uint *)(puVar1 + 0x18)) {
    puVar7 = (undefined4 *)*puVar7;
  }
  piVar4 = FUN_10004740(piVar4,(char *)puVar7,*(uint *)(puVar1 + 0x14));
  DVar5 = GetLastError();
  piVar4 = FUN_100023d0(piVar4,"ease of access keys [error code: ");
  piVar4 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                            ((basic_ostream_char_struct_std__char_traits_char___ *)piVar4,DVar5);
  FUN_100023d0(piVar4,"].");
  local_68 = &uStack_158;
  uStack_158 = uStack_158 & 0xffffff00;
  FUN_10002250(&uStack_158,"ERROR",(int *)0x5);
  local_8._0_1_ = 1;
  FUN_10001a40(local_138,&stack0xfffffe90);
  local_8 = (uint)local_8._1_3_ << 8;
  FUN_10005830(in_stack_fffffe90);
  *(undefined ***)((int)local_138 + *(int *)(local_138[0] + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_120 + *(int *)(local_138[0] + 4) + -0x1c) = *(int *)(local_138[0] + 4) + -0x68
  ;
  FUN_100020a0(local_120);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(local_118);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(local_d0);
LAB_100052b6:
  ExceptionList = local_10;
  local_138[0] = 0x100052cd;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall FUN_100052e0(char *param_1)

{
  bool bVar1;
  char *pcVar2;
  BOOL BVar3;
  void **ppvVar4;
  int *piVar5;
  DWORD DVar6;
  void *pvVar7;
  undefined4 *puVar8;
  undefined4 *in_stack_fffffee0;
  uint uStack_108;
  int local_e4 [4];
  int local_d4 [2];
  undefined4 local_cc [2];
  basic_iostream_char_struct_std__char_traits_char___ local_c4 [72];
  basic_ios_char_struct_std__char_traits_char___ local_7c [76];
  uint *local_30;
  void *local_2c [5];
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = -1;
  puStack_c = &LAB_1000b893;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  bVar1 = true;
  local_30 = (uint *)param_1;
  if (*param_1 != '\0') {
    *param_1 = '\0';
    uStack_108 = 0x10005334;
    BVar3 = SystemParametersInfoA(0x3b,8,&DAT_1001205c,0);
    if (BVar3 == 0) {
      ppvVar4 = (void **)FUN_100056c0(local_2c,(undefined4 *)(param_1 + 4),"Sticky Keys ");
      FUN_10005640(param_1 + 4,ppvVar4);
      if (0xf < local_18) {
        pvVar7 = local_2c[0];
        if (0xfff < local_18 + 1) {
          pvVar7 = *(void **)((int)local_2c[0] + -4);
          if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar7))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar7);
      }
      bVar1 = false;
    }
    puVar8 = (undefined4 *)(param_1 + 4);
    uStack_108 = 0x1000539c;
    BVar3 = SystemParametersInfoA(0x35,8,&DAT_10012064,0);
    if (BVar3 == 0) {
      ppvVar4 = (void **)FUN_100056c0(local_2c,puVar8,"Toggle Keys ");
      FUN_10005640(puVar8,ppvVar4);
      if (0xf < local_18) {
        pvVar7 = local_2c[0];
        if (0xfff < local_18 + 1) {
          pvVar7 = *(void **)((int)local_2c[0] + -4);
          if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar7))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar7);
      }
      bVar1 = false;
    }
    uStack_108 = 0x100053ff;
    BVar3 = SystemParametersInfoA(0x33,0x18,&DAT_1001206c,0);
    if (BVar3 == 0) {
      ppvVar4 = (void **)FUN_100056c0(local_2c,puVar8,"Filter Keys ");
      FUN_10005640(puVar8,ppvVar4);
      if (0xf < local_18) {
        pvVar7 = local_2c[0];
        if (0xfff < local_18 + 1) {
          pvVar7 = *(void **)((int)local_2c[0] + -4);
          if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar7))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar7);
      }
      bVar1 = false;
    }
    uStack_108 = 0x10005462;
    BVar3 = SystemParametersInfoA(0x37,0x1c,&DAT_10012034,0);
    if (BVar3 == 0) {
      ppvVar4 = (void **)FUN_100056c0(local_2c,puVar8,"Mouse Keys ");
      FUN_10005640(puVar8,ppvVar4);
      if (0xf < local_18) {
        pvVar7 = local_2c[0];
        if (0xfff < local_18 + 1) {
          pvVar7 = *(void **)((int)local_2c[0] + -4);
          if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar7))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar7);
      }
      bVar1 = false;
    }
    uStack_108 = 0x100054c5;
    BVar3 = SystemParametersInfoA(0x43,0xc,&DAT_10012050,0);
    if (BVar3 == 0) {
      ppvVar4 = (void **)FUN_100056c0(local_2c,puVar8,"High Contrast Keys ");
      FUN_10005640(puVar8,ppvVar4);
      if (0xf < local_18) {
        pvVar7 = local_2c[0];
        if (0xfff < local_18 + 1) {
          pvVar7 = *(void **)((int)local_2c[0] + -4);
          if (0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar7))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar7);
      }
    }
    else if (bVar1) goto LAB_1000561a;
    FUN_10001b00(local_e4);
    pcVar2 = (char *)local_30;
    local_8 = 0;
    puVar8 = (undefined4 *)((int)local_30 + 4);
    piVar5 = FUN_100023d0(local_d4,"Failed to restore");
    if (0xf < *(uint *)(pcVar2 + 0x18)) {
      puVar8 = (undefined4 *)*puVar8;
    }
    piVar5 = FUN_10004740(piVar5,(char *)puVar8,*(uint *)(pcVar2 + 0x14));
    DVar6 = GetLastError();
    piVar5 = FUN_100023d0(piVar5,"ease of access keys [error code: ");
    piVar5 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar5,DVar6);
    FUN_100023d0(piVar5,"].");
    local_30 = &uStack_108;
    uStack_108 = uStack_108 & 0xffffff00;
    FUN_10002250(&uStack_108,"ERROR",(int *)0x5);
    local_8._0_1_ = 1;
    FUN_10001a40(local_e4,&stack0xfffffee0);
    local_8 = (uint)local_8._1_3_ << 8;
    FUN_10005830(in_stack_fffffee0);
    *(undefined ***)((int)local_e4 + *(int *)(local_e4[0] + 4)) =
         std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
         vftable;
    *(int *)((int)local_cc + *(int *)(local_e4[0] + 4) + -0x1c) = *(int *)(local_e4[0] + 4) + -0x68;
    FUN_100020a0(local_cc);
    std::basic_iostream<char,struct_std::char_traits<char>_>::
    _basic_iostream_char_struct_std__char_traits_char___(local_c4);
    std::basic_ios<char,struct_std::char_traits<char>_>::
    _basic_ios_char_struct_std__char_traits_char___(local_7c);
  }
LAB_1000561a:
  ExceptionList = local_10;
  local_e4[0] = 0x10005632;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void ** __thiscall FUN_10005640(void *this,void **param_1)

{
  void *pvVar1;
  void *pvVar2;
  void *pvVar3;
  
  if ((void **)this != param_1) {
    if (0xf < *(uint *)((int)this + 0x14)) {
                    // WARNING: Load size is inaccurate
      pvVar1 = *this;
      pvVar3 = pvVar1;
      if ((0xfff < *(uint *)((int)this + 0x14) + 1) &&
         (pvVar3 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar3)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar3);
    }
    *(undefined4 *)((int)this + 0x10) = 0;
    *(undefined4 *)((int)this + 0x14) = 0xf;
    *(undefined *)this = 0;
    pvVar1 = param_1[1];
    pvVar3 = param_1[2];
    pvVar2 = param_1[3];
    *(void **)this = *param_1;
    *(void **)((int)this + 4) = pvVar1;
    *(void **)((int)this + 8) = pvVar3;
    *(void **)((int)this + 0xc) = pvVar2;
    *(undefined8 *)((int)this + 0x10) = *(undefined8 *)(param_1 + 4);
    param_1[4] = (void *)0x0;
    param_1[5] = (void *)0xf;
    *(undefined *)param_1 = 0;
  }
  return (void **)this;
}



undefined4 * __fastcall FUN_100056c0(undefined4 *param_1,undefined4 *param_2,char *param_3)

{
  char cVar1;
  int iVar2;
  undefined4 *puVar3;
  char *pcVar4;
  uint uVar5;
  undefined4 *local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000b919;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  param_1[4] = 0;
  param_1[5] = 0xf;
  *(undefined *)param_1 = 0;
  local_8 = 0;
  pcVar4 = param_3;
  do {
    cVar1 = *pcVar4;
    pcVar4 = pcVar4 + 1;
  } while (cVar1 != '\0');
  FUN_100028d0(param_1,pcVar4 + (param_2[4] - (int)(param_3 + 1)));
  local_14 = param_2;
  if (0xf < (uint)param_2[5]) {
    local_14 = (undefined4 *)*param_2;
  }
  puVar3 = local_14;
  iVar2 = param_1[4];
  uVar5 = param_2[4];
  if ((uint)(param_1[5] - iVar2) < uVar5) {
    local_14 = (undefined4 *)((uint)local_14 & 0xffffff00);
    FUN_10002770(param_1,uVar5,local_14,puVar3,uVar5);
  }
  else {
    param_1[4] = iVar2 + uVar5;
    puVar3 = param_1;
    if (0xf < (uint)param_1[5]) {
      puVar3 = (undefined4 *)*param_1;
    }
    memmove((void *)((int)puVar3 + iVar2),local_14,uVar5);
    *(undefined *)((int)(void *)((int)puVar3 + iVar2) + uVar5) = 0;
  }
  pcVar4 = param_3;
  do {
    cVar1 = *pcVar4;
    pcVar4 = pcVar4 + 1;
  } while (cVar1 != '\0');
  uVar5 = (int)pcVar4 - (int)(param_3 + 1);
  iVar2 = param_1[4];
  if (uVar5 <= (uint)(param_1[5] - iVar2)) {
    param_1[4] = iVar2 + uVar5;
    puVar3 = param_1;
    if (0xf < (uint)param_1[5]) {
      puVar3 = (undefined4 *)*param_1;
    }
    memmove((void *)((int)puVar3 + iVar2),param_3,uVar5);
    *(undefined *)((int)(void *)((int)puVar3 + iVar2) + uVar5) = 0;
    ExceptionList = local_10;
    return param_1;
  }
  local_14 = (undefined4 *)((uint)local_14 & 0xffffff00);
  FUN_10002770(param_1,uVar5,local_14,param_3,uVar5);
  ExceptionList = local_10;
  return param_1;
}



void __cdecl FUN_10005810(int *param_1,undefined4 param_2,undefined4 param_3)

{
  (**(code **)(*param_1 + 0x238))(param_1,param_2,param_3,&stack0x00000010);
  return;
}



void __cdecl FUN_10005830(undefined4 *param_1)

{
  int iVar1;
  int iVar2;
  undefined4 *puVar3;
  undefined4 **ppuVar4;
  undefined4 uStack00000014;
  uint in_stack_00000018;
  undefined4 *in_stack_0000001c;
  uint in_stack_00000030;
  int local_1c;
  int *local_18;
  int *local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000b950;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  local_8 = 1;
  iVar1 = JNI_GetCreatedJavaVMs(&local_18,1,&local_1c,DAT_10012024 ^ (uint)&stack0xfffffffc);
  if ((iVar1 == 0) && (local_1c != 0)) {
    iVar1 = (**(code **)(*local_18 + 0x18))(local_18,&local_14,0x10006);
    if (iVar1 == -2) {
      iVar1 = (**(code **)(*local_18 + 0x10))(local_18,&local_14,0);
    }
    if (iVar1 == 0) {
      iVar1 = (**(code **)(*local_14 + 0x18))
                        (local_14,"com/vue/browserlock/win/natives/NativeProxy");
      if (iVar1 != 0) {
        iVar2 = (**(code **)(*local_14 + 0x1c4))
                          (local_14,iVar1,&DAT_1000d908,"(Ljava/lang/String;Ljava/lang/String;)V");
        if (iVar2 != 0) {
          ppuVar4 = &param_1;
          if (0xf < in_stack_00000018) {
            ppuVar4 = (undefined4 **)param_1;
          }
          (**(code **)(*local_14 + 0x29c))(local_14,ppuVar4);
          puVar3 = &stack0x0000001c;
          if (0xf < in_stack_00000030) {
            puVar3 = in_stack_0000001c;
          }
          (**(code **)(*local_14 + 0x29c))(local_14,puVar3);
          FUN_10005810(local_14,iVar1,iVar2);
        }
      }
    }
  }
  if (0xf < in_stack_00000018) {
    puVar3 = param_1;
    if (0xfff < in_stack_00000018 + 1) {
      puVar3 = (undefined4 *)param_1[-1];
      if (0x1f < (uint)((int)param_1 + (-4 - (int)puVar3))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(puVar3);
  }
  uStack00000014 = 0;
  in_stack_00000018 = 0xf;
  param_1 = (undefined4 *)((uint)param_1 & 0xffffff00);
  if (0xf < in_stack_00000030) {
    puVar3 = in_stack_0000001c;
    if (0xfff < in_stack_00000030 + 1) {
      puVar3 = (undefined4 *)in_stack_0000001c[-1];
      if (0x1f < (uint)((int)in_stack_0000001c + (-4 - (int)puVar3))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(puVar3);
  }
  ExceptionList = local_10;
  return;
}



void __fastcall FUN_100059c0(int param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  if (0xf < *(uint *)(param_1 + 0x78)) {
    pvVar1 = *(void **)(param_1 + 100);
    pvVar2 = pvVar1;
    if ((0xfff < *(uint *)(param_1 + 0x78) + 1) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2))))
    goto LAB_10005b1b;
    FUN_1000a4db(pvVar2);
  }
  *(undefined4 *)(param_1 + 0x74) = 0;
  *(undefined4 *)(param_1 + 0x78) = 0xf;
  *(undefined *)(param_1 + 100) = 0;
  if (0xf < *(uint *)(param_1 + 0x60)) {
    pvVar1 = *(void **)(param_1 + 0x4c);
    pvVar2 = pvVar1;
    if ((0xfff < *(uint *)(param_1 + 0x60) + 1) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2))))
    goto LAB_10005b1b;
    FUN_1000a4db(pvVar2);
  }
  *(undefined4 *)(param_1 + 0x5c) = 0;
  *(undefined4 *)(param_1 + 0x60) = 0xf;
  *(undefined *)(param_1 + 0x4c) = 0;
  if (0xf < *(uint *)(param_1 + 0x48)) {
    pvVar1 = *(void **)(param_1 + 0x34);
    pvVar2 = pvVar1;
    if ((0xfff < *(uint *)(param_1 + 0x48) + 1) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2))))
    goto LAB_10005b1b;
    FUN_1000a4db(pvVar2);
  }
  *(undefined4 *)(param_1 + 0x44) = 0;
  *(undefined4 *)(param_1 + 0x48) = 0xf;
  *(undefined *)(param_1 + 0x34) = 0;
  if (0xf < *(uint *)(param_1 + 0x30)) {
    pvVar1 = *(void **)(param_1 + 0x1c);
    pvVar2 = pvVar1;
    if ((0xfff < *(uint *)(param_1 + 0x30) + 1) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2))))
    goto LAB_10005b1b;
    FUN_1000a4db(pvVar2);
  }
  *(undefined4 *)(param_1 + 0x2c) = 0;
  *(undefined4 *)(param_1 + 0x30) = 0xf;
  *(undefined *)(param_1 + 0x1c) = 0;
  if (0xf < *(uint *)(param_1 + 0x18)) {
    pvVar1 = *(void **)(param_1 + 4);
    pvVar2 = pvVar1;
    if ((0xfff < *(uint *)(param_1 + 0x18) + 1) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2)))) {
LAB_10005b1b:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  *(undefined4 *)(param_1 + 0x14) = 0;
  *(undefined4 *)(param_1 + 0x18) = 0xf;
  *(undefined *)(param_1 + 4) = 0;
  return;
}



undefined * __thiscall FUN_10005b30(void *this,undefined *param_1)

{
  int *piVar1;
  undefined4 *puVar2;
  void *pvVar3;
  undefined *puVar4;
  basic_ostream_char_struct_std__char_traits_char___ local_b8 [8];
  undefined4 local_b0 [2];
  basic_iostream_char_struct_std__char_traits_char___ local_a8 [72];
  basic_ios_char_struct_std__char_traits_char___ local_60 [80];
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000b97b;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  FUN_10001b00((int *)&stack0xffffff38);
  local_8 = 0;
                    // WARNING: Load size is inaccurate
  puVar2 = (undefined4 *)((int)this + 4);
  piVar1 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                            (local_b8,*this);
  piVar1 = FUN_100023d0(piVar1,"|");
  if (0xf < *(uint *)((int)this + 0x18)) {
    puVar2 = (undefined4 *)*puVar2;
  }
  piVar1 = FUN_10004740(piVar1,(char *)puVar2,*(uint *)((int)this + 0x14));
  puVar2 = (undefined4 *)((int)this + 0x1c);
  piVar1 = FUN_100023d0(piVar1,"|");
  if (0xf < *(uint *)((int)this + 0x30)) {
    puVar2 = (undefined4 *)*puVar2;
  }
  piVar1 = FUN_10004740(piVar1,(char *)puVar2,*(uint *)((int)this + 0x2c));
  puVar2 = (undefined4 *)((int)this + 0x34);
  piVar1 = FUN_100023d0(piVar1,"|");
  if (0xf < *(uint *)((int)this + 0x48)) {
    puVar2 = (undefined4 *)*puVar2;
  }
  piVar1 = FUN_10004740(piVar1,(char *)puVar2,*(uint *)((int)this + 0x44));
  puVar2 = (undefined4 *)((int)this + 0x4c);
  piVar1 = FUN_100023d0(piVar1,"|");
  if (0xf < *(uint *)((int)this + 0x60)) {
    puVar2 = (undefined4 *)*puVar2;
  }
  piVar1 = FUN_10004740(piVar1,(char *)puVar2,*(uint *)((int)this + 0x5c));
  puVar2 = (undefined4 *)((int)this + 100);
  piVar1 = FUN_100023d0(piVar1,"|");
  if (0xf < *(uint *)((int)this + 0x78)) {
    puVar2 = (undefined4 *)*puVar2;
  }
  piVar1 = FUN_10004740(piVar1,(char *)puVar2,*(uint *)((int)this + 0x74));
  pvVar3 = *(void **)((int)this + 0x7c);
  piVar1 = FUN_100023d0(piVar1,"|");
  std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
            ((basic_ostream_char_struct_std__char_traits_char___ *)piVar1,pvVar3);
  puVar4 = param_1;
  FUN_10001a40(&stack0xffffff38,param_1);
  *(undefined ***)(local_a8 + *(int *)(puVar4 + 4) + -0x20) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_b0 + *(int *)(puVar4 + 4) + -0x1c) = *(int *)(puVar4 + 4) + -0x68;
  FUN_100020a0(local_b0);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(local_a8);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(local_60);
  ExceptionList = local_10;
  return param_1;
}



undefined * FUN_10005cd0(void)

{
  return &DAT_100126f8;
}



int __cdecl FUN_10005ce0(undefined4 param_1,undefined4 param_2,undefined4 param_3)

{
  undefined4 *puVar1;
  int iVar2;
  
  puVar1 = (undefined4 *)FUN_10005cd0();
  iVar2 = __stdio_common_vsprintf_s(*puVar1,puVar1[1]);
  if (iVar2 < 0) {
    iVar2 = -1;
  }
  return iVar2;
}



void __fastcall FUN_10005d20(undefined *param_1,DWORD param_2)

{
  char cVar1;
  HANDLE hProcess;
  BOOL BVar2;
  char *pcVar3;
  undefined *local_11c;
  CHAR local_118 [260];
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000b9c2;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  local_8 = 0;
  *(undefined4 *)(param_1 + 0x10) = 0;
  *(undefined4 *)(param_1 + 0x14) = 0xf;
  *param_1 = 0;
  local_11c = param_1;
  FUN_10002250(param_1,&DAT_1000d90e,(int *)0x0);
  local_8 = 0;
  hProcess = OpenProcess(0x410,0,param_2);
  if (hProcess != (HANDLE)0x0) {
    memset(local_118,0,0x104);
    local_11c = (undefined *)0x104;
    BVar2 = QueryFullProcessImageNameA(hProcess,0,local_118,(PDWORD)&local_11c);
    if (BVar2 != 0) {
      pcVar3 = local_118;
      do {
        cVar1 = *pcVar3;
        pcVar3 = pcVar3 + 1;
      } while (cVar1 != '\0');
      FUN_10002250(param_1,local_118,(int *)(pcVar3 + -(int)(local_118 + 1)));
    }
  }
  CloseHandle(hProcess);
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __thiscall FUN_10005e30(void *this,undefined4 *param_1)

{
  char cVar1;
  LANGID LVar2;
  DWORD dwLen;
  LPCVOID lpData;
  undefined4 **ppuVar3;
  BOOL BVar4;
  undefined4 ****ppppuVar5;
  char *pcVar6;
  void *this_00;
  void *pvVar7;
  int *piVar8;
  undefined4 *puVar9;
  undefined4 uStack00000014;
  uint in_stack_00000018;
  void *in_stack_0000001c;
  uint in_stack_00000030;
  undefined2 *local_840;
  undefined4 local_83c;
  char *local_838;
  DWORD local_834;
  uint local_830;
  undefined4 ****local_82c [4];
  undefined4 local_81c;
  uint local_818;
  char local_814 [1024];
  char local_414 [1024];
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000ba2d;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  local_83c = 0;
  local_8 = 2;
  *(undefined4 *)((int)this + 0x10) = 0;
  *(undefined4 *)((int)this + 0x14) = 0xf;
  local_834 = 0;
  *(undefined *)this = 0;
  local_838 = (char *)this;
  FUN_10002250(this,&DAT_1000d90e,(int *)0x0);
  local_83c = 1;
  ppuVar3 = &param_1;
  if (0xf < in_stack_00000018) {
    ppuVar3 = (undefined4 **)param_1;
  }
  dwLen = GetFileVersionInfoSizeA((LPCSTR)ppuVar3,&local_834);
  if (dwLen != 0) {
    lpData = (LPCVOID)FUN_1000a4e9(dwLen);
    local_830 = 0;
    ppuVar3 = &param_1;
    if (0xf < in_stack_00000018) {
      ppuVar3 = (undefined4 **)param_1;
    }
    BVar4 = GetFileVersionInfoA((LPCSTR)ppuVar3,local_834,dwLen,lpData);
    if ((BVar4 != 0) && (lpData != (LPCVOID)0x0)) {
      local_81c = 0;
      local_818 = 0xf;
      local_82c[0] = (undefined4 ****)((uint)local_82c[0] & 0xffffff00);
      FUN_10002250(local_82c,"\\VarFileInfo\\Translation",(int *)0x18);
      local_8 = CONCAT31(local_8._1_3_,3);
      ppppuVar5 = local_82c;
      if (0xf < local_818) {
        ppppuVar5 = local_82c[0];
      }
      BVar4 = VerQueryValueA(lpData,(LPCSTR)ppppuVar5,&local_840,&local_830);
      if (((BVar4 == 0) || (local_830 == 0)) || (local_840 == (undefined2 *)0x0)) {
        LVar2 = GetUserDefaultLangID();
        FUN_10007d70(this_00,local_414,"%04X04B0",(char)LVar2);
        pcVar6 = local_414;
        do {
          cVar1 = *pcVar6;
          pcVar6 = pcVar6 + 1;
        } while (cVar1 != '\0');
      }
      else {
        FUN_10007d70(local_840,local_414,"%04x%04x",(char)*local_840);
        pcVar6 = local_414;
        do {
          cVar1 = *pcVar6;
          pcVar6 = pcVar6 + 1;
        } while (cVar1 != '\0');
      }
      FUN_10002250(this,local_414,(int *)(pcVar6 + -(int)(local_414 + 1)));
      pvVar7 = this;
      if (0xf < *(uint *)((int)this + 0x14)) {
                    // WARNING: Load size is inaccurate
        pvVar7 = *this;
      }
      FUN_10007d70(pvVar7,local_814,"\\StringFileInfo\\%s\\%s",(char)pvVar7);
      pcVar6 = local_814;
      do {
        cVar1 = *pcVar6;
        pcVar6 = pcVar6 + 1;
      } while (cVar1 != '\0');
      FUN_10002250(local_82c,local_814,(int *)(pcVar6 + -(int)(local_814 + 1)));
      local_830 = 0;
      ppppuVar5 = local_82c;
      if (0xf < local_818) {
        ppppuVar5 = local_82c[0];
      }
      BVar4 = VerQueryValueA(lpData,(LPCSTR)ppppuVar5,&local_838,&local_830);
      if ((BVar4 == 0) || (local_830 == 0)) {
        piVar8 = (int *)0x0;
        pcVar6 = "";
      }
      else {
        pcVar6 = local_838;
        do {
          cVar1 = *pcVar6;
          pcVar6 = pcVar6 + 1;
        } while (cVar1 != '\0');
        piVar8 = (int *)(pcVar6 + -(int)(local_838 + 1));
        pcVar6 = local_838;
      }
      FUN_10002250(this,pcVar6,piVar8);
      if (0xf < local_818) {
        ppppuVar5 = local_82c[0];
        if ((0xfff < local_818 + 1) &&
           (ppppuVar5 = (undefined4 ****)local_82c[0][-1],
           (LPCSTR)0x1f < (LPCSTR)((int)local_82c[0] + (-4 - (int)ppppuVar5)))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
        FUN_1000a4db(ppppuVar5);
      }
    }
    free(lpData);
  }
  if (0xf < in_stack_00000018) {
    puVar9 = param_1;
    if ((0xfff < in_stack_00000018 + 1) &&
       (puVar9 = (undefined4 *)param_1[-1], 0x1f < (uint)((int)param_1 + (-4 - (int)puVar9)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(puVar9);
  }
  uStack00000014 = 0;
  in_stack_00000018 = 0xf;
  param_1 = (undefined4 *)((uint)param_1 & 0xffffff00);
  if (0xf < in_stack_00000030) {
    pvVar7 = in_stack_0000001c;
    if ((0xfff < in_stack_00000030 + 1) &&
       (pvVar7 = *(void **)((int)in_stack_0000001c + -4),
       0x1f < (uint)((int)in_stack_0000001c + (-4 - (int)pvVar7)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar7);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void * __fastcall FUN_10006190(void *param_1,DWORD param_2,void *param_3)

{
  void *pvVar1;
  uint in_stack_00000018;
  undefined4 *in_stack_ffffffac;
  undefined auStack_3c [12];
  undefined4 uStack_30;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000ba70;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  local_8 = 0;
  FUN_100043a0(auStack_3c,&param_3);
  local_8._0_1_ = 1;
  FUN_10005d20(&stack0xffffffac,param_2);
  local_8 = (uint)local_8._1_3_ << 8;
  FUN_10005e30(param_1,in_stack_ffffffac);
  if (0xf < in_stack_00000018) {
    pvVar1 = param_3;
    if (0xfff < in_stack_00000018 + 1) {
      pvVar1 = *(void **)((int)param_3 + -4);
      if (0x1f < (uint)((int)param_3 + (-4 - (int)pvVar1))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    uStack_30 = 0x1000622a;
    FUN_1000a4db(pvVar1);
  }
  ExceptionList = local_10;
  return param_1;
}



void __fastcall FUN_10006240(undefined4 *param_1,int param_2)

{
  char cVar1;
  HANDLE hObject;
  int iVar2;
  char *pcVar3;
  void *pvVar4;
  undefined4 local_154 [2];
  int local_14c;
  char local_130 [260];
  void *local_2c [4];
  undefined4 local_1c;
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000bab2;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  local_8 = 0;
  param_1[4] = 0;
  param_1[5] = 0xf;
  *(undefined *)param_1 = 0;
  FUN_10002250(param_1,&DAT_1000d90e,(int *)0x0);
  local_8 = 0;
  hObject = (HANDLE)CreateToolhelp32Snapshot(2,0);
  local_154[0] = 0x128;
  Process32First(hObject,local_154);
  while (param_2 != local_14c) {
    iVar2 = Process32Next(hObject,local_154);
    if (iVar2 == 0) goto LAB_10006372;
  }
  pcVar3 = local_130;
  local_1c = 0;
  local_18 = 0xf;
  local_2c[0] = (void *)((uint)local_2c[0] & 0xffffff00);
  do {
    cVar1 = *pcVar3;
    pcVar3 = pcVar3 + 1;
  } while (cVar1 != '\0');
  FUN_10002250(local_2c,local_130,(int *)(pcVar3 + -(int)(local_130 + 1)));
  FUN_10005640(param_1,local_2c);
  if (0xf < local_18) {
    pvVar4 = local_2c[0];
    if ((0xfff < local_18 + 1) &&
       (pvVar4 = *(void **)((int)local_2c[0] + -4),
       0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar4);
  }
LAB_10006372:
  CloseHandle(hObject);
  if (param_1[4] != 0) {
    FUN_10006d30(param_1);
    FUN_10006d90(param_1);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall FUN_100063b0(void **param_1)

{
  char cVar1;
  uint uVar2;
  HANDLE hObject;
  int iVar3;
  uint uVar4;
  char *pcVar5;
  int ****ppppiVar6;
  int ****ppppiVar7;
  int iVar8;
  int iVar9;
  bool bVar10;
  undefined4 local_16c [9];
  char local_148 [260];
  int ****local_44 [4];
  uint local_34;
  uint local_30;
  int ****local_2c [4];
  uint local_1c;
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8._0_1_ = 0xff;
  local_8._1_3_ = 0xffffff;
  puStack_c = &LAB_1000baf0;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  hObject = (HANDLE)CreateToolhelp32Snapshot(2,0);
  local_16c[0] = 0x128;
  Process32First(hObject,local_16c);
  do {
    FUN_100043a0(local_44,param_1);
    local_8 = 0;
    ppppiVar6 = (int ****)local_44;
    if (0xf < local_30) {
      ppppiVar6 = local_44[0];
    }
    ppppiVar7 = (int ****)local_44;
    if (0xf < local_30) {
      ppppiVar7 = local_44[0];
    }
    iVar9 = (int)(int ****)(local_34 + (int)ppppiVar6) - (int)ppppiVar7;
    iVar8 = 0;
    if ((int ****)(local_34 + (int)ppppiVar6) < ppppiVar7) {
      iVar9 = 0;
    }
    if (iVar9 != 0) {
      do {
        iVar3 = tolower((int)*(char *)(iVar8 + (int)ppppiVar7));
        *(char *)(iVar8 + (int)ppppiVar6) = (char)iVar3;
        iVar8 = iVar8 + 1;
      } while (iVar8 != iVar9);
    }
    FUN_10006d90(local_44);
    pcVar5 = local_148;
    local_1c = 0;
    local_18 = 0xf;
    local_2c[0] = (int ****)((uint)local_2c[0] & 0xffffff00);
    do {
      cVar1 = *pcVar5;
      pcVar5 = pcVar5 + 1;
    } while (cVar1 != '\0');
    FUN_10002250(local_2c,local_148,(int *)(pcVar5 + -(int)(local_148 + 1)));
    local_8._0_1_ = 1;
    ppppiVar6 = (int ****)local_2c;
    if (0xf < local_18) {
      ppppiVar6 = local_2c[0];
    }
    ppppiVar7 = (int ****)local_2c;
    if (0xf < local_18) {
      ppppiVar7 = local_2c[0];
    }
    iVar9 = (int)(int ****)(local_1c + (int)ppppiVar6) - (int)ppppiVar7;
    iVar8 = 0;
    if ((int ****)(local_1c + (int)ppppiVar6) < ppppiVar7) {
      iVar9 = 0;
    }
    if (iVar9 != 0) {
      do {
        iVar3 = tolower((int)(char)*(byte *)(iVar8 + (int)ppppiVar7));
        *(byte *)(iVar8 + (int)ppppiVar6) = (byte)iVar3;
        iVar8 = iVar8 + 1;
      } while (iVar8 != iVar9);
    }
    FUN_10006d90(local_2c);
    ppppiVar6 = (int ****)local_44;
    if (0xf < local_30) {
      ppppiVar6 = local_44[0];
    }
    ppppiVar7 = (int ****)local_2c;
    if (0xf < local_18) {
      ppppiVar7 = local_2c[0];
    }
    uVar4 = local_1c;
    if (local_1c == local_34) {
      while (uVar2 = uVar4 - 4, 3 < uVar4) {
        if (*ppppiVar7 != *ppppiVar6) goto LAB_10006576;
        ppppiVar7 = ppppiVar7 + 1;
        ppppiVar6 = ppppiVar6 + 1;
        uVar4 = uVar2;
      }
      if (uVar2 == 0xfffffffc) {
LAB_100065aa:
        uVar4 = 0;
      }
      else {
LAB_10006576:
        bVar10 = *(byte *)ppppiVar7 < *(byte *)ppppiVar6;
        if ((*(byte *)ppppiVar7 == *(byte *)ppppiVar6) &&
           ((uVar2 == 0xfffffffd ||
            ((bVar10 = *(byte *)((int)ppppiVar7 + 1) < *(byte *)((int)ppppiVar6 + 1),
             *(byte *)((int)ppppiVar7 + 1) == *(byte *)((int)ppppiVar6 + 1) &&
             ((uVar2 == 0xfffffffe ||
              ((bVar10 = *(byte *)((int)ppppiVar7 + 2) < *(byte *)((int)ppppiVar6 + 2),
               *(byte *)((int)ppppiVar7 + 2) == *(byte *)((int)ppppiVar6 + 2) &&
               ((uVar2 == 0xffffffff ||
                (bVar10 = *(byte *)((int)ppppiVar7 + 3) < *(byte *)((int)ppppiVar6 + 3),
                *(byte *)((int)ppppiVar7 + 3) == *(byte *)((int)ppppiVar6 + 3)))))))))))))
        goto LAB_100065aa;
        uVar4 = -(uint)bVar10 | 1;
      }
      if (uVar4 == 0) {
        if (0xf < local_18) {
          ppppiVar6 = local_2c[0];
          if ((0xfff < local_18 + 1) &&
             (ppppiVar6 = (int ****)local_2c[0][-1],
             (byte *)0x1f < (byte *)((int)local_2c[0] + (-4 - (int)ppppiVar6)))) goto LAB_1000668d;
          FUN_1000a4db(ppppiVar6);
        }
        local_1c = 0;
        local_18 = 0xf;
        local_2c[0] = (int ****)((uint)local_2c[0] & 0xffffff00);
        if (0xf < local_30) {
          ppppiVar6 = local_44[0];
          if ((0xfff < local_30 + 1) &&
             (ppppiVar6 = (int ****)local_44[0][-1],
             0x1f < (uint)((int)local_44[0] + (-4 - (int)ppppiVar6)))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
          FUN_1000a4db(ppppiVar6);
        }
        break;
      }
    }
    local_8._0_1_ = 0;
    if (0xf < local_18) {
      ppppiVar6 = local_2c[0];
      if ((0xfff < local_18 + 1) &&
         (ppppiVar6 = (int ****)local_2c[0][-1],
         (byte *)0x1f < (byte *)((int)local_2c[0] + (-4 - (int)ppppiVar6)))) goto LAB_1000668d;
      FUN_1000a4db(ppppiVar6);
    }
    local_8._0_1_ = 0xff;
    local_8._1_3_ = 0xffffff;
    local_1c = 0;
    local_18 = 0xf;
    local_2c[0] = (int ****)((uint)local_2c[0] & 0xffffff00);
    if (0xf < local_30) {
      ppppiVar6 = local_44[0];
      if ((0xfff < local_30 + 1) &&
         (ppppiVar6 = (int ****)local_44[0][-1],
         0x1f < (uint)((int)local_44[0] + (-4 - (int)ppppiVar6)))) {
LAB_1000668d:
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(ppppiVar6);
    }
    iVar8 = Process32Next(hObject,local_16c);
  } while (iVar8 != 0);
  CloseHandle(hObject);
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Function: __alloca_probe replaced with injection: alloca_probe

void __fastcall FUN_10006720(void *param_1)

{
  int *piVar1;
  int iVar2;
  int *piVar3;
  uint local_100c;
  int local_1008 [1024];
  uint local_8;
  
  local_8 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  iVar2 = K32EnumProcesses(local_1008,0x1000,&local_100c);
  if ((iVar2 != 0) && (local_100c = local_100c >> 2, local_100c != 0)) {
    piVar3 = local_1008;
    do {
      if (*piVar3 != 0) {
        piVar1 = *(int **)((int)param_1 + 4);
        if (*(int **)((int)param_1 + 8) == piVar1) {
          FUN_10007d90(param_1,piVar1,piVar3);
        }
        else {
          *piVar1 = *piVar3;
          *(int *)((int)param_1 + 4) = *(int *)((int)param_1 + 4) + 4;
        }
      }
      piVar3 = piVar3 + 1;
      local_100c = local_100c - 1;
    } while (local_100c != 0);
  }
  ___security_check_cookie_4(local_8 ^ (uint)&stack0xfffffffc);
  return;
}



void __fastcall FUN_100067b0(DWORD *param_1,DWORD param_2,char param_3)

{
  DWORD *this;
  void **ppvVar1;
  int iVar2;
  DWORD **this_00;
  void *pvVar3;
  void *pvVar4;
  uint in_stack_ffffff98;
  void *local_30 [5];
  uint local_1c;
  uint local_18;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000bb39;
  local_10 = ExceptionList;
  local_18 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  this_00 = (DWORD **)(param_1 + 1);
  this = param_1 + 0x19;
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined *)this_00 = 0;
  param_1[0xb] = 0;
  param_1[0xc] = 0xf;
  *(undefined *)(param_1 + 7) = 0;
  param_1[0x11] = 0;
  param_1[0x12] = 0xf;
  *(undefined *)(param_1 + 0xd) = 0;
  param_1[0x17] = 0;
  param_1[0x18] = 0xf;
  *(undefined *)(param_1 + 0x13) = 0;
  param_1[0x1d] = 0;
  param_1[0x1e] = 0xf;
  *(undefined *)this = 0;
  param_1[0x1f] = 0;
  local_8 = 0;
  *param_1 = param_2;
  ppvVar1 = (void **)FUN_10006240(local_30,param_2);
  FUN_10005640(this_00,ppvVar1);
  if (0xf < local_1c) {
    pvVar4 = local_30[0];
    if (0xfff < local_1c + 1) {
      pvVar4 = *(void **)((int)local_30[0] + -4);
      if (0x1f < (uint)((int)local_30[0] + (-4 - (int)pvVar4))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar4);
  }
  pvVar4 = (void *)(in_stack_ffffff98 & 0xffffff00);
  FUN_10002250(&stack0xffffff98,"InternalName",(int *)0xc);
  ppvVar1 = (void **)FUN_10006190(local_30,param_2,pvVar4);
  FUN_10005640(param_1 + 0xd,ppvVar1);
  if (0xf < local_1c) {
    pvVar3 = local_30[0];
    if (0xfff < local_1c + 1) {
      pvVar3 = *(void **)((int)local_30[0] + -4);
      if (0x1f < (uint)((int)local_30[0] + (-4 - (int)pvVar3))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(pvVar3);
  }
  if (param_3 == '\0') {
    if ((param_1[5] != 0) || (param_1[5] != 0)) {
      iVar2 = FUN_10007090(param_2);
      if (iVar2 == 0) {
        FUN_10002250(param_1 + 7,&DAT_1000d90e,(int *)0x0);
      }
      else {
        iVar2 = FUN_10007090(param_2);
        ppvVar1 = (void **)FUN_10006240(local_30,iVar2);
        FUN_10005640(param_1 + 7,ppvVar1);
        if (0xf < local_1c) {
          pvVar3 = local_30[0];
          if (0xfff < local_1c + 1) {
            pvVar3 = *(void **)((int)local_30[0] + -4);
            if (0x1f < (uint)((int)local_30[0] + (-4 - (int)pvVar3))) {
                    // WARNING: Subroutine does not return
              _invalid_parameter_noinfo_noreturn();
            }
          }
          FUN_1000a4db(pvVar3);
        }
      }
      ppvVar1 = (void **)FUN_10005d20((undefined *)local_30,param_2);
      FUN_10005640(param_1 + 0x13,ppvVar1);
      if (0xf < local_1c) {
        pvVar3 = local_30[0];
        if (0xfff < local_1c + 1) {
          pvVar3 = *(void **)((int)local_30[0] + -4);
          if (0x1f < (uint)((int)local_30[0] + (-4 - (int)pvVar3))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar3);
      }
    }
    pvVar4 = (void *)((uint)pvVar4 & 0xffffff00);
    FUN_10002250(&stack0xffffff98,"FileDescription",(int *)0xf);
    ppvVar1 = (void **)FUN_10006190(local_30,param_2,pvVar4);
    FUN_10005640(this,ppvVar1);
    if (0xf < local_1c) {
      pvVar4 = local_30[0];
      if (0xfff < local_1c + 1) {
        pvVar4 = *(void **)((int)local_30[0] + -4);
        if (0x1f < (uint)((int)local_30[0] + (-4 - (int)pvVar4))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar4);
    }
    if ((param_1[0x1d] == 0) || (param_1[0x17] == 0)) {
      ppvVar1 = (void **)FUN_10006e40((uint *)local_30,param_2);
      FUN_10005640(this,ppvVar1);
      if (0xf < local_1c) {
        pvVar4 = local_30[0];
        if (0xfff < local_1c + 1) {
          pvVar4 = *(void **)((int)local_30[0] + -4);
          if (0x1f < (uint)((int)local_30[0] + (-4 - (int)pvVar4))) {
                    // WARNING: Subroutine does not return
            _invalid_parameter_noinfo_noreturn();
          }
        }
        FUN_1000a4db(pvVar4);
      }
    }
  }
  if ((param_1[0x1d] == 0) && (param_1[0x1d] == 0)) {
    if ((DWORD **)this != this_00) {
      if (0xf < param_1[6]) {
        this_00 = (DWORD **)*this_00;
      }
      FUN_10002250(this,this_00,(int *)param_1[5]);
    }
  }
  else {
    FUN_10006d30(this);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_18 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void FUN_10006b00(HWND param_1,void *param_2)

{
  void **ppvVar1;
  BOOL BVar2;
  uint uVar3;
  int ****ppppiVar4;
  undefined4 *puVar5;
  char *pcVar6;
  int iVar7;
  bool bVar8;
  DWORD local_98;
  void *local_94;
  int ****local_90 [4];
  int local_80;
  uint local_7c;
  void *local_78 [6];
  void *local_60 [6];
  void *local_48 [6];
  void *local_30 [6];
  HWND local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000bba3;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  BVar2 = IsWindowVisible(param_1);
  if ((BVar2 != 0) && (BVar2 = IsWindow(param_1), BVar2 != 0)) {
    local_98 = 0;
    GetWindowThreadProcessId(param_1,&local_98);
    FUN_100067b0((DWORD *)&local_94,local_98,'\0');
    local_8 = 0;
    ppppiVar4 = (int ****)local_90;
    if (0xf < local_7c) {
      ppppiVar4 = local_90[0];
    }
    local_18 = param_1;
    if (local_80 == 5) {
      puVar5 = &DAT_1000da40;
      iVar7 = 1;
      if (*ppppiVar4 == (int ***)0x75766e6f) {
        ppppiVar4 = ppppiVar4 + 1;
        iVar7 = -3;
        puVar5 = (undefined4 *)&DAT_1000da44;
      }
      bVar8 = *(byte *)ppppiVar4 < *(byte *)puVar5;
      if ((*(byte *)ppppiVar4 == *(byte *)puVar5) &&
         ((iVar7 == -3 ||
          (((bVar8 = *(byte *)((int)ppppiVar4 + 1) < *(byte *)((int)puVar5 + 1),
            *(byte *)((int)ppppiVar4 + 1) == *(byte *)((int)puVar5 + 1) &&
            (bVar8 = *(byte *)((int)ppppiVar4 + 2) < *(byte *)((int)puVar5 + 2),
            *(byte *)((int)ppppiVar4 + 2) == *(byte *)((int)puVar5 + 2))) &&
           (bVar8 = *(byte *)((int)ppppiVar4 + 3) < *(byte *)((int)puVar5 + 3),
           *(byte *)((int)ppppiVar4 + 3) == *(byte *)((int)puVar5 + 3))))))) {
        uVar3 = 0;
      }
      else {
        uVar3 = -(uint)bVar8 | 1;
      }
      if ((uVar3 == 0) && (DAT_100126d0 == (HWND)0x0)) {
        DAT_100126d0 = param_1;
      }
    }
    ppppiVar4 = (int ****)local_90;
    if (0xf < local_7c) {
      ppppiVar4 = local_90[0];
    }
    if (local_80 == 0xb) {
      pcVar6 = "browserlock";
      uVar3 = 7;
      do {
        if (*ppppiVar4 != *(int ****)pcVar6) break;
        ppppiVar4 = ppppiVar4 + 1;
        pcVar6 = (char *)((int)pcVar6 + 4);
        bVar8 = 3 < uVar3;
        uVar3 = uVar3 - 4;
      } while (bVar8);
      bVar8 = *(byte *)ppppiVar4 < (byte)*pcVar6;
      if (((*(byte *)ppppiVar4 == *pcVar6) &&
          (bVar8 = *(byte *)((int)ppppiVar4 + 1) < *(byte *)((int)pcVar6 + 1),
          *(byte *)((int)ppppiVar4 + 1) == *(byte *)((int)pcVar6 + 1))) &&
         ((bVar8 = *(byte *)((int)ppppiVar4 + 2) < *(byte *)((int)pcVar6 + 2),
          *(byte *)((int)ppppiVar4 + 2) == *(byte *)((int)pcVar6 + 2) &&
          ((uVar3 == 0xffffffff ||
           (bVar8 = *(byte *)((int)ppppiVar4 + 3) < *(byte *)((int)pcVar6 + 3),
           *(byte *)((int)ppppiVar4 + 3) == *(byte *)((int)pcVar6 + 3))))))) {
        uVar3 = 0;
      }
      else {
        uVar3 = -(uint)bVar8 | 1;
      }
      if (uVar3 == 0) {
        DAT_100126c8 = param_1;
      }
    }
    ppvVar1 = *(void ***)((int)param_2 + 4);
    if (*(void ***)((int)param_2 + 8) == ppvVar1) {
      FUN_10007f90(param_2,ppvVar1,&local_94);
    }
    else {
      *ppvVar1 = local_94;
      FUN_100043a0(ppvVar1 + 1,local_90);
      local_8._0_1_ = 1;
      FUN_100043a0(ppvVar1 + 7,local_78);
      local_8._0_1_ = 2;
      FUN_100043a0(ppvVar1 + 0xd,local_60);
      local_8._0_1_ = 3;
      FUN_100043a0(ppvVar1 + 0x13,local_48);
      local_8 = CONCAT31(local_8._1_3_,4);
      FUN_100043a0(ppvVar1 + 0x19,local_30);
      ppvVar1[0x1f] = local_18;
      *(int *)((int)param_2 + 4) = *(int *)((int)param_2 + 4) + 0x80;
    }
    FUN_100059c0((int)&local_94);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void __fastcall FUN_10006d30(undefined4 *param_1)

{
  int *piVar1;
  int iVar2;
  undefined4 *puVar3;
  int iVar4;
  int iVar5;
  undefined4 *local_8;
  
  puVar3 = param_1;
  local_8 = param_1;
  if (0xf < (uint)param_1[5]) {
    local_8 = (undefined4 *)*param_1;
    puVar3 = (undefined4 *)*param_1;
  }
  piVar1 = param_1 + 4;
  if (0xf < (uint)param_1[5]) {
    param_1 = (undefined4 *)*param_1;
  }
  iVar4 = (int)(undefined4 *)(*piVar1 + (int)puVar3) - (int)param_1;
  iVar5 = 0;
  if ((undefined4 *)(*piVar1 + (int)puVar3) < param_1) {
    iVar4 = 0;
  }
  if (iVar4 != 0) {
    do {
      iVar2 = tolower((int)*(char *)(iVar5 + (int)param_1));
      *(char *)(iVar5 + (int)local_8) = (char)iVar2;
      iVar5 = iVar5 + 1;
    } while (iVar5 != iVar4);
  }
  return;
}



void __fastcall FUN_10006d90(undefined4 *param_1)

{
  int iVar1;
  int *piVar2;
  undefined4 *puVar3;
  void *pvVar4;
  void *local_20 [4];
  undefined4 local_10;
  uint local_c;
  uint local_8;
  
  local_8 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  iVar1 = FUN_10007cd0(param_1);
  if (iVar1 != 0) {
    local_10 = 0;
    local_c = 0xf;
    local_20[0] = (void *)((uint)local_20[0] & 0xffffff00);
    piVar2 = (int *)FUN_10007cd0(param_1);
    if ((int *)param_1[4] < piVar2) {
      piVar2 = (int *)param_1[4];
    }
    puVar3 = param_1;
    if (0xf < (uint)param_1[5]) {
      puVar3 = (undefined4 *)*param_1;
    }
    FUN_10002250(local_20,puVar3,piVar2);
    FUN_10005640(param_1,local_20);
    if (0xf < local_c) {
      pvVar4 = local_20[0];
      if (0xfff < local_c + 1) {
        pvVar4 = *(void **)((int)local_20[0] + -4);
        if (0x1f < (uint)((int)local_20[0] + (-4 - (int)pvVar4))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar4);
    }
  }
  ___security_check_cookie_4(local_8 ^ (uint)&stack0xfffffffc);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall FUN_10006e40(uint *param_1,int param_2)

{
  char cVar1;
  char *pcVar2;
  char *pcVar3;
  void *pvVar4;
  LPBYTE pBVar5;
  int iStack_80;
  LPBYTE local_78;
  int local_74;
  int local_70;
  int local_6c;
  SC_HANDLE local_68;
  uint local_64;
  uint *local_60;
  uint local_5c;
  uint local_58;
  void *local_54 [4];
  undefined4 local_44;
  uint local_40;
  uint local_3c;
  uint uStack_38;
  uint uStack_34;
  uint uStack_30;
  undefined4 local_2c;
  undefined4 uStack_28;
  uint local_24;
  undefined *puStack_20;
  void *local_1c;
  undefined *puStack_18;
  undefined4 local_14;
  
  puStack_20 = &stack0xfffffffc;
  local_14 = 0xffffffff;
  puStack_18 = &LAB_1000bbe0;
  local_1c = ExceptionList;
  local_24 = DAT_10012024 ^ (uint)&stack0xfffffff0;
  ExceptionList = &local_1c;
  local_2c = 0;
  uStack_28 = 0xf;
  local_3c = local_3c & 0xffffff00;
  local_6c = param_2;
  local_60 = param_1;
  FUN_10002250(&local_3c,&DAT_1000d90e,(int *)0x0);
  local_14 = 0;
  local_68 = OpenSCManagerA((LPCSTR)0x0,(LPCSTR)0x0,4);
  if (local_68 == (SC_HANDLE)0x0) {
    param_1[4] = 0;
    param_1[5] = 0;
    *param_1 = local_3c;
    param_1[1] = uStack_38;
    param_1[2] = uStack_34;
    param_1[3] = uStack_30;
    *(ulonglong *)(param_1 + 4) = CONCAT44(uStack_28,local_2c);
  }
  else {
    local_5c = 0;
    local_58 = 0;
    EnumServicesStatusExA
              (local_68,SC_ENUM_PROCESS_INFO,0x3ff,3,(LPBYTE)0x0,0,&local_5c,&local_58,(LPDWORD)0x0,
               (LPCSTR)0x0);
    FUN_10007c30(&local_78,local_5c);
    local_14 = CONCAT31(local_14._1_3_,1);
    EnumServicesStatusExA
              (local_68,SC_ENUM_PROCESS_INFO,0x3ff,3,local_78,local_74 - (int)local_78,&local_5c,
               &local_58,(LPDWORD)0x0,(LPCSTR)0x0);
    local_64 = 0;
    pBVar5 = local_78;
    if (local_58 != 0) {
      do {
        pcVar2 = *(char **)(pBVar5 + 4);
        iStack_80 = (int)((ulonglong)*(undefined8 *)(pBVar5 + 0x20) >> 0x20);
        if (iStack_80 == local_6c) {
          local_44 = 0;
          local_40 = 0xf;
          local_54[0] = (void *)((uint)local_54[0] & 0xffffff00);
          local_60 = (uint *)(pcVar2 + 1);
          pcVar3 = pcVar2;
          do {
            cVar1 = *pcVar3;
            pcVar3 = pcVar3 + 1;
          } while (cVar1 != '\0');
          FUN_10002250(local_54,pcVar2,(int *)(pcVar3 + -(int)local_60));
          FUN_10005640(&local_3c,local_54);
          if (0xf < local_40) {
            pvVar4 = local_54[0];
            if ((0xfff < local_40 + 1) &&
               (pvVar4 = *(void **)((int)local_54[0] + -4),
               0x1f < (uint)((int)local_54[0] + (-4 - (int)pvVar4)))) goto LAB_10007058;
            FUN_1000a4db(pvVar4);
          }
        }
        local_64 = local_64 + 1;
        pBVar5 = pBVar5 + 0x2c;
      } while (local_64 < local_58);
    }
    CloseServiceHandle(local_68);
    param_1[4] = 0;
    param_1[5] = 0;
    *param_1 = local_3c;
    param_1[1] = uStack_38;
    param_1[2] = uStack_34;
    param_1[3] = uStack_30;
    *(ulonglong *)(param_1 + 4) = CONCAT44(uStack_28,local_2c);
    if (local_78 != (LPBYTE)0x0) {
      pBVar5 = local_78;
      if ((0xfff < (uint)(local_70 - (int)local_78)) &&
         (pBVar5 = *(LPBYTE *)(local_78 + -4), (LPBYTE)0x1f < local_78 + (-4 - (int)pBVar5))) {
LAB_10007058:
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pBVar5);
    }
  }
  ExceptionList = local_1c;
  ___security_check_cookie_4(local_24 ^ (uint)&stack0xfffffff0);
  return;
}



void __fastcall FUN_10007090(int param_1)

{
  HANDLE hObject;
  int iVar1;
  undefined4 local_13c;
  undefined4 local_138 [2];
  int local_130;
  undefined4 local_120;
  uint local_c;
  
  local_c = DAT_10012024 ^ (uint)&local_13c;
  local_13c = 0;
  hObject = (HANDLE)CreateToolhelp32Snapshot(2,0);
  local_138[0] = 0x128;
  Process32First(hObject,local_138);
  do {
    if (param_1 == local_130) {
      local_13c = local_120;
      break;
    }
    iVar1 = Process32Next(hObject,local_138);
  } while (iVar1 != 0);
  CloseHandle(hObject);
  ___security_check_cookie_4(local_c ^ (uint)&local_13c);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall FUN_10007120(void **param_1)

{
  size_t _Size;
  void *_Size_00;
  undefined4 ***pppuVar1;
  undefined4 ***pppuVar2;
  undefined4 ***pppuVar3;
  undefined4 ****ppppuVar4;
  BOOL BVar5;
  void **_Src;
  HWND pHVar6;
  char *pcVar7;
  uint uVar8;
  HWND pHVar9;
  HWND__ in_stack_ffffff04;
  undefined local_e4 [4];
  undefined4 uStack_e0;
  HWND local_bc;
  HWND local_b8;
  HWND local_b4;
  HWND local_b0;
  HWND local_ac;
  undefined4 ***local_a8;
  undefined4 ****local_a4;
  HWND local_a0;
  undefined4 ****local_9c [4];
  int local_8c;
  uint uStack_88;
  undefined4 ****local_84;
  undefined4 ***pppuStack_80;
  undefined4 ***pppuStack_7c;
  undefined4 ***pppuStack_78;
  undefined8 local_74;
  undefined4 ****local_6c;
  undefined4 ***pppuStack_68;
  undefined4 ***pppuStack_64;
  undefined4 ***pppuStack_60;
  undefined8 local_5c;
  undefined4 ****local_54;
  undefined4 ***pppuStack_50;
  undefined4 ***pppuStack_4c;
  undefined4 ***pppuStack_48;
  undefined8 local_44;
  char local_28;
  undefined local_27 [7];
  undefined *puStack_20;
  void *local_1c;
  undefined *puStack_18;
  undefined4 local_14;
  
  puStack_20 = &stack0xfffffffc;
  local_14 = 0xffffffff;
  puStack_18 = &LAB_1000bc49;
  local_1c = ExceptionList;
  local_27._3_4_ = DAT_10012024 ^ (uint)&stack0xfffffff0;
  ExceptionList = &local_1c;
  local_a0 = (HWND)param_1;
  local_a8 = (undefined4 ***)FUN_100063b0(param_1);
  pHVar9 = (HWND)0x0;
  local_bc = (HWND)0x0;
  local_b8 = (HWND)0x0;
  local_b0 = (HWND)0x0;
  local_b4 = (HWND)0x0;
  local_14 = 0;
  pHVar6 = (HWND)0x0;
  do {
    uStack_e0 = 0x100071a4;
    pHVar6 = FindWindowExA((HWND)0x0,pHVar6,(LPCSTR)0x0,(LPCSTR)0x0);
    local_a4 = (undefined4 ****)0x0;
    local_ac = pHVar6;
    GetWindowThreadProcessId(pHVar6,(LPDWORD)&local_a4);
    if (local_a4 == (undefined4 ****)local_a8) {
      if (local_b0 == pHVar9) {
        FUN_10007d90(&local_bc,pHVar9,&local_ac);
        local_b0 = local_b4;
        pHVar6 = local_ac;
        pHVar9 = local_b8;
      }
      else {
        pHVar9->unused = (int)pHVar6;
        local_b8 = pHVar9 + 1;
        pHVar9 = local_b8;
      }
    }
  } while (pHVar6 != (HWND)0x0);
  local_e4[0] = 0;
  FUN_10002250(local_e4,&DAT_1000d57c,(int *)0x4);
  local_14._0_1_ = 1;
  pcVar7 = &local_28 + 1;
  local_ac = (HWND)((int)pHVar9 - (int)local_bc);
  ppppuVar4 = (undefined4 ****)((int)local_ac >> 2);
  do {
    pcVar7 = pcVar7 + -1;
    local_a4 = (undefined4 ****)((uint)ppppuVar4 / 10);
    *pcVar7 = (char)ppppuVar4 + (char)local_a4 * -10 + '0';
    ppppuVar4 = local_a4;
  } while (local_a4 != (undefined4 ****)0x0);
  local_8c = 0;
  uStack_88 = 0xf;
  local_9c[0] = (undefined4 ****)((uint)local_9c[0] & 0xffffff00);
  if (pcVar7 != &local_28 + 1) {
    FUN_10002250(local_9c,pcVar7,(int *)(&local_28 + 1 + -(int)pcVar7));
  }
  local_14 = CONCAT31(local_14._1_3_,2);
  if (uStack_88 - local_8c < 6) {
    local_a8 = (undefined4 ***)((uint)local_a8 & 0xffffff00);
    in_stack_ffffff04.unused = 0x10007391;
    ppppuVar4 = (undefined4 ****)FUN_100082d0(local_9c,6);
  }
  else {
    ppppuVar4 = local_9c;
    if (0xf < uStack_88) {
      ppppuVar4 = local_9c[0];
    }
    if (((undefined4 ****)0x1000da7d < ppppuVar4) ||
       ((char *)((int)ppppuVar4 + local_8c) < "Found ")) {
      local_a4 = (undefined4 ****)0x6;
    }
    else if ("Found " < ppppuVar4) {
      local_a4 = ppppuVar4 + -0x400369e;
    }
    else {
      local_a4 = (undefined4 ****)0x0;
    }
    _Size = local_8c + 1;
    local_8c = local_8c + 6;
    memmove((char *)((int)ppppuVar4 + 6),ppppuVar4,_Size);
    memcpy(ppppuVar4,"Found ",(size_t)local_a4);
    memcpy((char *)((int)ppppuVar4 + (int)local_a4),(char *)((int)local_a4 + 0x1000da7e),
           6 - (int)local_a4);
    ppppuVar4 = local_9c;
  }
  local_74 = 0;
  local_84 = (undefined4 ****)*ppppuVar4;
  pppuStack_80 = ppppuVar4[1];
  pppuStack_7c = ppppuVar4[2];
  pppuStack_78 = ppppuVar4[3];
  local_74 = *(ulonglong *)(ppppuVar4 + 4);
  ppppuVar4[4] = (undefined4 ***)0x0;
  ppppuVar4[5] = (undefined4 ***)0xf;
  *(undefined *)ppppuVar4 = 0;
  local_14 = CONCAT31(local_14._1_3_,3);
  if (local_74._4_4_ == (uint)local_74) {
    local_a8 = (undefined4 ***)((uint)local_a8 & 0xffffff00);
    ppppuVar4 = (undefined4 ****)FUN_10002770(&local_84,1,local_a8,&DAT_1000da74,1);
  }
  else {
    ppppuVar4 = &local_84;
    if (0xf < local_74._4_4_) {
      ppppuVar4 = local_84;
    }
    local_74 = local_74 & 0xffffffff00000000 | (ulonglong)((uint)local_74 + 1);
    memmove((void *)((int)ppppuVar4 + (uint)local_74),&DAT_1000da74,1);
    *(undefined *)((int)(void *)((int)ppppuVar4 + (uint)local_74) + 1) = 0;
    ppppuVar4 = &local_84;
  }
  local_44 = 0;
  local_54 = (undefined4 ****)*ppppuVar4;
  pppuStack_50 = ppppuVar4[1];
  pppuStack_4c = ppppuVar4[2];
  pppuStack_48 = ppppuVar4[3];
  local_44 = *(ulonglong *)(ppppuVar4 + 4);
  ppppuVar4[4] = (undefined4 ***)0x0;
  ppppuVar4[5] = (undefined4 ***)0xf;
  *(undefined *)ppppuVar4 = 0;
  local_14 = CONCAT31(local_14._1_3_,4);
  _Src = (void **)local_a0;
  if ((void *)0xf < *(void **)(local_a0 + 5)) {
    _Src = *(void ***)local_a0;
  }
  _Size_00 = *(void **)(local_a0 + 4);
  if ((void *)(local_44._4_4_ - (int)local_44) < _Size_00) {
    local_a0 = (HWND)((uint)_Size_00 & 0xffffff00);
    ppppuVar4 = (undefined4 ****)
                FUN_10002770(&local_54,(uint)_Size_00,local_a0,_Src,(size_t)_Size_00);
  }
  else {
    local_44 = local_44 & 0xffffffff00000000 | (ulonglong)(uint)((int)_Size_00 + (int)local_44);
    ppppuVar4 = &local_54;
    if (0xf < local_44._4_4_) {
      ppppuVar4 = local_54;
    }
    local_a0 = (HWND)_Size_00;
    memmove((void *)((int)local_44 + (int)ppppuVar4),_Src,(size_t)_Size_00);
    *(undefined *)((int)(void *)((int)local_44 + (int)ppppuVar4) + (int)local_a0) = 0;
    ppppuVar4 = &local_54;
  }
  local_5c = 0;
  local_6c = (undefined4 ****)*ppppuVar4;
  pppuStack_68 = ppppuVar4[1];
  pppuStack_64 = ppppuVar4[2];
  pppuStack_60 = ppppuVar4[3];
  local_5c = *(ulonglong *)(ppppuVar4 + 4);
  ppppuVar4[4] = (undefined4 ***)0x0;
  ppppuVar4[5] = (undefined4 ***)0xf;
  *(undefined *)ppppuVar4 = 0;
  local_a0 = (HWND)&stack0xffffff04;
  pHVar6 = (HWND)&stack0xffffff04;
  local_14 = CONCAT31(local_14._1_3_,5);
  local_5c._4_4_ = (uint)(local_5c >> 0x20);
  if (local_5c._4_4_ - (int)local_5c < 0x14) {
    local_a0 = (HWND)&stack0xffffff00;
    ppppuVar4 = (undefined4 ****)FUN_10002770(&local_6c,0x14,local_a0," windows to restore.",0x14);
  }
  else {
    ppppuVar4 = &local_6c;
    if (0xf < local_5c._4_4_) {
      ppppuVar4 = local_6c;
    }
    local_5c = local_5c & 0xffffffff00000000 | (ulonglong)((int)local_5c + 0x14);
    memmove((void *)((int)ppppuVar4 + (int)local_5c)," windows to restore.",0x14);
    *(undefined *)((int)(void *)((int)ppppuVar4 + (int)local_5c) + 0x14) = 0;
    ppppuVar4 = &local_6c;
    pHVar6 = local_a0;
  }
  pHVar6[4].unused = 0;
  pHVar6[5].unused = 0;
  pppuVar1 = ppppuVar4[1];
  pppuVar2 = ppppuVar4[2];
  pppuVar3 = ppppuVar4[3];
  pHVar6->unused = (int)*ppppuVar4;
  pHVar6[1].unused = (int)pppuVar1;
  pHVar6[2].unused = (int)pppuVar2;
  pHVar6[3].unused = (int)pppuVar3;
  *(undefined8 *)(pHVar6 + 4) = *(undefined8 *)(ppppuVar4 + 4);
  ppppuVar4[4] = (undefined4 ***)0x0;
  ppppuVar4[5] = (undefined4 ***)0xf;
  *(undefined *)ppppuVar4 = 0;
  local_14 = CONCAT31(local_14._1_3_,9);
  FUN_10005830((undefined4 *)in_stack_ffffff04.unused);
  if (0xf < local_5c._4_4_) {
    ppppuVar4 = local_6c;
    if ((0xfff < local_5c._4_4_ + 1) &&
       (ppppuVar4 = (undefined4 ****)local_6c[-1],
       0x1f < (uint)((int)local_6c + (-4 - (int)ppppuVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(ppppuVar4);
  }
  local_5c = 0xf00000000;
  local_6c = (undefined4 ****)((uint)local_6c & 0xffffff00);
  if (0xf < local_44._4_4_) {
    ppppuVar4 = local_54;
    if ((0xfff < local_44._4_4_ + 1) &&
       (ppppuVar4 = (undefined4 ****)local_54[-1],
       0x1f < (uint)((int)local_54 + (-4 - (int)ppppuVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(ppppuVar4);
  }
  local_44 = 0xf00000000;
  local_54 = (undefined4 ****)((uint)local_54 & 0xffffff00);
  if (0xf < local_74._4_4_) {
    ppppuVar4 = local_84;
    if ((0xfff < local_74._4_4_ + 1) &&
       (ppppuVar4 = (undefined4 ****)local_84[-1],
       0x1f < (uint)((int)local_84 + (-4 - (int)ppppuVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(ppppuVar4);
  }
  local_74 = 0xf00000000;
  local_84 = (undefined4 ****)((uint)local_84 & 0xffffff00);
  if (0xf < uStack_88) {
    ppppuVar4 = local_9c[0];
    if ((0xfff < uStack_88 + 1) &&
       (ppppuVar4 = (undefined4 ****)local_9c[0][-1],
       (char *)0x1f < (char *)((int)local_9c[0] + (-4 - (int)ppppuVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(ppppuVar4);
  }
  local_a8 = (undefined4 ***)((uint)((int)&local_ac->unused + 3U) >> 2);
  uVar8 = 0;
  if (pHVar9 < local_bc) {
    local_a8 = (undefined4 ***)0x0;
  }
  pHVar6 = local_bc;
  if (local_a8 != (undefined4 ***)0x0) {
    do {
      local_a0 = (HWND)pHVar6->unused;
      BVar5 = IsWindowVisible(local_a0);
      if (BVar5 != 0) {
        uStack_e0 = 0x100076eb;
        PostMessageA(local_a0,0x112,0xf120,0);
      }
      uVar8 = uVar8 + 1;
      pHVar6 = pHVar6 + 1;
    } while ((undefined4 ***)uVar8 != local_a8);
  }
  if (local_bc != (HWND)0x0) {
    pHVar6 = local_bc;
    if ((0xfff < ((int)local_b0 - (int)local_bc & 0xfffffffcU)) &&
       (pHVar6 = (HWND)local_bc[-1].unused, 0x1f < (uint)((int)local_bc + (-4 - (int)pHVar6)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pHVar6);
  }
  ExceptionList = local_1c;
  ___security_check_cookie_4(local_27._3_4_ ^ (uint)&stack0xfffffff0);
  return;
}



void __fastcall FUN_10007760(HWND param_1)

{
  undefined local_20 [6];
  undefined2 uStack_1a;
  undefined4 local_18;
  undefined4 local_14;
  undefined4 local_10;
  
  local_20._0_4_ = 1;
  stack0xffffffe4 = 0x12;
  local_14 = 0;
  local_10 = 0;
  local_18 = 0;
  SendInput(1,(LPINPUT)local_20,0x1c);
  SetForegroundWindow(param_1);
  stack0xffffffe4 = CONCAT22(uStack_1a,0x12);
  local_18 = 2;
  SendInput(1,(LPINPUT)local_20,0x1c);
  return;
}



undefined4 FUN_100077d0(HWND param_1,DWORD param_2)

{
  DWORD local_8;
  
  GetWindowThreadProcessId(param_1,&local_8);
  if (local_8 == param_2) {
    DAT_100126cc = param_1;
    return 0;
  }
  return 1;
}



// WARNING: Could not reconcile some variable overlaps

void FUN_10007810(void)

{
  HWND pHVar1;
  int *piVar2;
  uint uVar3;
  LPARAM lParam;
  BOOL BVar4;
  undefined4 *puVar5;
  void *pvVar6;
  int ****ppppiVar7;
  int iVar8;
  bool bVar9;
  uint in_stack_fffffeb8;
  undefined4 *in_stack_fffffebc;
  undefined auStack_12c [8];
  undefined4 uStack_124;
  int local_108 [4];
  int local_f8 [2];
  undefined4 local_f0 [2];
  basic_iostream_char_struct_std__char_traits_char___ local_e8 [72];
  basic_ios_char_struct_std__char_traits_char___ local_a0 [72];
  DWORD local_58;
  undefined *local_54;
  undefined *local_50;
  DWORD local_4c;
  int ****local_48 [4];
  uint local_38;
  uint local_34;
  undefined local_30 [4];
  undefined4 local_2c;
  undefined4 local_28;
  undefined4 local_24;
  undefined4 local_20;
  undefined4 local_1c;
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000bcab;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  AllowSetForegroundWindow(0xffffffff);
  if (DAT_100126c8 == (HWND)0x0) {
    local_50 = &stack0xfffffed0;
    FUN_10002250(&stack0xfffffed0,&DAT_1000d57c,(int *)0x4);
    local_8 = 0;
    puVar5 = (undefined4 *)(in_stack_fffffeb8 & 0xffffff00);
    FUN_10002250(&stack0xfffffeb8,"Get browserlock window handle",(int *)0x1d);
    local_8 = 0xffffffff;
    FUN_10005830(puVar5);
    DAT_100126c8 = GetForegroundWindow();
  }
  pHVar1 = GetForegroundWindow();
  uStack_124 = 0x100078c8;
  GetWindowThreadProcessId(pHVar1,&local_4c);
  FUN_10006240(local_48,local_4c);
  local_8 = 1;
  uStack_124 = 0x100078e8;
  FUN_10001b00(local_108);
  local_8._0_1_ = 2;
  piVar2 = FUN_100023d0(local_f8,"Current foreground window before alt+tab : ");
  ppppiVar7 = (int ****)local_48;
  if (0xf < local_34) {
    ppppiVar7 = local_48[0];
  }
  FUN_10004740(piVar2,(char *)ppppiVar7,local_38);
  local_54 = auStack_12c;
  auStack_12c[0] = 0;
  FUN_10002250(auStack_12c,&DAT_1000d57c,(int *)0x4);
  local_8._0_1_ = 3;
  FUN_10001a40(local_108,&stack0xfffffebc);
  local_8._0_1_ = 2;
  FUN_10005830(in_stack_fffffebc);
  ppppiVar7 = (int ****)local_48;
  if (0xf < local_34) {
    ppppiVar7 = local_48[0];
  }
  if (local_38 == 5) {
    puVar5 = &DAT_1000da40;
    iVar8 = 1;
    if (*ppppiVar7 == (int ***)0x75766e6f) {
      ppppiVar7 = ppppiVar7 + 1;
      iVar8 = -3;
      puVar5 = (undefined4 *)&DAT_1000da44;
    }
    bVar9 = *(byte *)ppppiVar7 < *(byte *)puVar5;
    if ((*(byte *)ppppiVar7 == *(byte *)puVar5) &&
       ((iVar8 == -3 ||
        (((bVar9 = *(byte *)((int)ppppiVar7 + 1) < *(byte *)((int)puVar5 + 1),
          *(byte *)((int)ppppiVar7 + 1) == *(byte *)((int)puVar5 + 1) &&
          (bVar9 = *(byte *)((int)ppppiVar7 + 2) < *(byte *)((int)puVar5 + 2),
          *(byte *)((int)ppppiVar7 + 2) == *(byte *)((int)puVar5 + 2))) &&
         (bVar9 = *(byte *)((int)ppppiVar7 + 3) < *(byte *)((int)puVar5 + 3),
         *(byte *)((int)ppppiVar7 + 3) == *(byte *)((int)puVar5 + 3))))))) {
      uVar3 = 0;
    }
    else {
      uVar3 = -(uint)bVar9 | 1;
    }
    if (uVar3 != 0) goto LAB_100079d4;
    GetWindowThreadProcessId(DAT_100126c8,&local_58);
    SetFocus(DAT_100126c8);
    pHVar1 = DAT_100126c8;
  }
  else {
LAB_100079d4:
    local_1c = 0;
    local_18 = 0xf;
    local_2c = (void *)((uint)local_2c & 0xffffff00);
    FUN_10002250(&local_2c,&DAT_1000da40,(int *)0x5);
    local_8._0_1_ = 4;
    lParam = FUN_100063b0((void **)&local_2c);
    if (0xf < local_18) {
      pvVar6 = local_2c;
      if (0xfff < local_18 + 1) {
        pvVar6 = *(void **)((int)local_2c + -4);
        if (0x1f < (uint)((int)local_2c + (-4 - (int)pvVar6))) {
                    // WARNING: Subroutine does not return
          _invalid_parameter_noinfo_noreturn();
        }
      }
      FUN_1000a4db(pvVar6);
    }
    EnumWindows(FUN_100077d0,lParam);
    BVar4 = IsWindowVisible(DAT_100126cc);
    if (BVar4 != 0) {
      BVar4 = IsWindow(DAT_100126cc);
      if (BVar4 != 0) {
        SetFocus(DAT_100126cc);
        FUN_10007760(DAT_100126cc);
        goto LAB_10007ae0;
      }
    }
    SetFocus(DAT_100126d0);
    pHVar1 = DAT_100126d0;
  }
  local_30 = (undefined  [4])0x1;
  local_2c = (void *)0x12;
  local_24 = 0;
  local_20 = 0;
  local_28 = 0;
  uStack_124 = 0x10007ac4;
  SendInput(1,(LPINPUT)local_30,0x1c);
  SetForegroundWindow(pHVar1);
  local_2c = (void *)CONCAT22(local_2c._2_2_,0x12);
  local_28 = 2;
  uStack_124 = 0x10007ae0;
  SendInput(1,(LPINPUT)local_30,0x1c);
LAB_10007ae0:
  *(undefined ***)((int)local_108 + *(int *)(local_108[0] + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_f0 + *(int *)(local_108[0] + 4) + -0x1c) = *(int *)(local_108[0] + 4) + -0x68;
  FUN_100020a0(local_f0);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(local_e8);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(local_a0);
  if (0xf < local_34) {
    ppppiVar7 = local_48[0];
    if (0xfff < local_34 + 1) {
      ppppiVar7 = (int ****)local_48[0][-1];
      if ((byte *)0x1f < (byte *)((int)local_48[0] + (-4 - (int)ppppiVar7))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
    }
    FUN_1000a4db(ppppiVar7);
  }
  ExceptionList = local_10;
  local_108[0] = 0x10007b78;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void __fastcall FUN_10007b80(void **param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  pvVar1 = *param_1;
  if (pvVar1 != (void *)0x0) {
    pvVar2 = pvVar1;
    if ((0xfff < ((int)param_1[2] - (int)pvVar1 & 0xfffffffcU)) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
    *param_1 = (void *)0x0;
    param_1[1] = (void *)0x0;
    param_1[2] = (void *)0x0;
  }
  return;
}



void __fastcall FUN_10007be0(void **param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  pvVar1 = *param_1;
  if (pvVar1 != (void *)0x0) {
    pvVar2 = pvVar1;
    if ((0xfff < (uint)((int)param_1[2] - (int)pvVar1)) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
    *param_1 = (void *)0x0;
    param_1[1] = (void *)0x0;
    param_1[2] = (void *)0x0;
  }
  return;
}



void ** __thiscall FUN_10007c30(void *this,uint param_1)

{
  void *_Dst;
  code *pcVar1;
  uint uVar2;
  int iVar3;
  void **ppvVar4;
  
  *(undefined4 *)this = 0;
  *(undefined4 *)((int)this + 4) = 0;
  *(undefined4 *)((int)this + 8) = 0;
  if (param_1 != 0) {
    if (0x7fffffff < param_1) {
      FUN_10004730();
      pcVar1 = (code *)swi(3);
      ppvVar4 = (void **)(*pcVar1)();
      return ppvVar4;
    }
    if (param_1 < 0x1000) {
      uVar2 = FUN_1000a4ab(param_1);
    }
    else {
      uVar2 = param_1 + 0x23;
      if (uVar2 <= param_1) {
        uVar2 = 0xffffffff;
      }
      iVar3 = FUN_1000a4ab(uVar2);
      if (iVar3 == 0) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      uVar2 = iVar3 + 0x23U & 0xffffffe0;
      *(int *)(uVar2 - 4) = iVar3;
    }
    *(uint *)this = uVar2;
    *(uint *)((int)this + 4) = uVar2;
                    // WARNING: Load size is inaccurate
    *(uint *)((int)this + 8) = *this + param_1;
                    // WARNING: Load size is inaccurate
    _Dst = *this;
    memset(_Dst,0,param_1);
    *(uint *)((int)this + 4) = (int)_Dst + param_1;
  }
  return (void **)this;
}



int __fastcall FUN_10007cd0(undefined4 *param_1)

{
  uint uVar1;
  byte bVar2;
  int *piVar3;
  uint uVar4;
  undefined4 *_Buf;
  bool bVar5;
  
  _Buf = param_1;
  if (0xf < (uint)param_1[5]) {
    _Buf = (undefined4 *)*param_1;
  }
  uVar1 = param_1[4];
  if (3 < uVar1) {
    piVar3 = (int *)memchr(_Buf,0x2e,uVar1 - 3);
    while( true ) {
      if (piVar3 == (int *)0x0) {
        return -1;
      }
      if ((*piVar3 == 0x6578652e) ||
         ((((bVar2 = (byte)*piVar3, bVar5 = bVar2 < 0x2e, bVar2 == 0x2e &&
            (bVar5 = *(byte *)((int)piVar3 + 1) < 0x65, *(byte *)((int)piVar3 + 1) == 0x65)) &&
           (bVar5 = *(byte *)((int)piVar3 + 2) < 0x78, *(byte *)((int)piVar3 + 2) == 0x78)) &&
          (bVar5 = *(byte *)((int)piVar3 + 3) < 0x65, *(byte *)((int)piVar3 + 3) == 0x65)))) {
        uVar4 = 0;
      }
      else {
        uVar4 = -(uint)bVar5 | 1;
      }
      if (uVar4 == 0) break;
      piVar3 = (int *)memchr((void *)((int)piVar3 + 1),0x2e,
                             (int)_Buf + ((uVar1 - 3) - (int)(void *)((int)piVar3 + 1)));
    }
    return (int)piVar3 - (int)_Buf;
  }
  return -1;
}



void __thiscall FUN_10007d70(void *this,undefined4 param_1,undefined4 param_2,undefined param_3)

{
  FUN_10005ce0(param_2,this,&param_3);
  return;
}



void * __thiscall FUN_10007d90(void *this,void *param_1,undefined4 *param_2)

{
  uint uVar1;
  int iVar2;
  void *pvVar3;
  code *pcVar4;
  int iVar5;
  uint uVar6;
  uint uVar7;
  void *pvVar8;
  uint uVar9;
  void *pvVar10;
  
                    // WARNING: Load size is inaccurate
  iVar2 = *this;
  iVar5 = *(int *)((int)this + 4) - iVar2 >> 2;
  if (iVar5 == 0x3fffffff) {
    FUN_10004730();
    pcVar4 = (code *)swi(3);
    pvVar10 = (void *)(*pcVar4)();
    return pvVar10;
  }
  uVar1 = iVar5 + 1;
  uVar9 = *(int *)((int)this + 8) - iVar2 >> 2;
  uVar6 = uVar1;
  if ((uVar9 <= 0x3fffffff - (uVar9 >> 1)) && (uVar6 = (uVar9 >> 1) + uVar9, uVar6 < uVar1)) {
    uVar6 = uVar1;
  }
  uVar9 = uVar6 * 4;
  if (uVar6 < 0x40000000) {
    uVar6 = uVar9;
    if (0xfff < uVar9) goto LAB_10007dff;
    if (uVar9 == 0) {
      pvVar10 = (void *)0x0;
    }
    else {
      pvVar10 = (void *)FUN_1000a4ab(uVar9);
    }
  }
  else {
    uVar6 = 0xffffffff;
LAB_10007dff:
    uVar7 = uVar6 + 0x23;
    if (uVar7 <= uVar6) {
      uVar7 = 0xffffffff;
    }
    iVar5 = FUN_1000a4ab(uVar7);
    if (iVar5 == 0) goto LAB_10007edf;
    pvVar10 = (void *)(iVar5 + 0x23U & 0xffffffe0);
    *(int *)((int)pvVar10 - 4) = iVar5;
  }
  iVar2 = ((int)param_1 - iVar2 >> 2) * 4;
  *(undefined4 *)(iVar2 + (int)pvVar10) = *param_2;
                    // WARNING: Load size is inaccurate
  pvVar3 = *this;
  if (param_1 == *(void **)((int)this + 4)) {
    memmove(pvVar10,pvVar3,(int)*(void **)((int)this + 4) - (int)pvVar3);
  }
  else {
    memmove(pvVar10,pvVar3,(int)param_1 - (int)pvVar3);
    memmove((void *)(iVar2 + 4 + (int)pvVar10),param_1,*(int *)((int)this + 4) - (int)param_1);
  }
                    // WARNING: Load size is inaccurate
  pvVar3 = *this;
  if (pvVar3 != (void *)0x0) {
    pvVar8 = pvVar3;
    if ((0xfff < (*(int *)((int)this + 8) - (int)pvVar3 & 0xfffffffcU)) &&
       (pvVar8 = *(void **)((int)pvVar3 + -4), 0x1f < (uint)((int)pvVar3 + (-4 - (int)pvVar8)))) {
LAB_10007edf:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar8);
  }
  *(void **)this = pvVar10;
  *(void **)((int)this + 4) = (void *)((int)pvVar10 + uVar1 * 4);
  *(void **)((int)this + 8) = (void *)(uVar9 + (int)pvVar10);
                    // WARNING: Load size is inaccurate
  return (void *)(*this + iVar2);
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall FUN_10007ef0(undefined4 param_1,undefined4 *param_2,undefined4 *param_3)

{
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000bd0c;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  *param_2 = *param_3;
  FUN_100043a0(param_2 + 1,(void **)(param_3 + 1));
  local_8 = 0;
  FUN_100043a0(param_2 + 7,(void **)(param_3 + 7));
  local_8._0_1_ = 1;
  FUN_100043a0(param_2 + 0xd,(void **)(param_3 + 0xd));
  local_8._0_1_ = 2;
  FUN_100043a0(param_2 + 0x13,(void **)(param_3 + 0x13));
  local_8 = CONCAT31(local_8._1_3_,3);
  FUN_100043a0(param_2 + 0x19,(void **)(param_3 + 0x19));
  param_2[0x1f] = param_3[0x1f];
  ExceptionList = local_10;
  return;
}



void * __thiscall FUN_10007f90(void *this,void **param_1,undefined4 *param_2)

{
  uint uVar1;
  int iVar2;
  void **ppvVar3;
  code *pcVar4;
  int iVar5;
  int iVar6;
  uint uVar7;
  uint uVar8;
  void *pvVar9;
  uint uVar10;
  void **ppvVar11;
  void **ppvVar12;
  void *pvVar13;
  void **ppvVar14;
  void *local_10;
  undefined *puStack_c;
  undefined local_8;
  undefined3 uStack_7;
  
  local_8 = 0xff;
  uStack_7 = 0xffffff;
  puStack_c = &LAB_1000bd64;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
                    // WARNING: Load size is inaccurate
  iVar2 = *this;
  iVar5 = (int)param_1 - iVar2 >> 7;
  iVar6 = *(int *)((int)this + 4) - iVar2 >> 7;
  if (iVar6 == 0x1ffffff) {
    FUN_10004730();
    pcVar4 = (code *)swi(3);
    pvVar9 = (void *)(*pcVar4)();
    return pvVar9;
  }
  uVar1 = iVar6 + 1;
  uVar10 = *(int *)((int)this + 8) - iVar2 >> 7;
  uVar7 = uVar1;
  if ((uVar10 <= 0x1ffffff - (uVar10 >> 1)) && (uVar7 = (uVar10 >> 1) + uVar10, uVar7 < uVar1)) {
    uVar7 = uVar1;
  }
  uVar10 = uVar7 << 7;
  if (uVar7 < 0x2000000) {
    if (0xfff < uVar10) goto LAB_10008027;
    if (uVar10 == 0) {
      ppvVar11 = (void **)0x0;
    }
    else {
      ppvVar11 = (void **)FUN_1000a4ab(uVar10);
    }
  }
  else {
    uVar10 = 0xffffffff;
LAB_10008027:
    uVar8 = uVar10 + 0x23;
    if (uVar8 <= uVar10) {
      uVar8 = 0xffffffff;
    }
    pvVar9 = (void *)FUN_1000a4ab(uVar8);
    if (pvVar9 == (void *)0x0) goto LAB_1000804a;
    ppvVar11 = (void **)((int)pvVar9 + 0x23U & 0xffffffe0);
    ppvVar11[-1] = pvVar9;
  }
  ppvVar14 = ppvVar11 + iVar5 * 0x20;
  local_8 = 0;
  uStack_7 = 0;
  FUN_10007ef0(ppvVar14 + 0x20,ppvVar14,param_2);
  ppvVar3 = *(void ***)((int)this + 4);
  if (param_1 == ppvVar3) {
    ppvVar12 = ppvVar11;
                    // WARNING: Load size is inaccurate
    for (ppvVar14 = *this; local_8 = 1, ppvVar14 != ppvVar3; ppvVar14 = ppvVar14 + 0x20) {
      *ppvVar12 = *ppvVar14;
      FUN_100043a0(ppvVar12 + 1,ppvVar14 + 1);
      local_8 = 2;
      FUN_100043a0(ppvVar12 + 7,ppvVar14 + 7);
      local_8 = 3;
      FUN_100043a0(ppvVar12 + 0xd,ppvVar14 + 0xd);
      local_8 = 4;
      FUN_100043a0(ppvVar12 + 0x13,ppvVar14 + 0x13);
      local_8 = 5;
      FUN_100043a0(ppvVar12 + 0x19,ppvVar14 + 0x19);
      ppvVar12[0x1f] = ppvVar14[0x1f];
      ppvVar12 = ppvVar12 + 0x20;
    }
  }
  else {
                    // WARNING: Load size is inaccurate
    FUN_10008200(*this,param_1,ppvVar11);
    FUN_10008200(param_1,*(void ***)((int)this + 4),ppvVar14 + 0x20);
  }
                    // WARNING: Load size is inaccurate
  pvVar9 = *this;
  if (pvVar9 != (void *)0x0) {
    pvVar13 = *(void **)((int)this + 4);
    if (pvVar9 != pvVar13) {
      do {
        FUN_100059c0((int)pvVar9);
        pvVar9 = (void *)((int)pvVar9 + 0x80);
      } while (pvVar9 != pvVar13);
                    // WARNING: Load size is inaccurate
      pvVar9 = *this;
    }
    pvVar13 = pvVar9;
    if ((0xfff < (*(int *)((int)this + 8) - (int)pvVar9 & 0xffffff80U)) &&
       (pvVar13 = *(void **)((int)pvVar9 + -4), 0x1f < (uint)((int)pvVar9 + (-4 - (int)pvVar13)))) {
LAB_1000804a:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar13);
  }
  *(void ***)this = ppvVar11;
  *(void ***)((int)this + 4) = ppvVar11 + uVar1 * 0x20;
  *(void ***)((int)this + 8) = ppvVar11 + uVar7 * 0x20;
                    // WARNING: Load size is inaccurate
  ExceptionList = local_10;
  return (void *)(*this + iVar5 * 0x80);
}



void Catch_All_100081d4(void)

{
  int unaff_EBP;
  
  FUN_10004470(*(int *)(unaff_EBP + -0x18),*(int *)(unaff_EBP + -0x20));
  FUN_100044a0(*(void **)(unaff_EBP + -0x28),*(int *)(unaff_EBP + -0x1c));
                    // WARNING: Subroutine does not return
  _CxxThrowException((void *)0x0,(ThrowInfo *)0x0);
}



void ** FUN_10008200(void **param_1,void **param_2,void **param_3)

{
  void **ppvVar1;
  void **ppvVar2;
  void *local_10;
  undefined *puStack_c;
  undefined local_8;
  undefined3 uStack_7;
  
  puStack_c = &LAB_1000bdb4;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  uStack_7 = 0;
  if (param_1 != param_2) {
    ppvVar2 = param_1 + 7;
    do {
      local_8 = 0;
      *param_3 = ppvVar2[-7];
      FUN_100043a0(param_3 + 1,ppvVar2 + -6);
      local_8 = 1;
      FUN_100043a0(param_3 + 7,ppvVar2);
      local_8 = 2;
      FUN_100043a0(param_3 + 0xd,ppvVar2 + 6);
      local_8 = 3;
      FUN_100043a0(param_3 + 0x13,ppvVar2 + 0xc);
      local_8 = 4;
      FUN_100043a0(param_3 + 0x19,ppvVar2 + 0x12);
      param_3[0x1f] = ppvVar2[0x18];
      param_3 = param_3 + 0x20;
      ppvVar1 = ppvVar2 + 0x19;
      ppvVar2 = ppvVar2 + 0x20;
    } while (ppvVar1 != param_2);
  }
  ExceptionList = local_10;
  return param_3;
}



void ** __thiscall FUN_100082d0(void *this,uint param_1)

{
  int iVar1;
  uint uVar2;
  void *_Src;
  code *pcVar3;
  uint uVar4;
  uint uVar5;
  int iVar6;
  void **ppvVar7;
  void *_Dst;
  uint uVar8;
  void *pvVar9;
  size_t in_stack_00000014;
  
  iVar1 = *(int *)((int)this + 0x10);
  if (0x7fffffffU - iVar1 < param_1) {
    FUN_100028c0();
    pcVar3 = (code *)swi(3);
    ppvVar7 = (void **)(*pcVar3)();
    return ppvVar7;
  }
  uVar2 = *(uint *)((int)this + 0x14);
  uVar8 = iVar1 + param_1 | 0xf;
  if (uVar8 < 0x80000000) {
    if (0x7fffffff - (uVar2 >> 1) < uVar2) {
      uVar8 = 0x7fffffff;
    }
    else {
      uVar4 = (uVar2 >> 1) + uVar2;
      if (uVar8 < uVar4) {
        uVar8 = uVar4;
      }
    }
  }
  else {
    uVar8 = 0x7fffffff;
  }
  uVar4 = uVar8 + 1;
  if (uVar4 < 0x1000) {
    if (uVar4 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_1000a4ab(uVar4);
    }
  }
  else {
    uVar5 = uVar8 + 0x24;
    if (uVar5 <= uVar4) {
      uVar5 = 0xffffffff;
    }
    iVar6 = FUN_1000a4ab(uVar5);
    if (iVar6 == 0) goto LAB_100083db;
    _Dst = (void *)(iVar6 + 0x23U & 0xffffffe0);
    *(int *)((int)_Dst - 4) = iVar6;
  }
  *(uint *)((int)this + 0x10) = iVar1 + param_1;
  *(uint *)((int)this + 0x14) = uVar8;
  if (uVar2 < 0x10) {
    memcpy(_Dst,"Found ",in_stack_00000014);
    memcpy((void *)((int)_Dst + in_stack_00000014),this,iVar1 + 1);
    *(void **)this = _Dst;
    return (void **)this;
  }
                    // WARNING: Load size is inaccurate
  _Src = *this;
  memcpy(_Dst,"Found ",in_stack_00000014);
  memcpy((void *)((int)_Dst + in_stack_00000014),_Src,iVar1 + 1);
  pvVar9 = _Src;
  if ((uVar2 + 1 < 0x1000) ||
     (pvVar9 = *(void **)((int)_Src + -4), (uint)((int)_Src + (-4 - (int)pvVar9)) < 0x20)) {
    FUN_1000a4db(pvVar9);
    *(void **)this = _Dst;
    return (void **)this;
  }
LAB_100083db:
                    // WARNING: Subroutine does not return
  _invalid_parameter_noinfo_noreturn();
}



void __fastcall FUN_10008410(int *param_1)

{
  int iVar1;
  int iVar2;
  
  iVar1 = param_1[1];
  for (iVar2 = *param_1; iVar2 != iVar1; iVar2 = iVar2 + 0x80) {
    FUN_100059c0(iVar2);
  }
  return;
}



void FUN_10008440(void)

{
  HWND *ppHVar1;
  uint in_stack_ffffffac;
  undefined4 *puVar2;
  undefined local_3c [12];
  undefined4 uStack_30;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000bdd8;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  local_3c[0] = 0;
  FUN_10002250(local_3c,&DAT_1000d57c,(int *)0x4);
  local_8 = 0;
  puVar2 = (undefined4 *)(in_stack_ffffffac & 0xffffff00);
  FUN_10002250(&stack0xffffffac,"Showing Taskbar.",(int *)0x10);
  local_8 = 0xffffffff;
  FUN_10005830(puVar2);
  ppHVar1 = DAT_100126e8;
  if (DAT_100126e8 == DAT_100126ec) {
    DAT_100126ec = DAT_100126e8;
    ExceptionList = local_10;
    return;
  }
  do {
    uStack_30 = 0x100084de;
    ShowWindow(*ppHVar1,5);
    ppHVar1 = ppHVar1 + 1;
  } while (ppHVar1 != DAT_100126ec);
  DAT_100126ec = DAT_100126e8;
  ExceptionList = local_10;
  return;
}



void FUN_10008520(HWND param_1)

{
  uint uVar1;
  BOOL BVar2;
  uint uVar3;
  int ****ppppiVar4;
  int **ppiVar5;
  bool bVar6;
  uint in_stack_ffffffa0;
  void *pvVar7;
  HWND local_34;
  DWORD local_30;
  int ****local_2c [4];
  uint local_1c;
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000be08;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  local_34 = param_1;
  BVar2 = IsWindowVisible(param_1);
  if ((BVar2 == 0) || (BVar2 = IsWindow(param_1), BVar2 == 0)) goto LAB_100086b7;
  local_30 = 0;
  GetWindowThreadProcessId(param_1,&local_30);
  pvVar7 = (void *)(in_stack_ffffffa0 & 0xffffff00);
  FUN_10002250(&stack0xffffffa0,"InternalName",(int *)0xc);
  FUN_10006190(local_2c,local_30,pvVar7);
  local_8 = 0;
  FUN_10006d30(local_2c);
  ppiVar5 = &DAT_1001209c;
  ppppiVar4 = (int ****)local_2c;
  if (0xf < local_18) {
    ppppiVar4 = local_2c[0];
  }
  if (0xf < DAT_100120b0) {
    ppiVar5 = (int **)DAT_1001209c;
  }
  uVar3 = DAT_100120ac;
  if (local_1c < DAT_100120ac) {
    uVar3 = local_1c;
  }
  while (uVar1 = uVar3 - 4, 3 < uVar3) {
    if ((int ***)*ppiVar5 != *ppppiVar4) goto LAB_10008609;
    ppiVar5 = ppiVar5 + 1;
    ppppiVar4 = ppppiVar4 + 1;
    uVar3 = uVar1;
  }
  if (uVar1 == 0xfffffffc) {
LAB_1000863d:
    uVar3 = 0;
  }
  else {
LAB_10008609:
    bVar6 = *(byte *)ppiVar5 < *(byte *)ppppiVar4;
    if ((*(byte *)ppiVar5 == *(byte *)ppppiVar4) &&
       ((uVar1 == 0xfffffffd ||
        ((bVar6 = *(byte *)((int)ppiVar5 + 1) < *(byte *)((int)ppppiVar4 + 1),
         *(byte *)((int)ppiVar5 + 1) == *(byte *)((int)ppppiVar4 + 1) &&
         ((uVar1 == 0xfffffffe ||
          ((bVar6 = *(byte *)((int)ppiVar5 + 2) < *(byte *)((int)ppppiVar4 + 2),
           *(byte *)((int)ppiVar5 + 2) == *(byte *)((int)ppppiVar4 + 2) &&
           ((uVar1 == 0xffffffff ||
            (bVar6 = *(byte *)((int)ppiVar5 + 3) < *(byte *)((int)ppppiVar4 + 3),
            *(byte *)((int)ppiVar5 + 3) == *(byte *)((int)ppppiVar4 + 3)))))))))))))
    goto LAB_1000863d;
    uVar3 = -(uint)bVar6 | 1;
  }
  if (uVar3 == 0) {
    if ((local_1c <= DAT_100120ac) && (local_1c > DAT_100120ac || DAT_100120ac == local_1c)) {
      ShowWindow(param_1,0);
      if (DAT_100126f0 == DAT_100126ec) {
        FUN_10007d90(&DAT_100126e8,DAT_100126ec,&local_34);
      }
      else {
        *DAT_100126ec = param_1;
        DAT_100126ec = DAT_100126ec + 1;
      }
    }
  }
  if (0xf < local_18) {
    ppppiVar4 = local_2c[0];
    if ((0xfff < local_18 + 1) &&
       (ppppiVar4 = (int ****)local_2c[0][-1],
       0x1f < (uint)((int)local_2c[0] + (-4 - (int)ppppiVar4)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(ppppiVar4);
  }
LAB_100086b7:
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



undefined4 __fastcall FUN_100086e0(undefined4 *param_1,undefined4 *param_2)

{
  FARPROC pFVar1;
  FARPROC pFVar2;
  HMODULE hModule;
  int iVar3;
  HANDLE pvVar4;
  LPVOID lpMem;
  undefined4 *lpSrch;
  LPWSTR pWVar5;
  undefined4 uVar6;
  FARPROC pFVar7;
  DWORD DVar8;
  SIZE_T dwBytes;
  uint uStack_78;
  undefined4 local_68;
  undefined4 local_64;
  undefined *local_60;
  undefined4 local_5c;
  undefined4 local_58;
  undefined4 local_54;
  undefined local_50 [8];
  FARPROC local_48;
  undefined4 *local_44;
  int local_40;
  undefined *local_3c;
  FARPROC local_38;
  FARPROC local_34;
  undefined4 local_30;
  undefined4 local_2c;
  FARPROC local_28;
  int local_24;
  SIZE_T local_20;
  uint *local_1c;
  void *local_14;
  code *pcStack_10;
  uint local_c;
  undefined4 local_8;
  
  local_8 = 0xfffffffe;
  pcStack_10 = FUN_1000a85b;
  local_14 = ExceptionList;
  local_c = DAT_10012024 ^ 0x1000efc0;
  uStack_78 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  local_1c = &uStack_78;
  ExceptionList = &local_14;
  local_24 = 0;
  local_30 = 0;
  local_44 = param_2;
  hModule = GetModuleHandleW(L"ntdll");
  local_34 = GetProcAddress(hModule,"RtlInitUnicodeString");
  local_38 = GetProcAddress(hModule,"NtOpenDirectoryObject");
  local_28 = GetProcAddress(hModule,"NtQueryDirectoryObject");
  local_48 = GetProcAddress(hModule,"ZwClose");
  pFVar7 = local_28;
  pFVar2 = local_34;
  pFVar1 = local_38;
  if ((((local_34 != (FARPROC)0x0) && (local_38 != (FARPROC)0x0)) && (local_28 != (FARPROC)0x0)) &&
     (local_48 != (FARPROC)0x0)) {
    local_8 = 0;
    local_3c = local_50;
    for (local_40 = 8; local_40 != 0; local_40 = local_40 + -1) {
      *local_3c = 0;
      local_3c = local_3c + 1;
    }
    if (7 < (uint)param_1[5]) {
      param_1 = (undefined4 *)*param_1;
    }
    (*pFVar2)(local_50,param_1);
    local_68 = 0x18;
    local_64 = 0;
    local_5c = 0x40;
    local_60 = local_50;
    local_58 = 0;
    local_54 = 0;
    iVar3 = (*pFVar1)(&local_24,1,&local_68);
    if (-1 < iVar3) {
      local_2c = 0;
      do {
        local_20 = 0;
        iVar3 = (*pFVar7)(local_24,0,0,1,0,&local_2c,&local_20);
        if (iVar3 != -0x3fffffdd) {
LAB_1000887b:
          uVar6 = 0;
LAB_1000887d:
          if (local_24 == 0) {
            ExceptionList = local_14;
            return uVar6;
          }
          (*local_48)(local_24);
          ExceptionList = local_14;
          return uVar6;
        }
        DVar8 = 8;
        dwBytes = local_20;
        pvVar4 = GetProcessHeap();
        lpMem = HeapAlloc(pvVar4,DVar8,dwBytes);
        if (lpMem == (LPVOID)0x0) goto LAB_1000887b;
        iVar3 = (*local_28)(local_24,lpMem,local_20,1,0,&local_2c,&local_20);
        if (iVar3 < 0) {
          DVar8 = 0;
          pvVar4 = GetProcessHeap();
          HeapFree(pvVar4,DVar8,lpMem);
          goto LAB_1000887b;
        }
        lpSrch = local_44;
        if (7 < (uint)local_44[5]) {
          lpSrch = (undefined4 *)*local_44;
        }
        pWVar5 = StrStrIW(*(LPCWSTR *)((int)lpMem + 4),(LPCWSTR)lpSrch);
        DVar8 = 0;
        if (pWVar5 != (LPWSTR)0x0) {
          pvVar4 = GetProcessHeap();
          HeapFree(pvVar4,DVar8,lpMem);
          uVar6 = 1;
          local_30 = 1;
          goto LAB_1000887d;
        }
        pvVar4 = GetProcessHeap();
        HeapFree(pvVar4,DVar8,lpMem);
        pFVar7 = local_28;
      } while( true );
    }
  }
  ExceptionList = local_14;
  return 0;
}



// WARNING: Removing unreachable block (ram,0x10008947)

void FUN_10008910(void)

{
  int iVar1;
  void *pvVar2;
  bool bVar3;
  void *local_44 [4];
  undefined4 local_34;
  uint local_30;
  void *local_2c [4];
  undefined4 local_1c;
  uint local_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000be49;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  iVar1 = cpuid_Version_info(1);
  bVar3 = -1 < *(int *)(iVar1 + 0xc);
  if (bVar3) {
    local_34 = 0;
    local_30 = 7;
    local_44[0] = (void *)((uint)local_44[0] & 0xffff0000);
    FUN_10008af0(local_44,L"vmmemctl",(int *)0x8);
    local_8 = 0;
    local_1c = 0;
    local_18 = 7;
    local_2c[0] = (void *)((uint)local_2c[0] & 0xffff0000);
    FUN_10008af0(local_2c,L"\\Device",(int *)0x7);
    FUN_100086e0(local_2c,local_44);
    if (7 < local_18) {
      pvVar2 = local_2c[0];
      if ((0xfff < local_18 * 2 + 2) &&
         (pvVar2 = *(void **)((int)local_2c[0] + -4),
         0x1f < (uint)((int)local_2c[0] + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
        _invalid_parameter_noinfo_noreturn();
      }
      FUN_1000a4db(pvVar2);
    }
    local_1c = 0;
    local_18 = 7;
    local_2c[0] = (void *)((uint)local_2c[0] & 0xffff0000);
  }
  if ((bVar3) && (7 < local_30)) {
    pvVar2 = local_44[0];
    if ((0xfff < local_30 * 2 + 2) &&
       (pvVar2 = *(void **)((int)local_44[0] + -4),
       0x1f < (uint)((int)local_44[0] + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void __fastcall FUN_10008a90(void **param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  if ((void *)0x7 < param_1[5]) {
    pvVar1 = *param_1;
    pvVar2 = pvVar1;
    if ((0xfff < (int)param_1[5] * 2 + 2U) &&
       (pvVar2 = *(void **)((int)pvVar1 + -4), 0x1f < (uint)((int)pvVar1 + (-4 - (int)pvVar2)))) {
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar2);
  }
  param_1[4] = (void *)0x0;
  param_1[5] = (void *)0x7;
  *(undefined2 *)param_1 = 0;
  return;
}



int ** __thiscall FUN_10008af0(void *this,void *param_1,int *param_2)

{
  int *piVar1;
  void *pvVar2;
  code *pcVar3;
  uint uVar4;
  int iVar5;
  void *pvVar6;
  int **ppiVar7;
  uint uVar8;
  void *pvVar9;
  uint uVar10;
  
  piVar1 = *(int **)((int)this + 0x14);
  if (param_2 <= piVar1) {
    pvVar9 = this;
    if ((int *)0x7 < piVar1) {
                    // WARNING: Load size is inaccurate
      pvVar9 = *this;
    }
    *(int **)((int)this + 0x10) = param_2;
    memmove(pvVar9,param_1,(int)param_2 * 2);
    *(undefined2 *)((int)param_2 * 2 + (int)pvVar9) = 0;
    return (int **)this;
  }
  if ((int *)0x7ffffffe < param_2) {
    FUN_100028c0();
    pcVar3 = (code *)swi(3);
    ppiVar7 = (int **)(*pcVar3)();
    return ppiVar7;
  }
  uVar10 = (uint)param_2 | 7;
  if (uVar10 < 0x7fffffff) {
    if ((int *)(0x7ffffffe - ((uint)piVar1 >> 1)) < piVar1) {
      uVar10 = 0x7ffffffe;
    }
    else {
      uVar8 = ((uint)piVar1 >> 1) + (int)piVar1;
      if (uVar10 < uVar8) {
        uVar10 = uVar8;
      }
    }
  }
  else {
    uVar10 = 0x7ffffffe;
  }
  uVar8 = (uVar10 + 1) * 2;
  if (uVar10 + 1 < 0x80000000) {
    if (0xfff < uVar8) goto LAB_10008b8a;
    if (uVar8 == 0) {
      pvVar9 = (void *)0x0;
    }
    else {
      pvVar9 = (void *)FUN_1000a4ab(uVar8);
    }
  }
  else {
    uVar8 = 0xffffffff;
LAB_10008b8a:
    uVar4 = uVar8 + 0x23;
    if (uVar4 <= uVar8) {
      uVar4 = 0xffffffff;
    }
    iVar5 = FUN_1000a4ab(uVar4);
    if (iVar5 == 0) goto LAB_10008c21;
    pvVar9 = (void *)(iVar5 + 0x23U & 0xffffffe0);
    *(int *)((int)pvVar9 - 4) = iVar5;
  }
  *(uint *)((int)this + 0x14) = uVar10;
  *(int **)((int)this + 0x10) = param_2;
  memcpy(pvVar9,param_1,(int)param_2 * 2);
  *(undefined2 *)((int)param_2 * 2 + (int)pvVar9) = 0;
  if ((int *)0x7 < piVar1) {
                    // WARNING: Load size is inaccurate
    pvVar2 = *this;
    pvVar6 = pvVar2;
    if ((0xfff < (int)piVar1 * 2 + 2U) &&
       (pvVar6 = *(void **)((int)pvVar2 + -4), 0x1f < (uint)((int)pvVar2 + (-4 - (int)pvVar6)))) {
LAB_10008c21:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar6);
  }
  *(void **)this = pvVar9;
  return (int **)this;
}



undefined4 FUN_10008c30(undefined4 param_1,undefined4 param_2,undefined4 *param_3,void *param_4)

{
  undefined4 *puVar1;
  undefined4 uVar2;
  undefined4 uVar3;
  undefined4 uVar4;
  
  puVar1 = *(undefined4 **)((int)param_4 + 4);
  if (*(undefined4 **)((int)param_4 + 8) != puVar1) {
    uVar2 = param_3[1];
    uVar3 = param_3[2];
    uVar4 = param_3[3];
    *puVar1 = *param_3;
    puVar1[1] = uVar2;
    puVar1[2] = uVar3;
    puVar1[3] = uVar4;
    *(int *)((int)param_4 + 4) = *(int *)((int)param_4 + 4) + 0x10;
    return 1;
  }
  FUN_100092c0(param_4,puVar1,param_3);
  return 1;
}



// WARNING: Function: __alloca_probe replaced with injection: alloca_probe

void __thiscall
FUN_10008c70(void *this,undefined (*param_1) [16],undefined4 param_2,undefined4 param_3,
            undefined4 param_4,undefined4 param_5,int *param_6)

{
  NTSTATUS NVar1;
  int iVar2;
  int *piVar3;
  int *piVar4;
  uint uVar5;
  bool bVar6;
  undefined auStack_1058 [12];
  undefined (*local_104c) [16];
  int *local_1048;
  void *local_1044;
  undefined local_1040 [16];
  UCHAR local_1028 [16];
  int local_1018 [4];
  undefined4 local_1008;
  undefined4 uStack_1004;
  undefined4 uStack_1000;
  undefined4 uStack_ffc;
  undefined4 local_ff8;
  uint local_14;
  
  local_14 = DAT_10012024 ^ (uint)auStack_1058;
  local_104c = param_1;
  local_1048 = param_6;
  local_1040 = ZEXT816(0);
  local_1044 = this;
  memset(local_1028,0,0x1010);
  memset(param_6,0,0x1000);
  NVar1 = BCryptGenRandom((BCRYPT_ALG_HANDLE)0x0,(PUCHAR)local_1018,0x10,2);
  if (-1 < NVar1) {
    local_ff8 = *(undefined4 *)((int)this + 0x10);
    local_1008 = param_2;
    uStack_1004 = param_3;
    uStack_1000 = param_4;
    uStack_ffc = param_5;
    iVar2 = FUN_100094f0((undefined4 *)this,(undefined (*) [16])local_1018,0x1000,local_1028);
    if ((-1 < iVar2) &&
       (iVar2 = (**(code **)(*(int *)*local_104c + 0x14))(local_104c,local_1028,param_6), -1 < iVar2
       )) {
      local_104c = (undefined (*) [16])(param_6 + 4);
      iVar2 = FUN_100094f0((undefined4 *)this,local_104c,0xff0,local_1040);
      if (-1 < iVar2) {
        piVar4 = (int *)local_1040;
        uVar5 = 0xc;
        piVar3 = local_1048;
        while (*piVar3 == *piVar4) {
          piVar3 = piVar3 + 1;
          piVar4 = piVar4 + 1;
          bVar6 = uVar5 < 4;
          uVar5 = uVar5 - 4;
          if (bVar6) {
            *(int *)((int)local_1044 + 0x10) = *(int *)((int)local_1044 + 0x10) + 1;
            if (*(uint *)*local_104c < 0x10) {
              ___security_check_cookie_4(local_14 ^ (uint)auStack_1058);
              return;
            }
            piVar4 = local_1018;
            piVar3 = local_1048 + 5;
            uVar5 = 0xc;
            do {
              if (*piVar3 != *piVar4) {
                ___security_check_cookie_4(local_14 ^ (uint)auStack_1058);
                return;
              }
              piVar3 = piVar3 + 1;
              piVar4 = piVar4 + 1;
              bVar6 = 3 < uVar5;
              uVar5 = uVar5 - 4;
            } while (bVar6);
            ___security_check_cookie_4(local_14 ^ (uint)auStack_1058);
            return;
          }
        }
      }
    }
  }
  ___security_check_cookie_4(local_14 ^ (uint)auStack_1058);
  return;
}



// WARNING: Function: __alloca_probe replaced with injection: alloca_probe
// WARNING: Could not reconcile some variable overlaps

void FUN_10008e20(void)

{
  undefined (*pauVar1) [16];
  HWND hwnd;
  int iVar2;
  BOOL BVar3;
  DWORD DVar4;
  uint uVar5;
  uint uVar6;
  char *pcVar7;
  int *piVar8;
  uint in_stack_ffffee4c;
  undefined4 *puVar9;
  wchar_t *local_1178;
  undefined4 local_1174;
  undefined4 local_1170;
  ULONG local_116c;
  int local_1168;
  uint local_1164;
  undefined4 *local_1160;
  int local_115c;
  int local_1158;
  BCRYPT_KEY_HANDLE local_1154;
  HCRYPTPROV local_1150;
  undefined (*local_114c) [16];
  uint local_1148;
  int local_1144 [4];
  size_t local_1134;
  undefined local_1130 [4076];
  undefined4 local_144;
  undefined4 uStack_140;
  undefined4 uStack_13c;
  undefined4 uStack_138;
  undefined4 local_134;
  undefined4 uStack_130;
  undefined4 uStack_12c;
  undefined4 uStack_128;
  undefined4 local_124;
  undefined4 local_120;
  undefined local_44 [16];
  undefined local_34 [16];
  undefined local_24 [8];
  undefined4 uStack_1c;
  undefined4 uStack_18;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000bea7;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  hwnd = GetDesktopWindow();
  MonitorFromWindow(hwnd,1);
  OPMGetVideoOutputsFromHMONITOR();
  local_1148 = 0;
  if (local_1164 != 0) {
    while( true ) {
      local_114c = *(undefined (**) [16])(local_1168 + local_1148 * 4);
      _local_24 = ZEXT816(0);
      local_1158 = 0;
      local_115c = 0;
      iVar2 = (**(code **)(*(int *)*local_114c + 0xc))();
      if (iVar2 < 0) break;
      memset(&local_134,0,0xf0);
      local_1150 = 0;
      local_144 = local_24._0_4_;
      uStack_140 = local_24._4_4_;
      uStack_13c = uStack_1c;
      uStack_138 = uStack_18;
      BVar3 = CryptAcquireContextA(&local_1150,(LPCSTR)0x0,(LPCSTR)0x0,0x18,0xf0000048);
      if (BVar3 == 0) {
        DVar4 = GetLastError();
        if (DVar4 == 0x8009000f) {
          BVar3 = CryptAcquireContextA(&local_1150,(LPCSTR)0x0,(LPCSTR)0x0,0x18,0xf0000040);
          if (BVar3 != 0) goto LAB_10008f59;
          goto LAB_10008fa1;
        }
LAB_10008fa5:
        if (0 < (int)DVar4) {
          DVar4 = DVar4 & 0xffff | 0x80070000;
        }
        if (-1 < (int)DVar4) {
          DVar4 = 0x80004005;
        }
      }
      else {
LAB_10008f59:
        DVar4 = 0;
        BVar3 = CryptGenRandom(local_1150,0x18,(BYTE *)&local_134);
        if (BVar3 == 0) {
          DVar4 = GetLastError();
          if (0 < (int)DVar4) {
            DVar4 = DVar4 & 0xffff | 0x80070000;
          }
          if (-1 < (int)DVar4) {
            DVar4 = 0x80004005;
          }
        }
        BVar3 = CryptReleaseContext(local_1150,0);
        if (BVar3 == 0) {
LAB_10008fa1:
          DVar4 = GetLastError();
          goto LAB_10008fa5;
        }
      }
      if ((int)DVar4 < 0) {
        local_114c = (undefined (*) [16])&stack0xffffee64;
        FUN_10002250(&stack0xffffee64,"ERROR",(int *)0x5);
        local_8 = 1;
        piVar8 = (int *)0x25;
        pcVar7 = "HDCP CHECK: Failed to generate random";
        goto LAB_10009272;
      }
      local_1160[4] = local_124;
      *local_1160 = local_134;
      local_1160[1] = uStack_130;
      local_1160[2] = uStack_12c;
      local_1160[3] = uStack_128;
      local_1160[5] = local_120;
      if ((local_1158 == 0) || (local_115c == 0)) {
LAB_100091bd:
        local_114c = (undefined (*) [16])&stack0xffffee64;
        FUN_10002250(&stack0xffffee64,"ERROR",(int *)0x5);
        local_8 = 2;
        piVar8 = (int *)0x1e;
        pcVar7 = "HDCP CHECK: Failed to Encrypt!";
        goto LAB_10009272;
      }
      local_1154 = (BCRYPT_KEY_HANDLE)0x0;
      uVar5 = FUN_10009790(local_1158,local_115c,&local_1154);
      if ((int)uVar5 < 0) goto LAB_100091bd;
      local_1178 = L"SHA512";
      local_1174 = 0;
      local_1170 = 0;
      local_116c = 0;
      uVar5 = BCryptEncrypt(local_1154,(PUCHAR)&local_144,0x28,&local_1178,(PUCHAR)0x0,0,
                            (PUCHAR)&local_144,0x100,&local_116c,4);
      uVar6 = BCryptDestroyKey(local_1154);
      pauVar1 = local_114c;
      if (((int)(uVar5 | 0x10000000) < 0) || ((int)(uVar6 | 0x10000000) < 0)) goto LAB_100091bd;
      iVar2 = (**(code **)(*(int *)*local_114c + 0x10))();
      if (iVar2 < 0) {
        local_114c = (undefined (*) [16])&stack0xffffee64;
        FUN_10002250(&stack0xffffee64,"ERROR",(int *)0x5);
        local_8 = 3;
        piVar8 = (int *)0x2c;
        pcVar7 = "HDCP CHECK: Failed to finish initialization!";
        goto LAB_10009272;
      }
      iVar2 = FUN_10008c70(local_1160,pauVar1,0x38f2a801,0x48bb9a6c,0x69b60791,0x97176f6e,local_1144
                          );
      if (iVar2 < 0) {
        local_114c = (undefined (*) [16])&stack0xffffee64;
        FUN_10002250(&stack0xffffee64,"ERROR",(int *)0x5);
        local_8 = 4;
        piVar8 = (int *)0x2a;
        pcVar7 = "HDCP CHECK: Failed to send status request!";
        goto LAB_10009272;
      }
      local_44 = ZEXT816(0);
      local_34 = ZEXT816(0);
      if (local_1134 != 0) {
        memcpy(local_44,local_1130,local_1134);
      }
      if ((local_34._4_4_ == 0) || (local_1148 = local_1148 + 1, local_1164 <= local_1148))
      goto LAB_10009299;
    }
    local_114c = (undefined (*) [16])&stack0xffffee64;
    FUN_10002250(&stack0xffffee64,"ERROR",(int *)0x5);
    local_8 = 0;
    piVar8 = (int *)0x2a;
    pcVar7 = "HDCP CHECK: Failed to start initialization";
LAB_10009272:
    puVar9 = (undefined4 *)(in_stack_ffffee4c & 0xffffff00);
    FUN_10002250(&stack0xffffee4c,pcVar7,piVar8);
    local_8 = 0xffffffff;
    FUN_10005830(puVar9);
  }
LAB_10009299:
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void * __thiscall FUN_100092c0(void *this,void *param_1,undefined4 *param_2)

{
  uint uVar1;
  undefined4 *puVar2;
  void *pvVar3;
  code *pcVar4;
  undefined4 uVar5;
  undefined4 uVar6;
  undefined4 uVar7;
  int iVar8;
  uint uVar9;
  uint uVar10;
  void *pvVar11;
  uint uVar12;
  int iVar13;
  void *pvVar14;
  
                    // WARNING: Load size is inaccurate
  iVar13 = *this;
  iVar8 = *(int *)((int)this + 4) - iVar13 >> 4;
  if (iVar8 == 0xfffffff) {
    FUN_10004730();
    pcVar4 = (code *)swi(3);
    pvVar14 = (void *)(*pcVar4)();
    return pvVar14;
  }
  uVar1 = iVar8 + 1;
  uVar12 = *(int *)((int)this + 8) - iVar13 >> 4;
  uVar9 = uVar1;
  if ((uVar12 <= 0xfffffff - (uVar12 >> 1)) && (uVar9 = (uVar12 >> 1) + uVar12, uVar9 < uVar1)) {
    uVar9 = uVar1;
  }
  uVar12 = uVar9 * 0x10;
  if (uVar9 < 0x10000000) {
    uVar9 = uVar12;
    if (0xfff < uVar12) goto LAB_1000932d;
    if (uVar12 == 0) {
      pvVar14 = (void *)0x0;
    }
    else {
      pvVar14 = (void *)FUN_1000a4ab(uVar12);
    }
  }
  else {
    uVar9 = 0xffffffff;
LAB_1000932d:
    uVar10 = uVar9 + 0x23;
    if (uVar10 <= uVar9) {
      uVar10 = 0xffffffff;
    }
    iVar8 = FUN_1000a4ab(uVar10);
    if (iVar8 == 0) goto LAB_10009412;
    pvVar14 = (void *)(iVar8 + 0x23U & 0xffffffe0);
    *(int *)((int)pvVar14 - 4) = iVar8;
  }
  iVar13 = ((int)param_1 - iVar13 >> 4) * 0x10;
  puVar2 = (undefined4 *)(iVar13 + (int)pvVar14);
  uVar5 = param_2[1];
  uVar6 = param_2[2];
  uVar7 = param_2[3];
  *puVar2 = *param_2;
  puVar2[1] = uVar5;
  puVar2[2] = uVar6;
  puVar2[3] = uVar7;
                    // WARNING: Load size is inaccurate
  pvVar3 = *this;
  if (param_1 == *(void **)((int)this + 4)) {
    memmove(pvVar14,pvVar3,(int)*(void **)((int)this + 4) - (int)pvVar3);
  }
  else {
    memmove(pvVar14,pvVar3,(int)param_1 - (int)pvVar3);
    memmove(puVar2 + 4,param_1,*(int *)((int)this + 4) - (int)param_1);
  }
                    // WARNING: Load size is inaccurate
  pvVar3 = *this;
  if (pvVar3 != (void *)0x0) {
    pvVar11 = pvVar3;
    if ((0xfff < (*(int *)((int)this + 8) - (int)pvVar3 & 0xfffffff0U)) &&
       (pvVar11 = *(void **)((int)pvVar3 + -4), 0x1f < (uint)((int)pvVar3 + (-4 - (int)pvVar11)))) {
LAB_10009412:
                    // WARNING: Subroutine does not return
      _invalid_parameter_noinfo_noreturn();
    }
    FUN_1000a4db(pvVar11);
  }
  *(void **)this = pvVar14;
  *(void **)((int)this + 4) = (void *)(uVar1 * 0x10 + (int)pvVar14);
  *(void **)((int)this + 8) = (void *)(uVar12 + (int)pvVar14);
                    // WARNING: Load size is inaccurate
  return (void *)(*this + iVar13);
}



void __fastcall FUN_10009420(int param_1,byte *param_2)

{
  byte bVar1;
  byte bVar2;
  int iVar3;
  int iVar4;
  int iVar5;
  int iVar6;
  byte *pbVar7;
  
  iVar4 = 1 - (int)param_2;
  iVar3 = param_1 - (int)param_2;
  iVar5 = 2 - (int)param_2;
  pbVar7 = (byte *)(param_1 + 2);
  iVar6 = 3 - (int)param_2;
  do {
    bVar1 = param_2[iVar3];
    bVar2 = pbVar7[-1];
    *param_2 = bVar1 * '\x02';
    if (pbVar7 + (-2 - param_1) < (byte *)0xf) {
      *param_2 = bVar2 >> 7 | bVar1 * '\x02';
    }
    bVar2 = bVar2 * '\x02';
    bVar1 = *pbVar7;
    param_2[1] = bVar2;
    if (param_2 + iVar4 < (byte *)0xf) {
      param_2[1] = bVar1 >> 7 | bVar2;
    }
    bVar1 = bVar1 * '\x02';
    bVar2 = pbVar7[1];
    param_2[2] = bVar1;
    if (param_2 + iVar5 < (byte *)0xf) {
      param_2[2] = bVar2 >> 7 | bVar1;
    }
    bVar2 = bVar2 * '\x02';
    param_2[3] = bVar2;
    if (param_2 + iVar6 < (byte *)0xf) {
      param_2[3] = pbVar7[2] >> 7 | bVar2;
    }
    pbVar7 = pbVar7 + 4;
    param_2 = param_2 + 4;
  } while (pbVar7 + (-2 - param_1) < (byte *)0x10);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void __fastcall
FUN_100094f0(undefined4 *param_1,undefined (*param_2) [16],uint param_3,PUCHAR param_4)

{
  uint uVar1;
  NTSTATUS NVar2;
  int iVar3;
  wchar_t *hObject;
  ULONG local_6c;
  PUCHAR local_68;
  uint local_64;
  size_t local_60;
  LPCWSTR local_5c;
  BCRYPT_KEY_HANDLE local_58;
  undefined4 local_54;
  undefined4 local_50;
  undefined4 local_4c;
  undefined4 local_48;
  undefined4 uStack_44;
  undefined4 uStack_40;
  undefined4 uStack_3c;
  uint local_38;
  uint uStack_34;
  uint uStack_30;
  uint uStack_2c;
  uint local_28;
  uint uStack_24;
  uint uStack_20;
  uint uStack_1c;
  undefined local_18 [8];
  uint uStack_10;
  uint uStack_c;
  uint local_8;
  
  local_8 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  local_48 = *param_1;
  uStack_44 = param_1[1];
  uStack_40 = param_1[2];
  uStack_3c = param_1[3];
  local_5c = (LPCWSTR)0x0;
  local_58 = (BCRYPT_KEY_HANDLE)0x0;
  local_60 = 0;
  local_64 = 0;
  local_68 = (PUCHAR)0x0;
  local_54 = 0x4d42444b;
  local_50 = 1;
  local_4c = 0x10;
  NVar2 = BCryptOpenAlgorithmProvider(&local_5c,L"AES",L"Microsoft Primitive Provider",0);
  if (NVar2 == 0) {
    hObject = L"ObjectLength";
    NVar2 = BCryptGetProperty(local_5c,L"ObjectLength",(PUCHAR)&local_60,4,&local_64,0);
    if ((((NVar2 == 0) && (local_68 = (PUCHAR)FUN_1000a87e(local_60), local_68 != (PUCHAR)0x0)) &&
        (NVar2 = BCryptSetProperty(hObject,local_5c,(PUCHAR)L"ChainingMode",
                                   (ULONG)L"ChainingModeCBC",0x20), NVar2 == 0)) &&
       (NVar2 = BCryptImportKey(local_5c,(BCRYPT_KEY_HANDLE)0x0,L"KeyDataBlob",&local_58,local_68,
                                local_60,(PUCHAR)&local_54,0x1c,0), NVar2 == 0)) {
      local_6c = 0x10;
      _local_18 = ZEXT816(0);
      NVar2 = BCryptEncrypt(local_58,local_18,0x10,(void *)0x0,(PUCHAR)0x0,0,local_18,0x10,&local_6c
                            ,0);
      if (NVar2 == 0) {
        FUN_10009420((int)local_18,(byte *)&local_28);
        if ((char)local_18[0] < '\0') {
          uStack_1c = uStack_1c ^ 0x87000000;
        }
        FUN_10009420((int)&local_28,(byte *)&local_38);
        if ((local_28 & 0x80) != 0) {
          uStack_2c = uStack_2c ^ 0x87000000;
        }
        BCryptDestroyKey(local_58);
        local_58 = (BCRYPT_KEY_HANDLE)0x0;
        NVar2 = BCryptImportKey(local_5c,(BCRYPT_KEY_HANDLE)0x0,L"KeyDataBlob",&local_58,local_68,
                                local_60,(PUCHAR)&local_54,0x1c,0);
        if (NVar2 == 0) {
          local_64 = param_3;
          do {
            uVar1 = local_64;
            local_6c = 0;
            if (local_64 < 0x11) {
              if (local_64 == 0x10) {
                local_18 = (undefined  [8])
                           CONCAT44(*(uint *)(*param_2 + 4) ^ uStack_24,*(uint *)*param_2 ^ local_28
                                   );
                _local_18 = CONCAT48(*(uint *)(*param_2 + 8) ^ uStack_20,local_18);
                _local_18 = CONCAT412(*(uint *)(*param_2 + 0xc) ^ uStack_1c,_local_18);
              }
              else {
                _local_18 = ZEXT816(0);
                memcpy(local_18,param_2,local_64);
                local_18[uVar1] = 0x80;
                local_18 = (undefined  [8])
                           CONCAT44(uStack_34 ^ local_18._4_4_,local_38 ^ local_18._0_4_);
                _local_18 = CONCAT48(uStack_30 ^ uStack_10,local_18);
                _local_18 = CONCAT412(uStack_2c ^ uStack_c,_local_18);
              }
              iVar3 = BCryptEncrypt(local_58,local_18,0x10,(void *)0x0,(PUCHAR)0x0,0,param_4,0x10,
                                    &local_6c,0);
              local_64 = 0;
            }
            else {
              _local_18 = *param_2;
              iVar3 = BCryptEncrypt(local_58,local_18,0x10,(void *)0x0,(PUCHAR)0x0,0,local_18,0x10,
                                    &local_6c,0);
              param_2 = param_2[1];
              local_64 = local_64 - 0x10;
            }
          } while ((iVar3 == 0) && (local_64 != 0));
        }
      }
    }
  }
  if (local_58 != (BCRYPT_KEY_HANDLE)0x0) {
    BCryptDestroyKey(local_58);
  }
  if (local_5c != (LPCWSTR)0x0) {
    BCryptCloseAlgorithmProvider(local_5c,0);
  }
  free(local_68);
  ___security_check_cookie_4(local_8 ^ (uint)&stack0xfffffffc);
  return;
}



uint __fastcall FUN_10009790(int param_1,int param_2,BCRYPT_KEY_HANDLE *param_3)

{
  HCERTSTORE hCertStore;
  PCCERT_CONTEXT pCertContext;
  DWORD DVar1;
  BOOL BVar2;
  PCCERT_CONTEXT pCertContext_00;
  int local_10;
  int local_c;
  HCERTSTORE local_8;
  
  if (param_1 == 0) {
    return 0x80004003;
  }
  if (param_2 == 0) {
    return 0x80070057;
  }
  local_10 = param_2;
  local_c = param_1;
  hCertStore = CertOpenStore((LPCSTR)0x5,0x10001,0,0x8000,&local_10);
  if (hCertStore == (HCERTSTORE)0x0) {
    return 0x80004005;
  }
  pCertContext_00 = (PCCERT_CONTEXT)0x0;
  local_8 = hCertStore;
  pCertContext = CertEnumCertificatesInStore(hCertStore,(PCCERT_CONTEXT)0x0);
  if (pCertContext != (PCCERT_CONTEXT)0x0) {
    do {
      if (pCertContext_00 != (PCCERT_CONTEXT)0x0) {
        CertFreeCertificateContext(pCertContext_00);
      }
      pCertContext_00 = CertDuplicateCertificateContext(pCertContext);
      DVar1 = FUN_10009900(pCertContext_00,hCertStore);
      if ((int)DVar1 < 0) {
        CertFreeCertificateContext(pCertContext);
        CertFreeCertificateContext(pCertContext_00);
        BVar2 = CertCloseStore(local_8,0);
        if (BVar2 != 0) {
          return DVar1;
        }
        GetLastError();
        return DVar1;
      }
      pCertContext = CertEnumCertificatesInStore(local_8,pCertContext);
      hCertStore = local_8;
    } while (pCertContext != (PCCERT_CONTEXT)0x0);
    if (pCertContext_00 != (PCCERT_CONTEXT)0x0) {
      BVar2 = CryptImportPublicKeyInfoEx2
                        (0x10001,&pCertContext_00->pCertInfo->SubjectPublicKeyInfo,0,(void *)0x0,
                         param_3);
      if (BVar2 == 0) {
        DVar1 = GetLastError();
        if (0 < (int)DVar1) {
          DVar1 = DVar1 & 0xffff | 0x80070000;
        }
        if (-1 < (int)DVar1) {
          DVar1 = 0x80004005;
        }
      }
      CertFreeCertificateContext(pCertContext_00);
      BVar2 = CertCloseStore(local_8,0);
      if (BVar2 != 0) {
        return DVar1;
      }
      DVar1 = GetLastError();
      goto LAB_10009807;
    }
  }
  DVar1 = GetLastError();
  CertCloseStore(local_8,0);
LAB_10009807:
  if (0 < (int)DVar1) {
    DVar1 = DVar1 & 0xffff | 0x80070000;
  }
  if (-1 < (int)DVar1) {
    DVar1 = 0x80004005;
  }
  return DVar1;
}



DWORD __fastcall FUN_10009900(PCCERT_CONTEXT param_1,HCERTSTORE param_2)

{
  PCCERT_CONTEXT pSubjectContext;
  BOOL BVar1;
  uint uVar2;
  DWORD DVar3;
  code *pcVar4;
  PCCERT_CONTEXT pvIssuer;
  DWORD local_10;
  PCCERT_CONTEXT local_c;
  HCRYPTPROV local_8;
  
  if ((param_1 == (PCCERT_CONTEXT)0x0) || (param_2 == (HCERTSTORE)0x0)) {
    return 0x80004003;
  }
  pSubjectContext = CertDuplicateCertificateContext(param_1);
  uVar2 = 0;
  if (pSubjectContext == (PCCERT_CONTEXT)0x0) {
    return 0;
  }
  do {
    DVar3 = 0;
    local_10 = 0;
    local_c = pSubjectContext;
    pSubjectContext =
         CertGetIssuerCertificateFromStore(param_2,pSubjectContext,(PCCERT_CONTEXT)0x0,&local_10);
    if (pSubjectContext == (PCCERT_CONTEXT)0x0) {
      DVar3 = GetLastError();
      uVar2 = DVar3;
      if (0 < (int)DVar3) {
        uVar2 = DVar3 & 0xffff | 0x80070000;
      }
      if (-1 < (int)uVar2) {
        uVar2 = 0x80004005;
      }
      if (DVar3 == 0x80092007) {
        uVar2 = 0;
        BVar1 = CertCompareCertificateName
                          (1,&local_c->pCertInfo->Subject,&local_c->pCertInfo->Issuer);
        if (BVar1 == 0) {
          DVar3 = GetLastError();
          uVar2 = DVar3;
          if (0 < (int)DVar3) {
            uVar2 = DVar3 & 0xffff | 0x80070000;
          }
          if (-1 < (int)uVar2) {
            uVar2 = 0x80004005;
          }
        }
      }
    }
    local_8 = 0;
    if ((int)uVar2 < 0) {
LAB_100099fd:
      if (DVar3 == 0x8009000f) {
        uVar2 = 0;
        BVar1 = CryptAcquireContextA(&local_8,(LPCSTR)0x0,(LPCSTR)0x0,1,0xf0000040);
        pcVar4 = GetLastError_exref;
        if (BVar1 != 0) goto LAB_10009a44;
        uVar2 = GetLastError();
        if (0 < (int)uVar2) {
          uVar2 = uVar2 & 0xffff | 0x80070000;
        }
        if (-1 < (int)uVar2) {
          uVar2 = 0x80004005;
        }
      }
      else {
        pcVar4 = GetLastError_exref;
        if (-1 < (int)uVar2) goto LAB_10009a44;
      }
    }
    else {
      BVar1 = CryptAcquireContextA(&local_8,(LPCSTR)0x0,(LPCSTR)0x0,1,0xf0000048);
      if (BVar1 == 0) {
        DVar3 = GetLastError();
        uVar2 = DVar3;
        if (0 < (int)DVar3) {
          uVar2 = DVar3 & 0xffff | 0x80070000;
        }
        if (-1 < (int)uVar2) {
          uVar2 = 0x80004005;
        }
        goto LAB_100099fd;
      }
LAB_10009a44:
      pvIssuer = local_c;
      if (pSubjectContext != (PCCERT_CONTEXT)0x0) {
        pvIssuer = pSubjectContext;
      }
      BVar1 = CryptVerifyCertificateSignatureEx(local_8,1,2,local_c,2,pvIssuer,0,(void *)0x0);
      pcVar4 = GetLastError_exref;
      if (BVar1 == 0) {
        uVar2 = GetLastError();
        if (0 < (int)uVar2) {
          uVar2 = uVar2 & 0xffff | 0x80070000;
        }
        if (-1 < (int)uVar2) {
          uVar2 = 0x80004005;
        }
      }
    }
    BVar1 = CryptReleaseContext(local_8,0);
    local_8 = 0;
    if (BVar1 == 0) {
      uVar2 = (*pcVar4)();
      if (0 < (int)uVar2) {
        uVar2 = uVar2 & 0xffff | 0x80070000;
      }
      if (-1 < (int)uVar2) {
        uVar2 = 0x80004005;
      }
    }
    CertFreeCertificateContext(local_c);
    if ((int)uVar2 < 0) {
      if (pSubjectContext == (PCCERT_CONTEXT)0x0) {
        return uVar2;
      }
      local_c = pSubjectContext;
      CertFreeCertificateContext(pSubjectContext);
      return uVar2;
    }
    if (pSubjectContext == (PCCERT_CONTEXT)0x0) {
      return uVar2;
    }
  } while( true );
}



// WARNING: Could not reconcile some variable overlaps

void FUN_10009b10(void)

{
  DWORDLONG dwlConditionMask;
  undefined8 uVar1;
  undefined4 uStack_164;
  undefined8 uStack_160;
  DWORD DStack_158;
  DWORD DStack_154;
  DWORD DStack_150;
  undefined4 uStack_14c;
  undefined4 uStack_148;
  undefined auStack_134 [4];
  undefined4 local_130;
  undefined4 local_12c;
  undefined4 local_128;
  undefined4 local_124;
  undefined4 local_120;
  undefined local_11c [208];
  WORD WStack_4c;
  uint uStack_3c;
  undefined2 local_1c;
  undefined4 local_1a;
  undefined2 local_16;
  uint local_c;
  
  local_c = DAT_10012024 ^ (uint)auStack_134;
  local_130 = 0x11c;
  local_12c = 0;
  local_128 = 0;
  local_124 = 0;
  local_120 = 0;
  uStack_148 = 0x10009b64;
  memset(local_11c,0,0x100);
  local_1c = 0;
  local_1a = 0;
  uStack_148 = 1;
  uStack_14c = 3;
  DStack_150 = 2;
  DStack_154 = 0;
  DStack_158 = 0;
  local_16 = 0;
  uStack_160._4_4_ = 0x10009b96;
  uStack_160 = VerSetConditionMask();
  uStack_164 = 0x10009b9a;
  uVar1 = VerSetConditionMask();
  uStack_164 = (undefined4)((ulonglong)uVar1 >> 0x20);
  dwlConditionMask = (DWORDLONG)VerSetConditionMask((int)uVar1);
  uStack_160._4_4_ = 10;
  DStack_158 = 0;
  WStack_4c = 0;
  VerifyVersionInfoW((LPOSVERSIONINFOEXW)&uStack_160,0x23,dwlConditionMask);
  ___security_check_cookie_4(uStack_3c ^ (uint)&uStack_164);
  return;
}



// WARNING: Could not reconcile some variable overlaps

void FUN_10009be0(void)

{
  char cVar1;
  HMODULE hModule;
  FARPROC pFVar2;
  int *piVar3;
  double dVar4;
  double dVar5;
  uint in_stack_fffffddc;
  undefined4 *puVar6;
  undefined local_20c [4];
  undefined4 uStack_208;
  char *lpProcName;
  int local_1e8 [4];
  int local_1d8 [2];
  undefined4 local_1d0 [2];
  basic_iostream_char_struct_std__char_traits_char___ local_1c8 [72];
  basic_ios_char_struct_std__char_traits_char___ local_180 [72];
  undefined *local_138;
  undefined *local_134;
  undefined4 local_130;
  int local_12c;
  int local_124;
  uint local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000befc;
  local_10 = ExceptionList;
  local_14 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_10;
  FUN_10001b00(local_1e8);
  local_134 = local_20c;
  local_8 = 0;
  local_20c[0] = 0;
  FUN_10002250(local_20c,&DAT_1000d57c,(int *)0x4);
  local_8._0_1_ = 1;
  puVar6 = (undefined4 *)(in_stack_fffffddc & 0xffffff00);
  FUN_10002250(&stack0xfffffddc,"Check windows version",(int *)0x15);
  local_8._0_1_ = 0;
  FUN_10005830(puVar6);
  lpProcName = "RtlGetVersion";
  hModule = GetModuleHandleA("ntdll");
  pFVar2 = GetProcAddress(hModule,lpProcName);
  if (pFVar2 != (FARPROC)0x0) {
    cVar1 = FUN_10009b10();
    if (cVar1 != '\0') {
      local_130 = 0x11c;
      (*pFVar2)();
      dVar5 = (double)local_12c + *(double *)(&DAT_1000dee0 + (local_12c >> 0x1f) * -8);
      dVar4 = (double)local_124 + *(double *)(&DAT_1000dee0 + (local_124 >> 0x1f) * -8);
      if ((dVar5 != 10.0) || (17763.0 <= dVar4)) {
        uStack_208 = 0x10009dc0;
        piVar3 = FUN_100023d0(local_1d8,"Clipboard history can be cleared for Windows ");
        uStack_208 = 0x10009dc8;
        piVar3 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                                  ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,
                                   dVar5);
        piVar3 = FUN_100023d0(piVar3," with build number ");
        std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                  ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,dVar4);
        local_138 = local_20c;
        local_20c[0] = 0;
        FUN_10002250(local_20c,&DAT_1000d57c,(int *)0x4);
        local_8._0_1_ = 3;
        FUN_10001a40(local_1e8,&stack0xfffffddc);
        local_8._0_1_ = 0;
        FUN_10005830(puVar6);
      }
      else {
        uStack_208 = 0x10009d38;
        piVar3 = FUN_100023d0(local_1d8,"Clipboard history cannot be cleared for Windows ");
        uStack_208 = 0x10009d40;
        piVar3 = (int *)std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                                  ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,
                                   dVar5);
        piVar3 = FUN_100023d0(piVar3," with build number ");
        std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
                  ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,dVar4);
        local_138 = local_20c;
        local_20c[0] = 0;
        FUN_10002250(local_20c,&DAT_1000d57c,(int *)0x4);
        local_8._0_1_ = 2;
        FUN_10001a40(local_1e8,&stack0xfffffddc);
        local_8._0_1_ = 0;
        FUN_10005830(puVar6);
      }
    }
  }
  *(undefined ***)((int)local_1e8 + *(int *)(local_1e8[0] + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_1d0 + *(int *)(local_1e8[0] + 4) + -0x1c) = *(int *)(local_1e8[0] + 4) + -0x68
  ;
  FUN_100020a0(local_1d0);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(local_1c8);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(local_180);
  ExceptionList = local_10;
  ___security_check_cookie_4(local_14 ^ (uint)&stack0xfffffffc);
  return;
}



void __cdecl FUN_10009e90(undefined4 param_1,undefined param_2)

{
  undefined4 uVar1;
  undefined4 *puVar2;
  undefined4 uVar3;
  undefined1 *puVar4;
  
  uVar1 = __acrt_iob_func(1);
  puVar4 = &param_2;
  uVar3 = 0;
  puVar2 = (undefined4 *)FUN_10005cd0();
  __stdio_common_vfwprintf(*puVar2,puVar2[1],uVar1,param_1,uVar3,puVar4);
  return;
}



// WARNING: Could not reconcile some variable overlaps

uint FUN_10009ec0(int param_1)

{
  HLOCAL hMem;
  HMODULE hModule;
  FARPROC pFVar1;
  DWORD DVar2;
  int *piVar3;
  int iVar4;
  uint uVar5;
  int iVar6;
  byte bVar7;
  undefined4 *in_stack_fffffed0;
  undefined4 *in_stack_fffffee0;
  uint uStack_118;
  undefined4 *in_stack_fffffef0;
  uint uStack_108;
  undefined4 uVar8;
  char *lpProcName;
  int local_d0 [4];
  int local_c0 [2];
  undefined4 local_b8 [2];
  basic_iostream_char_struct_std__char_traits_char___ local_b0 [72];
  basic_ios_char_struct_std__char_traits_char___ local_68 [72];
  uint *local_20;
  undefined *local_1c;
  HLOCAL local_18;
  SIZE_T local_14;
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  local_8 = 0xffffffff;
  puStack_c = &LAB_1000bf53;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  local_14 = 0;
  local_18 = (HLOCAL)0x0;
  bVar7 = 0;
  FUN_10001b00(local_d0);
  lpProcName = "NtQuerySystemInformation";
  local_8 = 0;
  hModule = GetModuleHandleA("NtDll.dll");
  pFVar1 = GetProcAddress(hModule,lpProcName);
  if (pFVar1 == (FARPROC)0x0) {
    DVar2 = GetLastError();
    piVar3 = FUN_100023d0(local_c0,"Error while retrieving address of NtQuerySystemInformation ");
    std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,DVar2);
    local_1c = &stack0xffffff08;
    FUN_10002250(&stack0xffffff08,&DAT_1000d57c,(int *)0x4);
    local_8._0_1_ = 1;
    uStack_118 = 0x10009f85;
    FUN_10001a40(local_d0,&stack0xfffffef0);
    local_8 = (uint)local_8._1_3_ << 8;
    FUN_10005830(in_stack_fffffef0);
  }
  iVar4 = (*pFVar1)();
  if (iVar4 == -0x3ffffffc) {
    local_18 = LocalAlloc(0,local_14);
  }
  else {
    DVar2 = GetLastError();
    piVar3 = FUN_100023d0(local_c0,"Error while retrieving address of NtQuerySystemInformation ");
    std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,DVar2);
    local_20 = &uStack_108;
    uStack_108 = uStack_108 & 0xffffff00;
    FUN_10002250(&uStack_108,&DAT_1000d57c,(int *)0x4);
    local_8._0_1_ = 2;
    FUN_10001a40(local_d0,&stack0xfffffee0);
    local_8 = (uint)local_8._1_3_ << 8;
    FUN_10005830(in_stack_fffffee0);
  }
  uVar8 = 5;
  iVar4 = (*pFVar1)();
  if (iVar4 != 0) {
    DVar2 = GetLastError();
    uStack_108 = 0x1000a038;
    piVar3 = FUN_100023d0(local_c0,"Error while retrieving address of NtQuerySystemInformation ");
    uStack_108 = 0x1000a040;
    std::basic_ostream<char,struct_std::char_traits<char>_>::operator__
              ((basic_ostream_char_struct_std__char_traits_char___ *)piVar3,DVar2);
    local_20 = &uStack_118;
    uStack_108 = 0;
    uStack_118 = uStack_118 & 0xffffff00;
    FUN_10002250(&uStack_118,&DAT_1000d57c,(int *)0x4);
    local_8._0_1_ = 3;
    FUN_10001a40(local_d0,&stack0xfffffed0);
    local_8 = (uint)local_8._1_3_ << 8;
    FUN_10005830(in_stack_fffffed0);
  }
  hMem = local_18;
  iVar4 = 0;
  do {
    iVar6 = *(int *)(iVar4 + 0x44 + (int)hMem);
    if (iVar6 == 0) {
      *(wchar_t **)(iVar4 + 0x3c + (int)hMem) = L"System Idle Process";
    }
    if ((param_1 == iVar6) && (iVar6 = *(int *)(iVar4 + 4 + (int)hMem), iVar6 != 0)) {
      piVar3 = (int *)((int)hMem + iVar4 + 0xf0);
      do {
        if (piVar3[-1] == 5) {
          if (*piVar3 == 5) {
            bVar7 = 1;
          }
        }
        piVar3 = piVar3 + 0x10;
        iVar6 = iVar6 + -1;
      } while (iVar6 != 0);
    }
    uStack_108 = 0x1000a0d6;
    FUN_10009e90(&DAT_1000decc,(char)uVar8);
    piVar3 = (int *)(iVar4 + (int)hMem);
    iVar4 = iVar4 + *piVar3;
  } while (*piVar3 != 0);
  uStack_108 = 0x1000a0ee;
  LocalFree(hMem);
  *(undefined ***)((int)local_d0 + *(int *)(local_d0[0] + 4)) =
       std::basic_stringstream<char,struct_std::char_traits<char>,class_std::allocator<char>_>::
       vftable;
  *(int *)((int)local_b8 + *(int *)(local_d0[0] + 4) + -0x1c) = *(int *)(local_d0[0] + 4) + -0x68;
  uVar5 = FUN_100020a0(local_b8);
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___(local_b0);
  std::basic_ios<char,struct_std::char_traits<char>_>::
  _basic_ios_char_struct_std__char_traits_char___(local_68);
  ExceptionList = local_10;
  return uVar5 & 0xffffff00 | (uint)bVar7;
}



void __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::_Lock
          (basic_streambuf_char_struct_std__char_traits_char___ *this)

{
                    // WARNING: Could not recover jumptable at 0x1000a14b. Too many branches
                    // WARNING: Treating indirect jump as call
  _Lock(this);
  return;
}



void __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::_Unlock
          (basic_streambuf_char_struct_std__char_traits_char___ *this)

{
                    // WARNING: Could not recover jumptable at 0x1000a151. Too many branches
                    // WARNING: Treating indirect jump as call
  _Unlock(this);
  return;
}



__int64 __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::showmanyc
          (basic_streambuf_char_struct_std__char_traits_char___ *this)

{
  __int64 _Var1;
  
                    // WARNING: Could not recover jumptable at 0x1000a157. Too many branches
                    // WARNING: Treating indirect jump as call
  _Var1 = showmanyc(this);
  return _Var1;
}



int __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::uflow
          (basic_streambuf_char_struct_std__char_traits_char___ *this)

{
  int iVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000a15d. Too many branches
                    // WARNING: Treating indirect jump as call
  iVar1 = uflow(this);
  return iVar1;
}



__int64 __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::xsgetn
          (basic_streambuf_char_struct_std__char_traits_char___ *this,char *param_1,__int64 param_2)

{
  __int64 _Var1;
  
                    // WARNING: Could not recover jumptable at 0x1000a163. Too many branches
                    // WARNING: Treating indirect jump as call
  _Var1 = xsgetn(this,param_1,param_2);
  return _Var1;
}



__int64 __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::xsputn
          (basic_streambuf_char_struct_std__char_traits_char___ *this,char *param_1,__int64 param_2)

{
  __int64 _Var1;
  
                    // WARNING: Could not recover jumptable at 0x1000a169. Too many branches
                    // WARNING: Treating indirect jump as call
  _Var1 = xsputn(this,param_1,param_2);
  return _Var1;
}



basic_streambuf_char_struct_std__char_traits_char___ * __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::setbuf
          (basic_streambuf_char_struct_std__char_traits_char___ *this,char *param_1,__int64 param_2)

{
  basic_streambuf_char_struct_std__char_traits_char___ *pbVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000a16f. Too many branches
                    // WARNING: Treating indirect jump as call
  pbVar1 = setbuf(this,param_1,param_2);
  return pbVar1;
}



int __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::sync
          (basic_streambuf_char_struct_std__char_traits_char___ *this)

{
  int iVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000a175. Too many branches
                    // WARNING: Treating indirect jump as call
  iVar1 = sync(this);
  return iVar1;
}



void __thiscall
std::basic_streambuf<char,struct_std::char_traits<char>_>::imbue
          (basic_streambuf_char_struct_std__char_traits_char___ *this,locale *param_1)

{
                    // WARNING: Could not recover jumptable at 0x1000a17b. Too many branches
                    // WARNING: Treating indirect jump as call
  imbue(this,param_1);
  return;
}



// Library Function - Single Match
//  void __stdcall _com_issue_error(long)
// 
// Library: Visual Studio 2017 Release

void _com_issue_error(long param_1)

{
  undefined *puVar1;
  undefined4 uVar2;
  
  puVar1 = PTR_FUN_10012000;
  uVar2 = 0;
  _guard_check_icall();
  (*(code *)puVar1)(param_1,uVar2);
  return;
}



// WARNING: Function: __alloca_probe_16 replaced with injection: alloca_probe
// Library Function - Multiple Matches With Same Base Name
//  unsigned short * __stdcall _com_util::ConvertStringToBSTR(char const *)
//  wchar_t * __stdcall _com_util::ConvertStringToBSTR(char const *)
// 
// Library: Visual Studio 2017 Release

void ConvertStringToBSTR(LPCSTR param_1)

{
  char *cbMultiByte;
  char cVar1;
  code *pcVar2;
  uint uVar3;
  int iVar4;
  BSTR pOVar5;
  DWORD DVar6;
  LPCSTR pCVar7;
  uint *unaff_ESI;
  int unaff_EDI;
  uint local_3c;
  void *local_14;
  code *pcStack_10;
  uint local_c;
  undefined4 local_8;
  
  local_8 = 0xfffffffe;
  pcStack_10 = FUN_1000a85b;
  local_14 = ExceptionList;
  local_c = DAT_10012024 ^ 0x1000f0e0;
  uVar3 = DAT_10012024 ^ (uint)&stack0xfffffffc;
  ExceptionList = &local_14;
  local_3c = uVar3;
  if (param_1 == (LPCSTR)0x0) {
LAB_1000a2c9:
    ExceptionList = local_14;
    ___security_check_cookie_4(uVar3 ^ (uint)&stack0xfffffffc);
    return;
  }
  pCVar7 = param_1;
  do {
    cVar1 = *pCVar7;
    pCVar7 = pCVar7 + 1;
  } while (cVar1 != '\0');
  cbMultiByte = pCVar7 + (1 - (int)(param_1 + 1));
  if (cbMultiByte < (char *)0x80000000) {
    unaff_EDI = MultiByteToWideChar(0,0,param_1,(int)cbMultiByte,(LPWSTR)0x0,0);
    if (unaff_EDI == 0) goto LAB_1000a2f4;
    local_8 = 0;
    if (unaff_EDI < 0x1000) {
      unaff_ESI = &local_3c;
    }
    else {
      unaff_ESI = (uint *)malloc(unaff_EDI * 2);
    }
    local_8 = 0xfffffffe;
    if (unaff_ESI == (uint *)0x0) goto LAB_1000a30c;
    iVar4 = MultiByteToWideChar(0,0,param_1,(int)cbMultiByte,(LPWSTR)unaff_ESI,unaff_EDI);
    if (iVar4 != 0) {
      pOVar5 = SysAllocString((OLECHAR *)unaff_ESI);
      if (0xfff < unaff_EDI) {
        free(unaff_ESI);
      }
      if (pOVar5 != (BSTR)0x0) goto LAB_1000a2c9;
      goto LAB_1000a33f;
    }
  }
  else {
    _com_issue_error(-0x7ff8ffa9);
LAB_1000a2f4:
    DVar6 = GetLastError();
    if (0 < (int)DVar6) {
      DVar6 = DVar6 & 0xffff | 0x80070000;
    }
    _com_issue_error(DVar6);
LAB_1000a30c:
    _com_issue_error(-0x7ff8fff2);
  }
  if (0xfff < unaff_EDI) {
    free(unaff_ESI);
  }
  DVar6 = GetLastError();
  if (0 < (int)DVar6) {
    DVar6 = DVar6 & 0xffff | 0x80070000;
  }
  _com_issue_error(DVar6);
LAB_1000a33f:
  _com_issue_error(-0x7ff8fff2);
  pcVar2 = (code *)swi(3);
  (*pcVar2)();
  return;
}



// Library Function - Single Match
//  public: __thiscall _com_error::_com_error(class _com_error const &)
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

_com_error * __thiscall _com_error::_com_error(_com_error *this,_com_error *param_1)

{
  code *pcVar1;
  int *piVar2;
  
  *(undefined ***)this = &PTR__scalar_deleting_destructor__1000d300;
  *(undefined4 *)(this + 4) = *(undefined4 *)(param_1 + 4);
  piVar2 = *(int **)(param_1 + 8);
  *(int **)(this + 8) = piVar2;
  *(undefined4 *)(this + 0xc) = 0;
  if (piVar2 != (int *)0x0) {
    pcVar1 = *(code **)(*piVar2 + 4);
    _guard_check_icall();
    (*pcVar1)(piVar2);
  }
  return this;
}



// Library Function - Single Match
//  public: __thiscall _com_error::_com_error(long,struct IErrorInfo *,bool)
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

_com_error * __thiscall
_com_error::_com_error(_com_error *this,long param_1,IErrorInfo *param_2,bool param_3)

{
  code *pcVar1;
  
  *(undefined ***)this = &PTR__scalar_deleting_destructor__1000d300;
  *(long *)(this + 4) = param_1;
  *(IErrorInfo **)(this + 8) = param_2;
  *(undefined4 *)(this + 0xc) = 0;
  if ((param_2 != (IErrorInfo *)0x0) && (param_3)) {
    pcVar1 = *(code **)(*(int *)param_2 + 4);
    _guard_check_icall();
    (*pcVar1)(param_2);
  }
  return this;
}



// Library Function - Single Match
//  public: virtual void * __thiscall _com_error::`scalar deleting destructor'(unsigned int)
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

void * __thiscall _com_error::_scalar_deleting_destructor_(_com_error *this,uint param_1)

{
  code *pcVar1;
  int *piVar2;
  
  piVar2 = *(int **)(this + 8);
  *(undefined ***)this = &PTR__scalar_deleting_destructor__1000d300;
  if (piVar2 != (int *)0x0) {
    pcVar1 = *(code **)(*piVar2 + 8);
    _guard_check_icall();
    (*pcVar1)(piVar2);
  }
  if (*(HLOCAL *)(this + 0xc) != (HLOCAL)0x0) {
    LocalFree(*(HLOCAL *)(this + 0xc));
  }
  if ((param_1 & 1) != 0) {
    FUN_1000a4db(this);
  }
  return this;
}



void FUN_1000a470(long param_1,IErrorInfo *param_2)

{
  _com_error local_14 [16];
  
  _com_error::_com_error(local_14,param_1,param_2,false);
                    // WARNING: Subroutine does not return
  _CxxThrowException(local_14,(ThrowInfo *)&DAT_1000f0fc);
}



// Library Function - Single Match
//  @__security_check_cookie@4
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

void __fastcall ___security_check_cookie_4(int param_1)

{
  if (param_1 == DAT_10012024) {
    return;
  }
  ___report_gsfailure();
  return;
}



void __cdecl free(void *_Memory)

{
  free(_Memory);
  return;
}



void __cdecl FUN_1000a4ab(size_t param_1)

{
  int iVar1;
  void *pvVar2;
  undefined4 local_14 [2];
  undefined4 uStack_c;
  
  do {
    uStack_c = 0x1000a4c5;
    pvVar2 = malloc(param_1);
    if (pvVar2 != (void *)0x0) {
      return;
    }
    uStack_c = 0x1000a4b8;
    iVar1 = _callnewh(param_1);
  } while (iVar1 != 0);
  if (param_1 != 0xffffffff) {
    FUN_1000adf2();
    return;
  }
  FUN_1000ad70(local_14);
                    // WARNING: Subroutine does not return
  _CxxThrowException(local_14,(ThrowInfo *)&DAT_1000f200);
}



void __cdecl FUN_1000a4db(void *param_1)

{
  free(param_1);
  return;
}



void __cdecl FUN_1000a4e9(size_t param_1)

{
  FUN_1000a4ab(param_1);
  return;
}



undefined4 * __thiscall FUN_1000a4f2(void *this,byte param_1)

{
  *(undefined ***)this = type_info::vftable;
  if ((param_1 & 1) != 0) {
    FUN_1000a4db(this);
  }
  return (undefined4 *)this;
}



// Library Function - Single Match
//  struct _IMAGE_SECTION_HEADER * __cdecl find_pe_section(unsigned char * const,unsigned int)
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

_IMAGE_SECTION_HEADER * __cdecl find_pe_section(uchar *param_1,uint param_2)

{
  int iVar1;
  _IMAGE_SECTION_HEADER *p_Var2;
  _IMAGE_SECTION_HEADER *p_Var3;
  
  iVar1 = *(int *)(param_1 + 0x3c);
  p_Var2 = (_IMAGE_SECTION_HEADER *)
           (param_1 + (uint)*(ushort *)(param_1 + iVar1 + 0x14) + iVar1 + 0x18);
  p_Var3 = p_Var2 + (uint)*(ushort *)(param_1 + iVar1 + 6) * 0x28;
  while( true ) {
    if (p_Var2 == p_Var3) {
      return (_IMAGE_SECTION_HEADER *)0x0;
    }
    if ((*(uint *)(p_Var2 + 0xc) <= param_2) &&
       (param_2 < (uint)(*(int *)(p_Var2 + 8) + *(int *)(p_Var2 + 0xc)))) break;
    p_Var2 = p_Var2 + 0x28;
  }
  return p_Var2;
}



// Library Function - Single Match
//  ___scrt_acquire_startup_lock
// 
// Library: Visual Studio 2017 Release

uint ___scrt_acquire_startup_lock(void)

{
  void *pvVar1;
  bool bVar2;
  undefined3 extraout_var;
  void *pvVar3;
  
  bVar2 = ___scrt_is_ucrt_dll_in_use();
  pvVar3 = (void *)CONCAT31(extraout_var,bVar2);
  if (pvVar3 != (void *)0x0) {
    while( true ) {
      pvVar3 = (void *)0x0;
      LOCK();
      pvVar1 = StackBase;
      if (DAT_10012360 != (void *)0x0) {
        pvVar3 = DAT_10012360;
        pvVar1 = DAT_10012360;
      }
      DAT_10012360 = pvVar1;
      if (pvVar3 == (void *)0x0) break;
      if (StackBase == pvVar3) {
        return CONCAT31((int3)((uint)pvVar3 >> 8),1);
      }
    }
  }
  return (uint)pvVar3 & 0xffffff00;
}



// Library Function - Single Match
//  ___scrt_dllmain_after_initialize_c
// 
// Library: Visual Studio 2017 Release

undefined4 ___scrt_dllmain_after_initialize_c(void)

{
  bool bVar1;
  undefined3 extraout_var;
  undefined4 uVar2;
  uint uVar3;
  
  bVar1 = ___scrt_is_ucrt_dll_in_use();
  if (CONCAT31(extraout_var,bVar1) == 0) {
    uVar2 = FUN_1000afd0();
    uVar3 = _configure_narrow_argv(uVar2);
    if (uVar3 != 0) {
      return uVar3 & 0xffffff00;
    }
    uVar2 = _initialize_narrow_environment();
  }
  else {
    uVar2 = ___isa_available_init();
  }
  return CONCAT31((int3)((uint)uVar2 >> 8),1);
}



// Library Function - Single Match
//  ___scrt_dllmain_before_initialize_c
// 
// Library: Visual Studio 2017 Release

uint ___scrt_dllmain_before_initialize_c(void)

{
  uint uVar1;
  
  uVar1 = ___scrt_initialize_onexit_tables(0);
  return uVar1 & 0xffffff00 | (uint)((char)uVar1 != '\0');
}



// Library Function - Single Match
//  ___scrt_dllmain_crt_thread_attach
// 
// Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release

undefined ___scrt_dllmain_crt_thread_attach(void)

{
  char cVar1;
  
  cVar1 = FUN_1000b3a1();
  if (cVar1 != '\0') {
    cVar1 = FUN_1000b3a1();
    if (cVar1 != '\0') {
      return 1;
    }
    FUN_1000b3a1();
  }
  return 0;
}



// Library Function - Single Match
//  ___scrt_dllmain_crt_thread_detach
// 
// Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release

undefined ___scrt_dllmain_crt_thread_detach(void)

{
  FUN_1000b3a1();
  FUN_1000b3a1();
  return 1;
}



// Library Function - Single Match
//  ___scrt_dllmain_exception_filter
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

void __cdecl
___scrt_dllmain_exception_filter
          (undefined4 param_1,int param_2,undefined4 param_3,undefined *param_4,undefined4 param_5,
          undefined4 param_6)

{
  bool bVar1;
  undefined3 extraout_var;
  int iVar2;
  
  bVar1 = ___scrt_is_ucrt_dll_in_use();
  iVar2 = CONCAT31(extraout_var,bVar1);
  if ((iVar2 == 0) && (param_2 == 1)) {
    _guard_check_icall();
    (*(code *)param_4)(param_1,iVar2,param_3);
  }
  _seh_filter_dll(param_5,param_6);
  return;
}



void FUN_1000a624(void)

{
  bool bVar1;
  undefined3 extraout_var;
  int iVar2;
  
  bVar1 = ___scrt_is_ucrt_dll_in_use();
  if (CONCAT31(extraout_var,bVar1) != 0) {
    _execute_onexit_table(&DAT_10012368);
    return;
  }
  iVar2 = FUN_1000b3a4();
  if (iVar2 != 0) {
    return;
  }
                    // WARNING: Could not recover jumptable at 0x1000b389. Too many branches
                    // WARNING: Treating indirect jump as call
  _cexit();
  return;
}



void FUN_1000a647(void)

{
  FUN_1000b3a1();
  FUN_1000b3a1();
  return;
}



// Library Function - Single Match
//  ___scrt_initialize_crt
// 
// Library: Visual Studio 2017 Release

uint __cdecl ___scrt_initialize_crt(int param_1)

{
  uint uVar1;
  undefined4 uVar2;
  
  if (param_1 == 0) {
    DAT_10012364 = 1;
  }
  ___isa_available_init();
  uVar1 = FUN_1000b3a1();
  if ((char)uVar1 != '\0') {
    uVar2 = FUN_1000b3a1();
    if ((char)uVar2 != '\0') {
      return CONCAT31((int3)((uint)uVar2 >> 8),1);
    }
    uVar1 = FUN_1000b3a1();
  }
  return uVar1 & 0xffffff00;
}



// Library Function - Single Match
//  ___scrt_initialize_onexit_tables
// 
// Library: Visual Studio 2017 Release

undefined4 __cdecl ___scrt_initialize_onexit_tables(int param_1)

{
  code *pcVar1;
  byte bVar2;
  bool bVar3;
  undefined4 in_EAX;
  undefined3 extraout_var;
  uint uVar4;
  undefined4 uVar5;
  
  if (DAT_10012365 != '\0') {
    return CONCAT31((int3)((uint)in_EAX >> 8),1);
  }
  if ((param_1 != 0) && (param_1 != 1)) {
    ___scrt_fastfail(5);
    pcVar1 = (code *)swi(3);
    uVar5 = (*pcVar1)();
    return uVar5;
  }
  bVar3 = ___scrt_is_ucrt_dll_in_use();
  if ((CONCAT31(extraout_var,bVar3) == 0) || (param_1 != 0)) {
    bVar2 = 0x20 - ((byte)DAT_10012024 & 0x1f) & 0x1f;
    uVar4 = (0xffffffffU >> bVar2 | -1 << 0x20 - bVar2) ^ DAT_10012024;
    DAT_10012368 = uVar4;
    DAT_1001236c = uVar4;
    DAT_10012370 = uVar4;
    DAT_10012374 = uVar4;
    DAT_10012378 = uVar4;
    DAT_1001237c = uVar4;
LAB_1000a71e:
    DAT_10012365 = '\x01';
    uVar4 = CONCAT31((int3)(uVar4 >> 8),1);
  }
  else {
    uVar4 = _initialize_onexit_table(&DAT_10012368);
    if (uVar4 == 0) {
      uVar4 = _initialize_onexit_table(&DAT_10012374);
      if (uVar4 == 0) goto LAB_1000a71e;
    }
    uVar4 = uVar4 & 0xffffff00;
  }
  return uVar4;
}



// WARNING: Function: __SEH_prolog4 replaced with injection: SEH_prolog4
// Library Function - Single Match
//  ___scrt_is_nonwritable_in_current_image
// 
// Library: Visual Studio 2017 Release

uint __cdecl ___scrt_is_nonwritable_in_current_image(int param_1)

{
  _IMAGE_SECTION_HEADER *p_Var1;
  uint uVar2;
  void *local_14;
  
  p_Var1 = find_pe_section((uchar *)&IMAGE_DOS_HEADER_10000000,param_1 + 0xf0000000);
  if ((p_Var1 == (_IMAGE_SECTION_HEADER *)0x0) || (*(int *)(p_Var1 + 0x24) < 0)) {
    uVar2 = (uint)p_Var1 & 0xffffff00;
  }
  else {
    uVar2 = CONCAT31((int3)((uint)p_Var1 >> 8),1);
  }
  ExceptionList = local_14;
  return uVar2;
}



// Library Function - Single Match
//  ___scrt_release_startup_lock
// 
// Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release

int __cdecl ___scrt_release_startup_lock(char param_1)

{
  int iVar1;
  bool bVar2;
  undefined3 extraout_var;
  int iVar3;
  
  bVar2 = ___scrt_is_ucrt_dll_in_use();
  iVar1 = DAT_10012360;
  iVar3 = CONCAT31(extraout_var,bVar2);
  if ((iVar3 != 0) && (param_1 == '\0')) {
    DAT_10012360 = 0;
    iVar3 = iVar1;
  }
  return iVar3;
}



// Library Function - Single Match
//  ___scrt_uninitialize_crt
// 
// Library: Visual Studio 2017 Release

undefined __cdecl ___scrt_uninitialize_crt(undefined4 param_1,char param_2)

{
  if ((DAT_10012364 == '\0') || (param_2 == '\0')) {
    FUN_1000b3a1();
    FUN_1000b3a1();
  }
  return 1;
}



// Library Function - Single Match
//  __onexit
// 
// Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release

_onexit_t __cdecl __onexit(_onexit_t _Func)

{
  int iVar1;
  byte bVar2;
  
  bVar2 = (byte)DAT_10012024 & 0x1f;
  if (((DAT_10012024 ^ DAT_10012368) >> bVar2 | (DAT_10012024 ^ DAT_10012368) << 0x20 - bVar2) ==
      0xffffffff) {
    iVar1 = _crt_atexit();
  }
  else {
    iVar1 = _register_onexit_function(&DAT_10012368,_Func);
  }
  return (_onexit_t)(~-(uint)(iVar1 != 0) & (uint)_Func);
}



// Library Function - Single Match
//  _atexit
// 
// Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release

int __cdecl _atexit(void *param_1)

{
  _onexit_t p_Var1;
  
  p_Var1 = __onexit((_onexit_t)param_1);
  return (p_Var1 != (_onexit_t)0x0) - 1;
}



void __cdecl
FUN_1000a85b(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4)

{
  _except_handler4_common(&DAT_10012024,___security_check_cookie_4,param_1,param_2,param_3,param_4);
  return;
}



void FUN_1000a87e(size_t param_1)

{
  FUN_1000b16b(param_1);
  return;
}



// Library Function - Single Match
//  int __stdcall dllmain_crt_dispatch(struct HINSTANCE__ * const,unsigned long,void * const)
// 
// Library: Visual Studio 2017 Release

int dllmain_crt_dispatch(HINSTANCE__ *param_1,ulong param_2,void *param_3)

{
  uint uVar1;
  
  if (param_2 == 0) {
    uVar1 = dllmain_crt_process_detach(param_3 != (void *)0x0);
  }
  else if (param_2 == 1) {
    uVar1 = dllmain_crt_process_attach(param_1,param_3);
  }
  else {
    if (param_2 == 2) {
      uVar1 = ___scrt_dllmain_crt_thread_attach();
    }
    else {
      if (param_2 != 3) {
        return 1;
      }
      uVar1 = ___scrt_dllmain_crt_thread_detach();
    }
    uVar1 = uVar1 & 0xff;
  }
  return uVar1;
}



// WARNING: Function: __SEH_prolog4 replaced with injection: SEH_prolog4
// WARNING: Globals starting with '_' overlap smaller symbols at the same address
// Library Function - Single Match
//  int __cdecl dllmain_crt_process_attach(struct HINSTANCE__ * const,void * const)
// 
// Library: Visual Studio 2017 Release

int __cdecl dllmain_crt_process_attach(HINSTANCE__ *param_1,void *param_2)

{
  code *pcVar1;
  bool bVar2;
  undefined4 uVar3;
  uint uVar4;
  int iVar5;
  code **ppcVar6;
  void *local_14;
  
  uVar3 = ___scrt_initialize_crt(0);
  if ((char)uVar3 != '\0') {
    ___scrt_acquire_startup_lock();
    bVar2 = true;
    if (_DAT_1001235c != 0) {
      ___scrt_fastfail(7);
      pcVar1 = (code *)swi(3);
      iVar5 = (*pcVar1)();
      return iVar5;
    }
    _DAT_1001235c = 1;
    uVar4 = ___scrt_dllmain_before_initialize_c();
    if ((char)uVar4 != '\0') {
      __RTC_Initialize();
      FUN_1000b253();
      ___scrt_initialize_default_local_stdio_options();
      iVar5 = _initterm_e(&DAT_1000d2e0,&DAT_1000d2e4);
      if ((iVar5 == 0) && (uVar3 = ___scrt_dllmain_after_initialize_c(), (char)uVar3 != '\0')) {
        _initterm(&DAT_1000d2c8,&DAT_1000d2dc);
        _DAT_1001235c = 2;
        bVar2 = false;
      }
    }
    FUN_1000a9d2();
    if (!bVar2) {
      ppcVar6 = (code **)FUN_1000b28e();
      if ((*ppcVar6 != (code *)0x0) &&
         (uVar3 = ___scrt_is_nonwritable_in_current_image((int)ppcVar6), (char)uVar3 != '\0')) {
        uVar3 = 2;
        pcVar1 = *ppcVar6;
        _guard_check_icall();
        (*pcVar1)(param_1,uVar3,param_2);
      }
      DAT_10012380 = DAT_10012380 + 1;
      ExceptionList = local_14;
      return 1;
    }
  }
  ExceptionList = local_14;
  return 0;
}



void FUN_1000a9d2(void)

{
  int unaff_EBP;
  
  ___scrt_release_startup_lock((char)*(undefined4 *)(unaff_EBP + -0x1d));
  return;
}



// WARNING: Function: __SEH_prolog4 replaced with injection: SEH_prolog4
// WARNING: Globals starting with '_' overlap smaller symbols at the same address
// Library Function - Single Match
//  int __cdecl dllmain_crt_process_detach(bool)
// 
// Library: Visual Studio 2017 Release

int __cdecl dllmain_crt_process_detach(bool param_1)

{
  code *pcVar1;
  char cVar2;
  uint uVar3;
  int iVar4;
  undefined3 in_stack_00000005;
  void *local_14;
  
  if (DAT_10012380 < 1) {
    uVar3 = 0;
  }
  else {
    DAT_10012380 = DAT_10012380 + -1;
    ___scrt_acquire_startup_lock();
    if (_DAT_1001235c != 2) {
      ___scrt_fastfail(7);
      pcVar1 = (code *)swi(3);
      iVar4 = (*pcVar1)();
      return iVar4;
    }
    FUN_1000a624();
    __scrt_uninitialize_type_info();
    __RTC_Terminate();
    _DAT_1001235c = 0;
    FUN_1000aa5f();
    cVar2 = ___scrt_uninitialize_crt(_param_1,'\0');
    uVar3 = (uint)(cVar2 != '\0');
  }
  ExceptionList = local_14;
  return uVar3;
}



void FUN_1000aa5f(void)

{
  int unaff_EBP;
  
  FUN_1000a647();
  ___scrt_release_startup_lock((char)*(undefined4 *)(unaff_EBP + -0x1c));
  return;
}



// WARNING: Function: __SEH_prolog4 replaced with injection: SEH_prolog4
// Library Function - Single Match
//  int __cdecl dllmain_dispatch(struct HINSTANCE__ * const,unsigned long,void * const)
// 
// Library: Visual Studio 2017 Release

int __cdecl dllmain_dispatch(HINSTANCE__ *param_1,ulong param_2,void *param_3)

{
  int iVar1;
  void *local_14;
  
  if ((param_2 == 0) && (DAT_10012380 < 1)) {
    iVar1 = 0;
  }
  else if (((param_2 != 1) && (param_2 != 2)) ||
          ((iVar1 = dllmain_raw(param_1,param_2,param_3), iVar1 != 0 &&
           (iVar1 = dllmain_crt_dispatch(param_1,param_2,param_3), iVar1 != 0)))) {
    iVar1 = FUN_100049c0();
    if ((param_2 == 1) && (iVar1 == 0)) {
      FUN_100049c0();
      dllmain_crt_dispatch(param_1,0,param_3);
      dllmain_raw(param_1,0,param_3);
    }
    if (((param_2 == 0) || (param_2 == 3)) &&
       (iVar1 = dllmain_crt_dispatch(param_1,param_2,param_3), iVar1 != 0)) {
      iVar1 = dllmain_raw(param_1,param_2,param_3);
    }
  }
  ExceptionList = local_14;
  return iVar1;
}



// WARNING: Removing unreachable block (ram,0x1000ab8f)
// Library Function - Single Match
//  int __stdcall dllmain_raw(struct HINSTANCE__ * const,unsigned long,void * const)
// 
// Library: Visual Studio 2017 Release

int dllmain_raw(HINSTANCE__ *param_1,ulong param_2,void *param_3)

{
  return 1;
}



void entry(HINSTANCE__ *param_1,ulong param_2,void *param_3)

{
  if (param_2 == 1) {
    ___security_init_cookie();
  }
  dllmain_dispatch(param_1,param_2,param_3);
  return;
}



void _guard_check_icall(void)

{
  return;
}



// WARNING: This is an inlined function
// WARNING: Function: __alloca_probe replaced with injection: alloca_probe
// Library Function - Single Match
//  __alloca_probe_16
// 
// Library: Visual Studio 2017 Release

uint __alloca_probe_16(undefined1 param_1)

{
  uint in_EAX;
  uint uVar1;
  
  uVar1 = 4 - in_EAX & 0xf;
  return in_EAX + uVar1 | -(uint)CARRY4(in_EAX,uVar1);
}



// WARNING: This is an inlined function
// WARNING: Function: __alloca_probe replaced with injection: alloca_probe

uint __alloca_probe_8(undefined1 param_1)

{
  uint in_EAX;
  uint uVar1;
  
  uVar1 = 4 - in_EAX & 7;
  return in_EAX + uVar1 | -(uint)CARRY4(in_EAX,uVar1);
}



// Library Function - Single Match
//  ___raise_securityfailure
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

void __cdecl ___raise_securityfailure(_EXCEPTION_POINTERS *param_1)

{
  HANDLE hProcess;
  UINT uExitCode;
  
  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)0x0);
  UnhandledExceptionFilter(param_1);
  uExitCode = 0xc0000409;
  hProcess = GetCurrentProcess();
  TerminateProcess(hProcess,uExitCode);
  return;
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address
// Library Function - Single Match
//  ___report_gsfailure
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

void __cdecl ___report_gsfailure(void)

{
  code *pcVar1;
  uint uVar2;
  undefined4 extraout_ECX;
  undefined4 extraout_ECX_00;
  undefined4 uVar3;
  undefined4 extraout_EDX;
  undefined4 unaff_EBX;
  undefined4 unaff_EBP;
  undefined4 unaff_ESI;
  undefined4 unaff_EDI;
  undefined2 in_ES;
  undefined2 in_CS;
  undefined2 in_SS;
  undefined2 in_DS;
  undefined2 in_FS;
  undefined2 in_GS;
  byte bVar4;
  byte bVar5;
  byte in_AF;
  byte bVar6;
  byte bVar7;
  byte in_TF;
  byte in_IF;
  byte bVar8;
  byte in_NT;
  byte in_AC;
  byte in_VIF;
  byte in_VIP;
  byte in_ID;
  undefined8 uVar9;
  undefined4 unaff_retaddr;
  
  uVar2 = IsProcessorFeaturePresent(0x17);
  uVar9 = CONCAT44(extraout_EDX,uVar2);
  bVar4 = 0;
  bVar8 = 0;
  bVar7 = (int)uVar2 < 0;
  bVar6 = uVar2 == 0;
  bVar5 = (POPCOUNT(uVar2 & 0xff) & 1U) == 0;
  uVar3 = extraout_ECX;
  if (!(bool)bVar6) {
    pcVar1 = (code *)swi(0x29);
    uVar9 = (*pcVar1)();
    uVar3 = extraout_ECX_00;
  }
  _DAT_10012498 =
       (uint)(in_NT & 1) * 0x4000 | (uint)(bVar8 & 1) * 0x800 | (uint)(in_IF & 1) * 0x200 |
       (uint)(in_TF & 1) * 0x100 | (uint)(bVar7 & 1) * 0x80 | (uint)(bVar6 & 1) * 0x40 |
       (uint)(in_AF & 1) * 0x10 | (uint)(bVar5 & 1) * 4 | (uint)(bVar4 & 1) |
       (uint)(in_ID & 1) * 0x200000 | (uint)(in_VIP & 1) * 0x100000 | (uint)(in_VIF & 1) * 0x80000 |
       (uint)(in_AC & 1) * 0x40000;
  _DAT_1001249c = &stack0x00000004;
  _DAT_100123d8 = 0x10001;
  _DAT_10012388 = 0xc0000409;
  _DAT_1001238c = 1;
  _DAT_10012398 = 1;
  _DAT_1001239c = 2;
  _DAT_10012394 = unaff_retaddr;
  _DAT_10012464 = in_GS;
  _DAT_10012468 = in_FS;
  _DAT_1001246c = in_ES;
  _DAT_10012470 = in_DS;
  _DAT_10012474 = unaff_EDI;
  _DAT_10012478 = unaff_ESI;
  _DAT_1001247c = unaff_EBX;
  _DAT_10012484 = uVar3;
  _DAT_1001248c = unaff_EBP;
  DAT_10012490 = unaff_retaddr;
  _DAT_10012494 = in_CS;
  _DAT_100124a0 = in_SS;
  ___raise_securityfailure((_EXCEPTION_POINTERS *)&PTR_DAT_1000d330);
  _DAT_10012480 = (undefined4)((ulonglong)uVar9 >> 0x20);
  _DAT_10012488 = (undefined4)uVar9;
  return;
}



void __cdecl free(void *_Memory)

{
                    // WARNING: Could not recover jumptable at 0x1000b34d. Too many branches
                    // WARNING: Treating indirect jump as call
  free(_Memory);
  return;
}



undefined4 * __thiscall FUN_1000ad22(void *this,exception *param_1)

{
  std::exception::exception((exception *)this,param_1);
  *(undefined ***)this = std::bad_alloc::vftable;
  return (undefined4 *)this;
}



undefined4 * __fastcall FUN_1000ad3d(undefined4 *param_1)

{
  param_1[1] = 0;
  param_1[2] = 0;
  param_1[1] = "bad allocation";
  *param_1 = std::bad_alloc::vftable;
  return param_1;
}



undefined4 * __thiscall FUN_1000ad55(void *this,exception *param_1)

{
  std::exception::exception((exception *)this,param_1);
  *(undefined ***)this = std::bad_array_new_length::vftable;
  return (undefined4 *)this;
}



undefined4 * __fastcall FUN_1000ad70(undefined4 *param_1)

{
  param_1[1] = 0;
  param_1[2] = 0;
  param_1[1] = "bad array new length";
  *param_1 = std::bad_array_new_length::vftable;
  return param_1;
}



// Library Function - Single Match
//  public: __thiscall std::exception::exception(class std::exception const &)
// 
// Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release

exception * __thiscall std::exception::exception(exception *this,exception *param_1)

{
  *(undefined ***)this = vftable;
  *(undefined4 *)(this + 4) = 0;
  *(undefined4 *)(this + 8) = 0;
  __std_exception_copy(param_1 + 4,this + 4);
  return this;
}



undefined4 * __thiscall FUN_1000adc5(void *this,byte param_1)

{
  *(undefined ***)this = std::exception::vftable;
  __std_exception_destroy((int)this + 4);
  if ((param_1 & 1) != 0) {
    FUN_1000a4db(this);
  }
  return (undefined4 *)this;
}



void FUN_1000adf2(void)

{
  undefined4 local_10 [3];
  
  FUN_1000ad3d(local_10);
                    // WARNING: Subroutine does not return
  _CxxThrowException(local_10,(ThrowInfo *)&DAT_1000f1ac);
}



char * __fastcall FUN_1000ae2c(int param_1)

{
  char *pcVar1;
  
  pcVar1 = *(char **)(param_1 + 4);
  if (pcVar1 == (char *)0x0) {
    pcVar1 = "Unknown exception";
  }
  return pcVar1;
}



// WARNING: Removing unreachable block (ram,0x1000aeb5)
// WARNING: Removing unreachable block (ram,0x1000ae7a)
// WARNING: Removing unreachable block (ram,0x1000af2d)
// WARNING: Globals starting with '_' overlap smaller symbols at the same address
// Library Function - Single Match
//  ___isa_available_init
// 
// Library: Visual Studio 2017 Release

undefined4 ___isa_available_init(void)

{
  int *piVar1;
  uint *puVar2;
  int iVar3;
  uint uVar4;
  BOOL BVar5;
  uint uVar6;
  uint uVar7;
  uint in_XCR0;
  
  _DAT_100126a4 = 0;
  DAT_1001202c = DAT_1001202c | 1;
  BVar5 = IsProcessorFeaturePresent(10);
  uVar4 = DAT_1001202c;
  if (BVar5 != 0) {
    DAT_1001202c = DAT_1001202c | 2;
    _DAT_100126a4 = 1;
    piVar1 = (int *)cpuid_basic_info(0);
    puVar2 = (uint *)cpuid_Version_info(1);
    uVar7 = puVar2[3];
    if (((piVar1[3] ^ 0x6c65746eU | piVar1[2] ^ 0x49656e69U | piVar1[1] ^ 0x756e6547U) == 0) &&
       (((((uVar6 = *puVar2 & 0xfff3ff0, uVar6 == 0x106c0 || (uVar6 == 0x20660)) ||
          (uVar6 == 0x20670)) || ((uVar6 == 0x30650 || (uVar6 == 0x30660)))) || (uVar6 == 0x30670)))
       ) {
      DAT_100126a8 = DAT_100126a8 | 1;
    }
    if (*piVar1 < 7) {
      uVar6 = 0;
    }
    else {
      iVar3 = cpuid_Extended_Feature_Enumeration_info(7);
      uVar6 = *(uint *)(iVar3 + 4);
      if ((uVar6 & 0x200) != 0) {
        DAT_100126a8 = DAT_100126a8 | 2;
      }
    }
    if ((uVar7 & 0x100000) != 0) {
      DAT_1001202c = uVar4 | 6;
      _DAT_100126a4 = 2;
      if ((((uVar7 & 0x8000000) != 0) && ((uVar7 & 0x10000000) != 0)) && ((in_XCR0 & 6) == 6)) {
        DAT_1001202c = uVar4 | 0xe;
        _DAT_100126a4 = 3;
        if ((uVar6 & 0x20) != 0) {
          DAT_1001202c = uVar4 | 0x2e;
          _DAT_100126a4 = 5;
        }
      }
    }
  }
  return 0;
}



undefined4 FUN_1000afd0(void)

{
  return 1;
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address
// Library Function - Single Match
//  ___scrt_is_ucrt_dll_in_use
// 
// Library: Visual Studio 2017 Release

bool ___scrt_is_ucrt_dll_in_use(void)

{
  return _DAT_10012030 != 0;
}



// Library Function - Single Match
//  ___scrt_fastfail
// 
// Library: Visual Studio 2017 Release

void ___scrt_fastfail(undefined4 param_1)

{
  code *pcVar1;
  BOOL BVar2;
  LONG LVar3;
  undefined4 local_328 [39];
  EXCEPTION_RECORD local_5c;
  _EXCEPTION_POINTERS local_c;
  
  BVar2 = IsProcessorFeaturePresent(0x17);
  if (BVar2 != 0) {
    pcVar1 = (code *)swi(0x29);
    (*pcVar1)();
  }
  FUN_1000b0fa();
  memset(local_328,0,0x2cc);
  local_328[0] = 0x10001;
  memset(&local_5c,0,0x50);
  local_5c.ExceptionCode = 0x40000015;
  local_5c.ExceptionFlags = 1;
  BVar2 = IsDebuggerPresent();
  local_c.ExceptionRecord = &local_5c;
  local_c.ContextRecord = (PCONTEXT)local_328;
  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)0x0);
  LVar3 = UnhandledExceptionFilter(&local_c);
  if ((LVar3 == 0) && (BVar2 != 1)) {
    FUN_1000b0fa();
  }
  return;
}



// WARNING: Globals starting with '_' overlap smaller symbols at the same address

void FUN_1000b0fa(void)

{
  _DAT_100126ac = 0;
  return;
}



// WARNING: This is an inlined function
// WARNING: Unable to track spacebase fully for stack
// WARNING: Variable defined which should be unmapped: param_2
// Library Function - Single Match
//  __SEH_prolog4
// 
// Libraries: Visual Studio 2015, Visual Studio 2017, Visual Studio 2019

void __cdecl __SEH_prolog4(undefined4 param_1,int param_2)

{
  int iVar1;
  undefined4 unaff_EBX;
  undefined4 unaff_ESI;
  undefined4 unaff_EDI;
  undefined4 unaff_retaddr;
  uint auStack_1c [5];
  undefined local_8 [8];
  
  iVar1 = -param_2;
  *(undefined4 *)((int)auStack_1c + iVar1 + 0x10) = unaff_EBX;
  *(undefined4 *)((int)auStack_1c + iVar1 + 0xc) = unaff_ESI;
  *(undefined4 *)((int)auStack_1c + iVar1 + 8) = unaff_EDI;
  *(uint *)((int)auStack_1c + iVar1 + 4) = DAT_10012024 ^ (uint)&param_2;
  *(undefined4 *)((int)auStack_1c + iVar1) = unaff_retaddr;
  ExceptionList = local_8;
  return;
}



void FUN_1000b16b(size_t param_1)

{
  void *local_10;
  undefined *puStack_c;
  undefined4 local_8;
  
  puStack_c = &LAB_1000bf71;
  local_10 = ExceptionList;
  ExceptionList = &local_10;
  local_8 = 0;
  FUN_1000a4ab(param_1);
  FUN_1000b1ab();
  return;
}



undefined * Catch_All_1000b1a3(void)

{
  return &DAT_1000b1a9;
}



void FUN_1000b1ab(void)

{
  int unaff_EBP;
  
  ExceptionList = *(void **)(unaff_EBP + -0xc);
  return;
}



// Library Function - Single Match
//  ___get_entropy
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

uint ___get_entropy(void)

{
  DWORD DVar1;
  uint local_18;
  uint local_14;
  _FILETIME local_10;
  uint local_8;
  
  local_10.dwLowDateTime = 0;
  local_10.dwHighDateTime = 0;
  GetSystemTimeAsFileTime(&local_10);
  local_8 = local_10.dwHighDateTime ^ local_10.dwLowDateTime;
  DVar1 = GetCurrentThreadId();
  local_8 = local_8 ^ DVar1;
  DVar1 = GetCurrentProcessId();
  local_8 = local_8 ^ DVar1;
  QueryPerformanceCounter((LARGE_INTEGER *)&local_18);
  return local_14 ^ local_18 ^ local_8 ^ (uint)&local_8;
}



// Library Function - Single Match
//  ___security_init_cookie
// 
// Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release

void __cdecl ___security_init_cookie(void)

{
  if ((DAT_10012024 == 0xbb40e64e) || ((DAT_10012024 & 0xffff0000) == 0)) {
    DAT_10012024 = ___get_entropy();
    if (DAT_10012024 == 0xbb40e64e) {
      DAT_10012024 = 0xbb40e64f;
    }
    else if ((DAT_10012024 & 0xffff0000) == 0) {
      DAT_10012024 = DAT_10012024 | (DAT_10012024 | 0x4711) << 0x10;
    }
  }
  DAT_10012020 = ~DAT_10012024;
  return;
}



void FUN_1000b253(void)

{
  InitializeSListHead((PSLIST_HEADER)&DAT_100126b0);
  return;
}



// Library Function - Single Match
//  void __cdecl __scrt_uninitialize_type_info(void)
// 
// Library: Visual Studio 2017 Release

void __cdecl __scrt_uninitialize_type_info(void)

{
  __std_type_info_destroy_list(&DAT_100126b0);
  return;
}



undefined * FUN_1000b26b(void)

{
  return &DAT_100126b8;
}



// Library Function - Single Match
//  ___scrt_initialize_default_local_stdio_options
// 
// Library: Visual Studio 2017 Release

void ___scrt_initialize_default_local_stdio_options(void)

{
  uint *puVar1;
  
  puVar1 = (uint *)FUN_10005cd0();
  *puVar1 = *puVar1 | 4;
  puVar1[1] = puVar1[1];
  puVar1 = (uint *)FUN_1000b26b();
  *puVar1 = *puVar1 | 2;
  puVar1[1] = puVar1[1];
  return;
}



undefined * FUN_1000b28e(void)

{
  return &DAT_10012700;
}



// WARNING: Removing unreachable block (ram,0x1000b2a4)
// WARNING: Removing unreachable block (ram,0x1000b2a5)
// WARNING: Removing unreachable block (ram,0x1000b2ab)
// WARNING: Removing unreachable block (ram,0x1000b2b5)
// WARNING: Removing unreachable block (ram,0x1000b2bc)
// Library Function - Single Match
//  __RTC_Initialize
// 
// Library: Visual Studio 2017 Release

void __RTC_Initialize(void)

{
  return;
}



// WARNING: Removing unreachable block (ram,0x1000b2d0)
// WARNING: Removing unreachable block (ram,0x1000b2d1)
// WARNING: Removing unreachable block (ram,0x1000b2d7)
// WARNING: Removing unreachable block (ram,0x1000b2e1)
// WARNING: Removing unreachable block (ram,0x1000b2e8)
// Library Function - Single Match
//  __RTC_Terminate
// 
// Library: Visual Studio 2017 Release

void __RTC_Terminate(void)

{
  return;
}



// WARNING: This is an inlined function
// Library Function - Single Match
//  __alloca_probe
// 
// Libraries: Visual Studio 2015, Visual Studio 2017, Visual Studio 2019

void __alloca_probe(void)

{
  undefined *in_EAX;
  undefined4 *puVar1;
  undefined4 *puVar2;
  undefined4 unaff_retaddr;
  undefined auStack_4 [4];
  
  puVar2 = (undefined4 *)((int)&stack0x00000000 - (int)in_EAX & ~-(uint)(&stack0x00000000 < in_EAX))
  ;
  for (puVar1 = (undefined4 *)((uint)auStack_4 & 0xfffff000); puVar2 < puVar1;
      puVar1 = puVar1 + -0x400) {
  }
  *puVar2 = unaff_retaddr;
  return;
}



void Unwind_1000b323(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b323. Too many branches
                    // WARNING: Treating indirect jump as call
  __std_terminate();
  return;
}



void _CxxThrowException(void *pExceptionObject,ThrowInfo *pThrowInfo)

{
                    // WARNING: Could not recover jumptable at 0x1000b329. Too many branches
                    // WARNING: Subroutine does not return
                    // WARNING: Treating indirect jump as call
  _CxxThrowException(pExceptionObject,pThrowInfo);
  return;
}



void * __cdecl memset(void *_Dst,int _Val,size_t _Size)

{
  void *pvVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b32f. Too many branches
                    // WARNING: Treating indirect jump as call
  pvVar1 = memset(_Dst,_Val,_Size);
  return pvVar1;
}



void _except_handler4_common(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b335. Too many branches
                    // WARNING: Treating indirect jump as call
  _except_handler4_common();
  return;
}



void __std_exception_copy(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b33b. Too many branches
                    // WARNING: Treating indirect jump as call
  __std_exception_copy();
  return;
}



void __std_exception_destroy(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b341. Too many branches
                    // WARNING: Treating indirect jump as call
  __std_exception_destroy();
  return;
}



void __std_type_info_destroy_list(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b347. Too many branches
                    // WARNING: Treating indirect jump as call
  __std_type_info_destroy_list();
  return;
}



void __cdecl free(void *_Memory)

{
                    // WARNING: Could not recover jumptable at 0x1000b34d. Too many branches
                    // WARNING: Treating indirect jump as call
  free(_Memory);
  return;
}



void * __cdecl malloc(size_t _Size)

{
  void *pvVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b353. Too many branches
                    // WARNING: Treating indirect jump as call
  pvVar1 = malloc(_Size);
  return pvVar1;
}



int __cdecl _callnewh(size_t _Size)

{
  int iVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b359. Too many branches
                    // WARNING: Treating indirect jump as call
  iVar1 = _callnewh(_Size);
  return iVar1;
}



void _seh_filter_dll(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b35f. Too many branches
                    // WARNING: Treating indirect jump as call
  _seh_filter_dll();
  return;
}



void _configure_narrow_argv(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b365. Too many branches
                    // WARNING: Treating indirect jump as call
  _configure_narrow_argv();
  return;
}



void _initialize_narrow_environment(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b36b. Too many branches
                    // WARNING: Treating indirect jump as call
  _initialize_narrow_environment();
  return;
}



void _initialize_onexit_table(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b371. Too many branches
                    // WARNING: Treating indirect jump as call
  _initialize_onexit_table();
  return;
}



void _register_onexit_function(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b377. Too many branches
                    // WARNING: Treating indirect jump as call
  _register_onexit_function();
  return;
}



void _execute_onexit_table(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b37d. Too many branches
                    // WARNING: Treating indirect jump as call
  _execute_onexit_table();
  return;
}



void _crt_atexit(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b383. Too many branches
                    // WARNING: Treating indirect jump as call
  _crt_atexit();
  return;
}



void _initterm(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b38f. Too many branches
                    // WARNING: Treating indirect jump as call
  _initterm();
  return;
}



void _initterm_e(void)

{
                    // WARNING: Could not recover jumptable at 0x1000b395. Too many branches
                    // WARNING: Treating indirect jump as call
  _initterm_e();
  return;
}



BOOL IsProcessorFeaturePresent(DWORD ProcessorFeature)

{
  BOOL BVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b39b. Too many branches
                    // WARNING: Treating indirect jump as call
  BVar1 = IsProcessorFeaturePresent(ProcessorFeature);
  return BVar1;
}



undefined FUN_1000b3a1(void)

{
  return 1;
}



undefined4 FUN_1000b3a4(void)

{
  return 0;
}



// Library Function - Single Match
//  __alldiv
// 
// Library: Visual Studio

undefined8 __alldiv(uint param_1,uint param_2,uint param_3,uint param_4)

{
  ulonglong uVar1;
  longlong lVar2;
  uint uVar3;
  int iVar4;
  uint uVar5;
  uint uVar6;
  uint uVar7;
  uint uVar8;
  bool bVar10;
  char cVar11;
  uint uVar9;
  
  cVar11 = (int)param_2 < 0;
  if ((bool)cVar11) {
    bVar10 = param_1 != 0;
    param_1 = -param_1;
    param_2 = -(uint)bVar10 - param_2;
  }
  if ((int)param_4 < 0) {
    cVar11 = cVar11 + '\x01';
    bVar10 = param_3 != 0;
    param_3 = -param_3;
    param_4 = -(uint)bVar10 - param_4;
  }
  uVar3 = param_1;
  uVar5 = param_3;
  uVar6 = param_2;
  uVar9 = param_4;
  if (param_4 == 0) {
    uVar3 = param_2 / param_3;
    iVar4 = (int)(((ulonglong)param_2 % (ulonglong)param_3 << 0x20 | (ulonglong)param_1) /
                 (ulonglong)param_3);
  }
  else {
    do {
      uVar8 = uVar9 >> 1;
      uVar5 = uVar5 >> 1 | (uint)((uVar9 & 1) != 0) << 0x1f;
      uVar7 = uVar6 >> 1;
      uVar3 = uVar3 >> 1 | (uint)((uVar6 & 1) != 0) << 0x1f;
      uVar6 = uVar7;
      uVar9 = uVar8;
    } while (uVar8 != 0);
    uVar1 = CONCAT44(uVar7,uVar3) / (ulonglong)uVar5;
    iVar4 = (int)uVar1;
    lVar2 = (ulonglong)param_3 * (uVar1 & 0xffffffff);
    uVar3 = (uint)((ulonglong)lVar2 >> 0x20);
    uVar5 = uVar3 + iVar4 * param_4;
    if (((CARRY4(uVar3,iVar4 * param_4)) || (param_2 < uVar5)) ||
       ((param_2 <= uVar5 && (param_1 < (uint)lVar2)))) {
      iVar4 = iVar4 + -1;
    }
    uVar3 = 0;
  }
  if (cVar11 == '\x01') {
    bVar10 = iVar4 != 0;
    iVar4 = -iVar4;
    uVar3 = -(uint)bVar10 - uVar3;
  }
  return CONCAT44(uVar3,iVar4);
}



// Library Function - Single Match
//  __alldvrm
// 
// Library: Visual Studio

undefined8 __alldvrm(uint param_1,uint param_2,uint param_3,uint param_4)

{
  ulonglong uVar1;
  longlong lVar2;
  uint uVar3;
  int iVar4;
  uint uVar5;
  uint uVar6;
  uint uVar7;
  uint uVar8;
  bool bVar10;
  char cVar11;
  uint uVar9;
  
  cVar11 = (int)param_2 < 0;
  if ((bool)cVar11) {
    bVar10 = param_1 != 0;
    param_1 = -param_1;
    param_2 = -(uint)bVar10 - param_2;
  }
  if ((int)param_4 < 0) {
    cVar11 = cVar11 + '\x01';
    bVar10 = param_3 != 0;
    param_3 = -param_3;
    param_4 = -(uint)bVar10 - param_4;
  }
  uVar3 = param_1;
  uVar5 = param_3;
  uVar6 = param_2;
  uVar9 = param_4;
  if (param_4 == 0) {
    uVar3 = param_2 / param_3;
    iVar4 = (int)(((ulonglong)param_2 % (ulonglong)param_3 << 0x20 | (ulonglong)param_1) /
                 (ulonglong)param_3);
  }
  else {
    do {
      uVar8 = uVar9 >> 1;
      uVar5 = uVar5 >> 1 | (uint)((uVar9 & 1) != 0) << 0x1f;
      uVar7 = uVar6 >> 1;
      uVar3 = uVar3 >> 1 | (uint)((uVar6 & 1) != 0) << 0x1f;
      uVar6 = uVar7;
      uVar9 = uVar8;
    } while (uVar8 != 0);
    uVar1 = CONCAT44(uVar7,uVar3) / (ulonglong)uVar5;
    iVar4 = (int)uVar1;
    lVar2 = (ulonglong)param_3 * (uVar1 & 0xffffffff);
    uVar3 = (uint)((ulonglong)lVar2 >> 0x20);
    uVar5 = uVar3 + iVar4 * param_4;
    if (((CARRY4(uVar3,iVar4 * param_4)) || (param_2 < uVar5)) ||
       ((param_2 <= uVar5 && (param_1 < (uint)lVar2)))) {
      iVar4 = iVar4 + -1;
    }
    uVar3 = 0;
  }
  if (cVar11 == '\x01') {
    bVar10 = iVar4 != 0;
    iVar4 = -iVar4;
    uVar3 = -(uint)bVar10 - uVar3;
  }
  return CONCAT44(uVar3,iVar4);
}



// Library Function - Single Match
//  __allmul
// 
// Library: Visual Studio

ulonglong __allmul(uint param_1,uint param_2,uint param_3,uint param_4)

{
  if ((param_4 | param_2) == 0) {
    return (ulonglong)param_1 * (ulonglong)param_3;
  }
  return (ulonglong)param_1 * (ulonglong)param_3 & 0xffffffff |
         (ulonglong)
         ((int)((ulonglong)param_1 * (ulonglong)param_3 >> 0x20) +
         param_2 * param_3 + param_1 * param_4) << 0x20;
}



void * __cdecl memchr(void *_Buf,int _Val,size_t _MaxCount)

{
  void *pvVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b574. Too many branches
                    // WARNING: Treating indirect jump as call
  pvVar1 = memchr(_Buf,_Val,_MaxCount);
  return pvVar1;
}



void * __cdecl memcpy(void *_Dst,void *_Src,size_t _Size)

{
  void *pvVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b57a. Too many branches
                    // WARNING: Treating indirect jump as call
  pvVar1 = memcpy(_Dst,_Src,_Size);
  return pvVar1;
}



void * __cdecl memmove(void *_Dst,void *_Src,size_t _Size)

{
  void *pvVar1;
  
                    // WARNING: Could not recover jumptable at 0x1000b580. Too many branches
                    // WARNING: Treating indirect jump as call
  pvVar1 = memmove(_Dst,_Src,_Size);
  return pvVar1;
}



void Unwind_1000b590(void)

{
  int unaff_EBP;
  
  FUN_1000a4db(*(void **)(unaff_EBP + -0x10));
  return;
}



void Unwind_1000b5c0(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 0x20));
  return;
}



void Unwind_1000b5c8(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 8));
  return;
}



void Unwind_1000b5d0(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x100));
  return;
}



void Unwind_1000b5db(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b5e3(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x100));
  return;
}



void Unwind_1000b5ee(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b5f6(void)

{
  int unaff_EBP;
  
  FUN_1000a4db(*(void **)(unaff_EBP + -0x3c));
  return;
}



void Unwind_1000b605(void)

{
  int unaff_EBP;
  
  FUN_10001110((undefined4 *)(unaff_EBP + -0x3c));
  return;
}



void Unwind_1000b60d(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x100));
  return;
}



void Unwind_1000b618(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b620(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x100));
  return;
}



void Unwind_1000b62b(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b633(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b63b(void)

{
  int unaff_EBP;
  
  FUN_10001110((undefined4 *)(unaff_EBP + -0x44));
  return;
}



void Unwind_1000b643(void)

{
  int unaff_EBP;
  
  FUN_10001110((undefined4 *)(unaff_EBP + -0x34));
  return;
}



void Unwind_1000b64b(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x100));
  return;
}



void Unwind_1000b656(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b690(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x10) & 2) != 0) {
    *(uint *)(unaff_EBP + -0x10) = *(uint *)(unaff_EBP + -0x10) & 0xfffffffd;
    FUN_100019f0(*(void ***)(unaff_EBP + -0x14));
    return;
  }
  return;
}



void Unwind_1000b6d0(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x10) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x10) = *(uint *)(unaff_EBP + -0x10) & 0xfffffffe;
                    // WARNING: Could not recover jumptable at 0x1000b6e6. Too many branches
                    // WARNING: Treating indirect jump as call
    std::basic_ios<char,struct_std::char_traits<char>_>::
    _basic_ios_char_struct_std__char_traits_char___
              ((basic_ios_char_struct_std__char_traits_char___ *)
               (*(int *)(unaff_EBP + -0x14) + 0x68));
    return;
  }
  return;
}



void Unwind_1000b6ed(void)

{
  int unaff_EBP;
  
                    // WARNING: Could not recover jumptable at 0x1000b6f3. Too many branches
                    // WARNING: Treating indirect jump as call
  std::basic_iostream<char,struct_std::char_traits<char>_>::
  _basic_iostream_char_struct_std__char_traits_char___
            ((basic_iostream_char_struct_std__char_traits_char___ *)
             (*(int *)(unaff_EBP + -0x14) + 0x20));
  return;
}



void Unwind_1000b760(void)

{
  int unaff_EBP;
  
  FUN_10002380((int **)(unaff_EBP + -0x30));
  return;
}



void Unwind_1000b768(void)

{
  int unaff_EBP;
  
  FUN_100021e0((int **)(unaff_EBP + -0x30));
  return;
}



void Unwind_1000b790(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x10) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x10) = *(uint *)(unaff_EBP + -0x10) & 0xfffffffe;
    FUN_100019f0(*(void ***)(unaff_EBP + -0x1c));
    return;
  }
  return;
}



void Unwind_1000b7d0(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x2c));
  return;
}



void Unwind_1000b7d8(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x2c));
  return;
}



void Unwind_1000b810(void)

{
  int unaff_EBP;
  
  FUN_10002380((int **)(unaff_EBP + -0x2c));
  return;
}



void Unwind_1000b818(void)

{
  int unaff_EBP;
  
  FUN_100021e0((int **)(unaff_EBP + -0x2c));
  return;
}



void Unwind_1000b840(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b848(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000b850(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x30));
  return;
}



void Unwind_1000b880(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0xe0));
  return;
}



void Unwind_1000b88b(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x2c));
  return;
}



void Unwind_1000b8c0(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x134));
  return;
}



void Unwind_1000b8cb(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -100));
  return;
}



void Unwind_1000b900(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x14) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x14) = *(uint *)(unaff_EBP + -0x14) & 0xfffffffe;
    FUN_100019f0(*(void ***)(unaff_EBP + -0x18));
    return;
  }
  return;
}



void Unwind_1000b940(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 0x20));
  return;
}



void Unwind_1000b948(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 8));
  return;
}



void Unwind_1000b970(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0xc4));
  return;
}



void Unwind_1000b9a0(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x11c) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x11c) = *(uint *)(unaff_EBP + -0x11c) & 0xfffffffe;
    FUN_100019f0(*(void ***)(unaff_EBP + -0x120));
    return;
  }
  return;
}



void Unwind_1000b9f0(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 0x20));
  return;
}



void Unwind_1000b9f8(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 8));
  return;
}



void Unwind_1000ba00(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x838) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x838) = *(uint *)(unaff_EBP + -0x838) & 0xfffffffe;
    FUN_100019f0(*(void ***)(unaff_EBP + -0x840));
    return;
  }
  return;
}



void Unwind_1000ba22(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x828));
  return;
}



void Unwind_1000ba60(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + 8));
  return;
}



void Unwind_1000ba68(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x10));
  return;
}



void Unwind_1000ba90(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x158) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x158) = *(uint *)(unaff_EBP + -0x158) & 0xfffffffe;
    FUN_100019f0(*(void ***)(unaff_EBP + -0x15c));
    return;
  }
  return;
}



void Unwind_1000bae0(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x40));
  return;
}



void Unwind_1000bae8(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000bb20(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x38) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x38) = *(uint *)(unaff_EBP + -0x38) & 0xfffffffe;
    FUN_100059c0(*(int *)(unaff_EBP + -0x3c));
    return;
  }
  return;
}



void Unwind_1000bb60(void)

{
  int unaff_EBP;
  
  FUN_100059c0(unaff_EBP + -0x90);
  return;
}



void Unwind_1000bb6b(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x98) + 4));
  return;
}



void Unwind_1000bb79(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x98) + 0x1c));
  return;
}



void Unwind_1000bb87(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x98) + 0x34));
  return;
}



void Unwind_1000bb95(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x98) + 0x4c));
  return;
}



void Unwind_1000bbd0(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x2c));
  return;
}



void Unwind_1000bbd8(void)

{
  int unaff_EBP;
  
  FUN_10007be0((void **)(unaff_EBP + -0x68));
  return;
}



void Unwind_1000bc10(void)

{
  int unaff_EBP;
  
  FUN_10007b80((void **)(unaff_EBP + -0xac));
  return;
}



void Unwind_1000bc1b(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0xb0));
  return;
}



void Unwind_1000bc26(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x8c));
  return;
}



void Unwind_1000bc31(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x74));
  return;
}



void Unwind_1000bc39(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x44));
  return;
}



void Unwind_1000bc41(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x5c));
  return;
}



void Unwind_1000bc80(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x4c));
  return;
}



void Unwind_1000bc88(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x44));
  return;
}



void Unwind_1000bc90(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x104));
  return;
}



void Unwind_1000bc9b(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x50));
  return;
}



void Unwind_1000bca3(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000bce0(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x10) + 4));
  return;
}



void Unwind_1000bceb(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x10) + 0x1c));
  return;
}



void Unwind_1000bcf6(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x10) + 0x34));
  return;
}



void Unwind_1000bd01(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x10) + 0x4c));
  return;
}



void Unwind_1000bd30(void)

{
  int unaff_EBP;
  
  FUN_10008410((int *)(unaff_EBP + -0x38));
  return;
}



void Unwind_1000bd38(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x2c) + 4));
  return;
}



void Unwind_1000bd43(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x2c) + 0x1c));
  return;
}



void Unwind_1000bd4e(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x2c) + 0x34));
  return;
}



void Unwind_1000bd59(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + -0x2c) + 0x4c));
  return;
}



void Unwind_1000bd80(void)

{
  int unaff_EBP;
  
  FUN_10008410((int *)(unaff_EBP + -0x18));
  return;
}



void Unwind_1000bd88(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + 0x10) + 4));
  return;
}



void Unwind_1000bd93(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + 0x10) + 0x1c));
  return;
}



void Unwind_1000bd9e(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + 0x10) + 0x34));
  return;
}



void Unwind_1000bda9(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(*(int *)(unaff_EBP + 0x10) + 0x4c));
  return;
}



void Unwind_1000bdd0(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x10));
  return;
}



void Unwind_1000be00(void)

{
  int unaff_EBP;
  
  FUN_100019f0((void **)(unaff_EBP + -0x28));
  return;
}



void Unwind_1000be30(void)

{
  int unaff_EBP;
  
  if ((*(uint *)(unaff_EBP + -0x48) & 1) != 0) {
    *(uint *)(unaff_EBP + -0x48) = *(uint *)(unaff_EBP + -0x48) & 0xfffffffe;
    FUN_10008a90((void **)(unaff_EBP + -0x40));
    return;
  }
  return;
}



void Unwind_1000be70(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1148));
  return;
}



void Unwind_1000be7b(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1148));
  return;
}



void Unwind_1000be86(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1148));
  return;
}



void Unwind_1000be91(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1148));
  return;
}



void Unwind_1000be9c(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1148));
  return;
}



void Unwind_1000bed0(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0x1e4));
  return;
}



void Unwind_1000bedb(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x130));
  return;
}



void Unwind_1000bee6(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x134));
  return;
}



void Unwind_1000bef1(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x134));
  return;
}



void Unwind_1000bf30(void)

{
  int unaff_EBP;
  
  FUN_100019b0((int *)(unaff_EBP + -0xcc));
  return;
}



void Unwind_1000bf3b(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x18));
  return;
}



void Unwind_1000bf43(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1c));
  return;
}



void Unwind_1000bf4b(void)

{
  int unaff_EBP;
  
  FUN_100019f0(*(void ***)(unaff_EBP + -0x1c));
  return;
}